Do not derive encode/decode when discriminant doesn't fit u8.

[gui1117]

whe the discriminant doesn't fit u8 the derivation is wrong (more precisely: unexpected)

#[derive(Encode, Decode)]
#[repr(u32)]
enum ABC {
	D = 3u32,
}

#[repr(u32)]
enum ABC { D = 3u32, }
const _: () =
    {
        #[allow(unknown_lints)]
        #[allow(rust_2018_idioms)]
        extern crate parity_scale_codec as _parity_scale_codec;
        impl _parity_scale_codec::Encode for ABC {
            fn encode_to<__CodecOutputEdqy: _parity_scale_codec::Output +
                         ?Sized>(&self,
                                 __codec_dest_edqy: &mut __CodecOutputEdqy) {
                match *self {
                    ABC::D => {
                        __codec_dest_edqy.push_byte(3u32 as
                                                        ::core::primitive::u8);
                    }
                    _ => (),
                }
            }
        }
        impl _parity_scale_codec::EncodeLike for ABC { }
    };
const _: () =
    {
        #[allow(unknown_lints)]
        #[allow(rust_2018_idioms)]
        extern crate parity_scale_codec as _parity_scale_codec;
        impl _parity_scale_codec::Decode for ABC {
            fn decode<__CodecInputEdqy: _parity_scale_codec::Input>(__codec_input_edqy:
                                                                        &mut __CodecInputEdqy)
             -> ::core::result::Result<Self, _parity_scale_codec::Error> {
                match __codec_input_edqy.read_byte().map_err(|e|
                                                                 e.chain("Could not decode `ABC`, failed to read variant byte"))?
                    {
                    __codec_x_edqy if
                    __codec_x_edqy == 3u32 as ::core::primitive::u8 => {
                        ::core::result::Result::Ok(ABC::D)
                    }
                    _ =>
                    ::core::result::Result::Err("Could not decode `ABC`, variant doesn\'t exist".into()),
                }
            }
        }
    };

I think we can use From::from instead of as maybe but it is probably a breaking change.

[ascjones]

It's already protected against overflows, you will get the following error:

On a related note, do we want to be able to support derived encoding for larger repr discriminants?

[gui1117]

I tried to compile:

#[derive(Encode, Decode)]
#[repr(u32)]
enum ABC {
	D = 300_000u32,
}

I didn't get any compile error, how did you get it ?

[gui1117]

On a related note, do we want to be able to support derived encoding for larger repr discriminants?

I was thinking maybe we should reserve the index: u8::max_value() for such a case

[ascjones]

I didn't get any compile error, how did you get it ?

I added a variant to IdentityFields https://github.com/paritytech/substrate/blob/686dd77ce530af2131402683b29974c74eb23e8f/frame/identity/src/types.rs#L243

Maybe you only get that for binary literals.

[ascjones]

I was thinking maybe we should reserve the index: u8::max_value() for such a case

It's a good idea, though would break any existing 256 variant enums 😁

[gui1117]

yes it is breaking enums which uses the index 255, even if it contained less variants.

[bkchr]

Do we see repr(u32) in the attributes?