fix compact encoding on structs

[tadeohepperle]

In subxt we had issues decoding structs that have compact encoded fields, which are other struct (see Issue 1034).

This PR changes the way compact decoding works by passing an is_compact flag around recursively while decoding data (entry point: decode_with_visitor_maybe_compact(..) in decode.rs).

This code snippet (see Issue 1034) did not work previously, but now runs without issue:

use codec::{CompactAs, Decode, Encode};
use scale_decode::DecodeAsType;
use scale_encode::EncodeAsType;
use scale_info::TypeInfo;

#[derive(CompactAs, Decode, Encode, DecodeAsType, EncodeAsType, Debug, TypeInfo)]
pub struct Perbill(pub ::core::primitive::u32);

#[derive(Decode, Encode, DecodeAsType, EncodeAsType, Debug, TypeInfo)]
pub struct ValidatorPrefs {
    #[codec(compact)]
    pub commission: Perbill,
    pub blocked: ::core::primitive::bool,
}

fn make_type<T: scale_info::TypeInfo + 'static>() -> (u32, scale_info::PortableRegistry) {
    let m = scale_info::MetaType::new::<T>();
    let mut types = scale_info::Registry::new();
    let id = types.register_type(&m);
    let portable_registry: scale_info::PortableRegistry = types.into();
    (id.id, portable_registry)
}

fn main() {
    let val: ValidatorPrefs = ValidatorPrefs {
        commission: Perbill(22),
        blocked: true,
    };
    let (id, val_pref_registry) = make_type::<ValidatorPrefs>();
    let val_bytes = val.encode();
    let val_or_err = ValidatorPrefs::decode_as_type(&mut &val_bytes[..], id, &val_pref_registry);
    assert!(val_or_err.is_ok());
}

[jsdw]

Personally for this and the matches! above, I'd be tempted to do something like define this here:

macro_rules err_if_compact! {
    () => {
        if is_compact {
            return Err(DecodeError::CannotDecodeCompactIntoType(ty.clone().into()).into());
        }
    }
}

And then in each branch wehre it applies:

match ty {
    // ...
    TypeDefPrimitive::Bool => {
        err_if_compact!();
        // usual logic here
    }
    // ...
}

The reason for this is so that it's very clear that all of the branches that don't want/have any special compact logic are guarded right there, rather than having the check a little bit away from where it's protecting :)

(also it saves us a match but that's not a big deal)

The macro could be defined to take in the ty it'll clone and put in the error too, and then used both here and above perhaps.

[jsdw]

let's add #[doc(hidden)] to this, because I hope that it's only really needed for internal use, and it'd be nice if people only saw/used decode_as_type :)

[jsdw]

Cool! It's good to see this works :)

[jsdw]

Nice to see this tested too!

[jsdw]

A couple of tiny things but overall this looks great; nice work!

[jsdw]

Nice!