Cleanup

src/meta_type.rs

@@ -96,7 +96,6 @@ impl MetaType {
         }
     }
 
-    // TODO: is this used anywhere?
     /// Creates a new meta type from the type of the given reference.
     pub fn of<T>(_elem: &T) -> Self
     where

src/tests.rs

@@ -81,14 +81,11 @@ fn prelude_items() {
             .type_params(tuple_meta_type!(i32))
             .composite(Fields::unit())
     );
-}
 
-#[test]
-fn compact_types() {
     assert_type!(
-        scale::Compact<i32>,
+        prelude::Compact<i32>,
         Type::builder()
-            .path(Path::from_segments(vec!["scale", "Compact"]).unwrap())
+            .path(Path::prelude("Compact"))
             .type_params(tuple_meta_type!(i32))
             .compact::<i32>()
     );

src/ty/fields.rs

@@ -143,9 +143,6 @@ impl Field {
     where
         T: TypeInfo + 'static,
     {
-        // TODO: using `scale::Compact` here like this makes the `impl<T>
-        // TypeInfo for Compact<T>` kick in, but not sure that is the right
-        // thing to do. :/
         Self::new(name, MetaType::new::<scale::Compact<T>>(), type_name)
     }
 }

src/ty/mod.rs

@@ -121,8 +121,7 @@ impl From<TypeDefTuple> for Type {
 impl From<TypeDefCompact> for Type {
     fn from(compact: TypeDefCompact) -> Self {
         Self::new(
-            // TODO: put `Compact` in the prelude
-            Path::new("Compact", "scale"),
+            Path::prelude("Compact"),
             vec![compact.type_param],
             compact,
         )

test_suite/tests/derive.rs

@@ -17,7 +17,10 @@ use pretty_assertions::assert_eq;
 use scale::Encode;
 use scale_info::{
     build::*,
-    prelude::boxed::Box,
+    prelude::{
+        boxed::Box,
+        Compact,
+    },
     tuple_meta_type,
     Path,
     Type,
@@ -214,36 +217,29 @@ fn scale_compact_types_work_in_structs() {
         b: u16,
     }
 
-    let dense = Type::builder()
+    let ty = Type::builder()
         .path(Path::new("Dense", "derive"))
         .composite(
             Fields::named()
                 .field_of::<u8>("a", "u8")
-                .field_of::<scale::Compact<u16>>("b", "u16"),
+                .field_of::<Compact<u16>>("b", "u16"),
         );
 
-    assert_type!(Dense, dense);
-}
+    assert_type!(Dense, ty);
 
-// TODO: both this test and the one above pass, which means something's not
-// right.
-#[test]
-fn wip() {
-    #[allow(unused)]
-    #[derive(Encode, TypeInfo)]
-    struct A {
-        a: u8,
-        #[codec(compact)]
-        b: u16,
-    }
-    let ty = Type::builder()
-        .path(Path::new("A", "derive"))
-        .composite(
-            Fields::named()
-                .field_of::<u8>("a", "u8")
-                .compact_of::<u16>("b", "u16")
-        );
-    assert_type!(A, ty);
+    // TODO: These two tests both pass. This illustrates a doubt I have that
+    // this is the right way to go. With this PR we take `#[codec(compact)]` to
+    // mean that the type is encoded/decoded as `Compact<T>` but in reality the
+    // output of the `Encode` macro is something quite different and not
+    // `Compact<T>`.
+    // Maybe this is fine, maybe it's not, just not sure.
+
+    let ty_alt = Type::builder().path(Path::new("Dense", "derive")).composite(
+        Fields::named()
+            .field_of::<u8>("a", "u8")
+            .compact_of::<u16>("b", "u16"),
+    );
+    assert_type!(Dense, ty_alt);
 }
 
 #[test]

test_suite/tests/json.rs

@@ -381,7 +381,7 @@ fn registry_knows_about_compact_types() {
                 }
             },
             { // type 2, the `Compact<u128>` of field `a`.
-                "path": ["scale", "Compact"],
+                "path": ["Compact"],
                 "def": { "compact": { "type": 3 } },
                 "params": [3]
             },
@@ -395,7 +395,7 @@ fn registry_knows_about_compact_types() {
                 "def": { "primitive": "u8" }
             },
             { // type 6, the `Compact<u64>` of field `c`
-                "path": ["scale", "Compact"],
+                "path": ["Compact"],
                 "def": { "compact": { "type": 7 } },
                 "params": [7]
             },