Handle more SCALE attributes: skip, index

derive/src/utils.rs

@@ -38,7 +38,7 @@ pub fn variant_index(v: &Variant, i: usize) -> TokenStream {
                 if let Lit::Int(ref v) = nv.lit {
                     let byte = v
                         .base10_parse::<u8>()
-                        .expect("Internal error, index attribute must have been checked");
+                        .expect("Internal error. `#[codec(index = …)]` attribute syntax must be checked in `parity-scale-codec`. This is a bug.");
                     return Some(byte)
                 }
             }
@@ -56,7 +56,7 @@ pub fn variant_index(v: &Variant, i: usize) -> TokenStream {
     })
 }
 
-// /// Look for a `#[codec(compact)]` outer attribute on the given `Field`.
+/// Look for a `#[codec(compact)]` outer attribute on the given `Field`.
 pub fn is_compact(field: &syn::Field) -> bool {
     let outer_attrs = field
         .attrs
@@ -97,7 +97,7 @@ where
         if attr.path.is_ident("codec") {
             if let Meta::List(ref meta_list) = attr
                 .parse_meta()
-                .expect("Internal error, parse_meta must have been checked")
+                .expect("Internal error. `#[codec(…)]` attributes must be checked in `parity-scale-codec`. This is a bug.")
             {
                 return meta_list.nested.iter().filter_map(pred.clone()).next()
             }

src/tests.rs

@@ -183,103 +183,3 @@ fn basic_struct_with_phantoms() {
 
     assert_type!(SomeStruct<bool>, struct_bool_type_info);
 }
-
-#[test]
-fn basic_c_like_enum() {
-    #[allow(unused)]
-    enum BasicCStyleEnum {
-        A,
-        B,
-    }
-
-    impl TypeInfo for BasicCStyleEnum {
-        type Identity = Self;
-
-        fn type_info() -> Type {
-            Type::builder()
-                .path(Path::new("BasicCStyleEnum", module_path!()))
-                .variant(Variants::fieldless().variant("A", 0).variant("B", 1))
-        }
-    }
-
-    let ty = Type::builder()
-        .path(
-            Path::from_segments(vec!["scale_info", "tests", "BasicCStyleEnum"]).unwrap(),
-        )
-        .variant(Variants::fieldless().variant("A", 0).variant("B", 1));
-
-    assert_type!(BasicCStyleEnum, ty);
-}
-
-#[test]
-fn c_like_enum_with_discriminant_override() {
-    #[allow(unused)]
-    enum CStyleEnum {
-        A = 3,
-        B = 0,
-    }
-
-    impl TypeInfo for CStyleEnum {
-        type Identity = Self;
-
-        fn type_info() -> Type {
-            Type::builder()
-                .path(Path::new("CStyleEnum", module_path!()))
-                .variant(Variants::fieldless().variant("A", 3).variant("B", 0))
-        }
-    }
-
-    let ty = Type::builder()
-        .path(Path::from_segments(vec!["scale_info", "tests", "CStyleEnum"]).unwrap())
-        .variant(Variants::fieldless().variant("A", 3).variant("B", 0));
-
-    assert_type!(CStyleEnum, ty);
-}
-
-#[test]
-fn basic_enum() {
-    #[allow(unused)]
-    enum RustEnum {
-        A(bool),
-        B { b: u8 },
-        C(u16, u32),
-        D,
-    }
-    impl TypeInfo for RustEnum {
-        type Identity = Self;
-
-        fn type_info() -> Type {
-            Type::builder()
-                .path(Path::new("RustEnum", module_path!()))
-                .variant(
-                    Variants::with_fields()
-                        .variant("A", Fields::unnamed().field_of::<bool>("bool"))
-                        .variant("B", Fields::named().field_of::<u8>("b", "bool"))
-                        .variant(
-                            "C",
-                            Fields::unnamed()
-                                .field_of::<u16>("u16")
-                                .field_of::<u32>("u32"),
-                        )
-                        .variant_unit("D"),
-                )
-        }
-    }
-
-    let ty = Type::builder()
-        .path(Path::new("RustEnum", module_path!()))
-        .variant(
-            Variants::with_fields()
-                .variant("A", Fields::unnamed().field_of::<bool>("bool"))
-                .variant("B", Fields::named().field_of::<u8>("b", "bool"))
-                .variant(
-                    "C",
-                    Fields::unnamed()
-                        .field_of::<u16>("u16")
-                        .field_of::<u32>("u32"),
-                )
-                .variant_unit("D"),
-        );
-
-    assert_type!(RustEnum, ty);
-}

src/ty/variant.rs

@@ -60,7 +60,7 @@ use serde::{
 ///     Monday,
 ///     Tuesday,
 ///     Wednesday,
-///     Thursday = 42, // Also allows to manually set the discriminant!
+///     Thursday = 42, // Allows setting the discriminant explicitly
 ///     Friday,
 ///     Saturday,
 ///     Sunday,

test_suite/tests/derive.rs

@@ -151,13 +151,18 @@ fn c_like_enum_derive_with_scale_index_set() {
         B = 10,
         #[codec(index = 13)]
         C,
+        D,
+        #[codec(index = 14)]
+        E = 15,
     }
 
     let ty = Type::builder().path(Path::new("E", "derive")).variant(
         Variants::fieldless()
-            .variant("A", 0u64)
-            .variant("B", 10u64)
-            .variant("C", 13u64),
+            .variant("A", 0)
+            .variant("B", 10)
+            .variant("C", 13)
+            .variant("D", 3)
+            .variant("E", 14),
     );
 
     assert_type!(E, ty);

test_suite/tests/ui/fail_with_invalid_codec_attrs.stderr

@@ -16,4 +16,4 @@ error: proc-macro derive panicked
 11 | #[derive(TypeInfo, Encode)]
    |          ^^^^^^^^
    |
-   = help: message: Internal error, parse_meta must have been checked: Error("expected literal")
+   = help: message: Internal error. `#[codec(…)]` attributes must be checked in `parity-scale-codec`. This is a bug.: Error("expected literal")