Cleanup

src/build.rs

@@ -248,18 +248,6 @@ impl<T> FieldsBuilder<T> {
     pub fn finalize(self) -> Vec<Field<MetaForm>> {
         self.fields
     }
-
-    /// Mark last field as compact, meaning that encoding/decoding should be in the [`scale_codec::Compact`] format.
-    pub fn compact(mut self) -> Self {
-        self.fields
-            .iter_mut()
-            .last()
-            .and_then(|f| {
-                f.compact();
-                Some(f)
-            });
-        self
-    }
 }
 
 impl FieldsBuilder<NamedFields> {

src/tests.rs

@@ -154,34 +154,3 @@ fn struct_with_generics() {
         .composite(Fields::named().field_of::<Box<MyStruct<bool>>>("data", "T"));
     assert_type!(SelfTyped, expected_type);
 }
-
-// TODO: dp remove this or make it actually test something
-#[test]
-fn struct_with_compact() {
-    use scale::Encode;
-    // use scale::Compact;
-    #[allow(unused)]
-    #[derive(Encode)]
-    struct Thicc {
-        #[codec(compact)]
-        stuff: u8,
-        moar: u16,
-    }
-
-    impl TypeInfo for Thicc {
-        type Identity = Self;
-
-        fn type_info() -> Type {
-            Type::builder()
-                .path(Path::new("Thicc", module_path!()))
-                .composite(
-                    Fields::named()
-                        .field_of::<u8>("stuff", "u8").compact()
-                        .field_of::<u16>("moar", "u16")
-                )
-        }
-    }
-
-    fn assert_type_info<T: TypeInfo + 'static>() {}
-    assert_type_info::<Thicc>();
-}

src/ty/fields.rs

@@ -86,18 +86,6 @@ pub struct Field<T: Form = MetaForm> {
     ty: T::Type,
     /// The name of the type of the field as it appears in the source code.
     type_name: T::String,
-    /// This field should be encode/decoded as a
-    /// [`Compact`](parity_scale_codec::Compact) field
-    #[cfg_attr(
-        feature = "serde",
-        serde(skip_serializing_if = "is_false", default)
-    )]
-    compact: bool,
-}
-
-/// TODO: There must be a better way than this
-fn is_false(v: &bool) -> bool {
-    !(*v)
 }
 
 impl IntoFrozen for Field {
@@ -108,7 +96,6 @@ impl IntoFrozen for Field {
             name: self.name.map(|name| name.into_frozen(registry)),
             ty: registry.register_type(&self.ty),
             type_name: self.type_name.into_frozen(registry),
-            compact: self.compact,
         }
     }
 }
@@ -121,13 +108,11 @@ impl Field {
         name: Option<&'static str>,
         ty: MetaType,
         type_name: &'static str,
-        // TODO: dp add compact arg (and use it)
     ) -> Self {
         Self {
             name,
             ty,
             type_name,
-            compact: false,
         }
     }
 
@@ -152,12 +137,6 @@ impl Field {
     {
         Self::new(None, MetaType::new::<T>(), type_name)
     }
-
-    /// Set the `compact` property to true, signalling that this type is to be
-    /// encoded/decoded as [`Compact`](parity_scale_codec::Compact).
-    pub fn compact(&mut self) {
-        self.compact = true;
-    }
 }
 
 impl<T> Field<T>

test_suite/tests/derive.rs

@@ -216,158 +216,3 @@ fn ui_tests() {
     t.pass("tests/ui/pass_basic_generic_type.rs");
     t.pass("tests/ui/pass_complex_generic_self_referential_type.rs");
 }
-
-// TODO: dp Make useful or remove
-#[test]
-fn substrate_example() {
-    use scale::{
-        // Decode,
-        Encode, Compact,
-    };
-    use scale_info::prelude::vec::Vec;
-    // #[allow(unused)]
-    // type AccountIndex = u32;
-    /// A multi-format address wrapper for on-chain accounts.
-    #[allow(unused)]
-    // #[derive(Encode, Decode, PartialEq, Eq, Clone, TypeInfo)]
-    #[derive(Encode, TypeInfo)]
-    #[cfg_attr(feature = "std", derive(Hash))]
-    pub enum MultiAddress<AccountId, AccountIndex> {
-        /// It's an account ID (pubkey).
-        Id(AccountId),
-        /// It's an account index.
-        // Index(#[codec(compact)] AccountIndex),
-        Index(Compact<AccountIndex>),
-        /// It's some arbitrary raw bytes.
-        Raw(Vec<u8>),
-        /// It's a 32 byte representation.
-        Address32([u8; 32]),
-        /// Its a 20 byte representation.
-        Address20([u8; 20]),
-    }
-
-    let _ma = MultiAddress::<u64, u32>::Id(32);
-}
-
-// #[ignore]
-// fn substrate_example_expanded() {
-//     use scale::{Decode, Encode, Compact};
-//     use scale_info::prelude::vec::Vec;
-//     /// A multi-format address wrapper for on-chain accounts.
-//     #[allow(unused)]
-//     pub enum MultiAddress<AccountId, AccountIndex> {
-//         /// It's an account ID (pubkey).
-//         Id(AccountId),
-//         /// It's an account index.
-//         // Index(#[codec(compact)] AccountIndex),
-//         Index(Compact<AccountIndex>),
-//         /// It's some arbitrary raw bytes.
-//         Raw(Vec<u8>),
-//         /// It's a 32 byte representation.
-//         Address32([u8; 32]),
-//         /// Its a 20 byte representation.
-//         Address20([u8; 20]),
-//     }
-
-//     const _IMPL_TYPE_INFO_FOR_MultiAddress: () = {
-//         impl<
-//                 AccountId: ::scale_info::TypeInfo + 'static,
-//                 AccountIndex: ::scale_info::TypeInfo + 'static,
-//             > ::scale_info::TypeInfo for MultiAddress<AccountId, AccountIndex>
-//         where
-//             AccountId: ::scale_info::TypeInfo + 'static,
-//             AccountIndex: ::scale_info::TypeInfo + 'static,
-//         {
-//             type Identity = Self;
-//             fn type_info() -> ::scale_info::Type {
-//                 ::scale_info::Type::builder()
-//                     .path(::scale_info::Path::new("MultiAddress", "derive"))
-//                     .type_params(<[_]>::into_vec(box [
-//                         ::scale_info::meta_type::<AccountId>(),
-//                         ::scale_info::meta_type::<AccountIndex>(),
-//                     ]))
-//                     .variant(
-//                         ::scale_info::build::Variants::with_fields()
-//                             .variant(
-//                                 "Id",
-//                                 ::scale_info::build::Fields::unnamed()
-//                                     .field_of::<AccountId>("AccountId"),
-//                             )
-//                             .variant(
-//                                 "Index",
-//                                 ::scale_info::build::Fields::unnamed()
-//                                     .field_of::<AccountIndex>("AccountIndex"),
-//                             )
-//                             .variant(
-//                                 "Raw",
-//                                 ::scale_info::build::Fields::unnamed()
-//                                     .field_of::<Vec<u8>>("Vec<u8>"),
-//                             )
-//                             .variant(
-//                                 "Address32",
-//                                 ::scale_info::build::Fields::unnamed()
-//                                     .field_of::<[u8; 32]>("[u8; 32]"),
-//                             )
-//                             .variant(
-//                                 "Address20",
-//                                 ::scale_info::build::Fields::unnamed()
-//                                     .field_of::<[u8; 20]>("[u8; 20]"),
-//                             ),
-//                     )
-//                     .into()
-//             }
-//         };
-//     };
-
-//     const _: () = {
-//         #[allow(unknown_lints)]
-//         #[allow(rust_2018_idioms)]
-//         extern crate scale as _parity_scale_codec;
-//         impl<AccountId, AccountIndex> _parity_scale_codec::Encode for MultiAddress<AccountId, AccountIndex>
-//         where
-//             AccountId: _parity_scale_codec::Encode,
-//             AccountId: _parity_scale_codec::Encode,
-//             AccountIndex: _parity_scale_codec::HasCompact,
-//         {
-//             fn encode_to<__CodecOutputEdqy: _parity_scale_codec::Output>(
-//                 &self,
-//                 __codec_dest_edqy: &mut __CodecOutputEdqy,
-//             ) {
-//                 match *self {
-//                     MultiAddress::Id(ref aa) => {
-//                         __codec_dest_edqy.push_byte(0usize as u8);
-//                         __codec_dest_edqy.push(aa);
-//                     }
-//                     MultiAddress::Index(ref aa) => {
-//                         __codec_dest_edqy.push_byte(1usize as u8);
-//                         {
-//                             __codec_dest_edqy.push (&<<AccountIndex as _parity_scale_codec::HasCompact>::Type as _parity_scale_codec::EncodeAsRef< '_ , AccountIndex >>::RefType::from(aa));
-//                         }
-//                     }
-//                     MultiAddress::Raw(ref aa) => {
-//                         __codec_dest_edqy.push_byte(2usize as u8);
-//                         __codec_dest_edqy.push(aa);
-//                     }
-//                     MultiAddress::Address32(ref aa) => {
-//                         __codec_dest_edqy.push_byte(3usize as u8);
-//                         __codec_dest_edqy.push(aa);
-//                     }
-//                     MultiAddress::Address20(ref aa) => {
-//                         __codec_dest_edqy.push_byte(4usize as u8);
-//                         __codec_dest_edqy.push(aa);
-//                     }
-//                     _ => (),
-//                 }
-//             }
-//         }
-//         impl<AccountId, AccountIndex> _parity_scale_codec::EncodeLike
-//             for MultiAddress<AccountId, AccountIndex>
-//         where
-//             AccountId: _parity_scale_codec::Encode,
-//             AccountId: _parity_scale_codec::Encode,
-//             AccountIndex: _parity_scale_codec::HasCompact,
-//         {
-//         }
-//     };
-//     let _ma = MultiAddress::<u64, u32>::Id(32);
-// }

test_suite/tests/json.rs

@@ -196,49 +196,6 @@ fn test_struct() {
     }));
 }
 
-#[test]
-fn test_struct_with_some_fields_marked_as_compact() {
-    use scale::Encode;
-
-    // #[derive(TypeInfo, Encode)]
-    #[derive(Encode)]
-    struct Dense {
-        #[codec(compact)]
-        a: u128,
-        b: [u8; 32],
-        #[codec(compact)]
-        c: u64,
-    }
-    use scale_info::{Type, Path, build::Fields};
-    impl TypeInfo for Dense {
-        type Identity = Self;
-        fn type_info() -> Type {
-            Type::builder()
-                .path(Path::new("Dense", module_path!()))
-                .composite(
-                    Fields::named()
-                        .field_of::<u8>("a", "i32").compact()
-                        .field_of::<[u8; 32]>("b", "[u8; 32]")
-                        .field_of::<u64>("c", "u64").compact()
-                )
-                // .into() // <–– TODO: dp I don't think we need these `.into()`s anymore.
-        }
-    }
-
-    assert_json_for_type::<Dense>(json![{
-        "path": ["json", "Dense"],
-        "def": {
-            "composite": {
-                "fields": [
-                    { "name": "a", "type": 1, "typeName": "i32", "compact": true },
-                    { "name": "b", "type": 2, "typeName": "[u8; 32]" },
-                    { "name": "c", "type": 3, "typeName": "u64", "compact": true },
-                ],
-            },
-        }
-    }]);
-}
-
 #[test]
 fn test_clike_enum() {
     #[derive(TypeInfo)]