Validate Codegen Settings

Cargo.toml

@@ -31,7 +31,7 @@ prettyplease = "0.2.15"
 scale-decode = "0.9.0"
 scale-encode = "0.5.0"
 frame-metadata = { version = "16.0.0", default-features = false, features = ["current", "std"] }
-bitvec = { version = "1", default-features = false }
+bitvec = { version = "1", default-features = false, features = ["alloc"] }
 pretty_assertions = "1.4.0"
 anyhow = "1.0.75"
 peekmore = "1.3.0"

typegen/src/tests/mod.rs

@@ -7,7 +7,13 @@ use syn::parse_quote;
 
 use crate::{
     tests::utils::{subxt_settings, Testgen},
-    typegen::settings::TypeGeneratorSettings,
+    typegen::{
+        error::SettingsValidationError,
+        settings::TypeGeneratorSettings,
+        validation::{
+            similar_type_paths_in_registry, validate_substitutes_and_derives_against_registry,
+        },
+    },
     utils::ensure_unique_type_paths,
     DerivesRegistry, TypeSubstitutes,
 };
@@ -1260,3 +1266,113 @@ fn ensure_unique_type_paths_test() {
         ]
     );
 }
+
+#[test]
+fn validation_errors() {
+    #[allow(unused)]
+    #[derive(TypeInfo)]
+    struct S;
+
+    let registry = Testgen::new().with::<S>().into_portable_registry();
+    let mut settings = TypeGeneratorSettings::new();
+    settings.derives = {
+        let mut d = DerivesRegistry::new();
+        d.add_derives_for(
+            parse_quote!(scale_typegen::tests::S),
+            [parse_quote!(Clone), parse_quote!(Reflect)],
+            true,
+        );
+
+        d.add_attributes_for(
+            parse_quote!(scale_typegen::tests::S),
+            [parse_quote!(#[nice])],
+            true,
+        );
+
+        d.add_derives_for(
+            parse_quote!(scale_typegen::tests::T),
+            [parse_quote!(Clone), parse_quote!(Reflect)],
+            true,
+        );
+
+        d.add_attributes_for(
+            parse_quote!(scale_typegen::tests::T),
+            [parse_quote!(#[nice])],
+            true,
+        );
+        d
+    };
+    settings = settings
+        .substitute(
+            parse_quote!(scale_typegen::tests::S),
+            parse_quote!(::hello::S),
+        )
+        .substitute(
+            parse_quote!(scale_typegen::tests::T),
+            parse_quote!(::hello::T),
+        );
+
+    let err = validate_substitutes_and_derives_against_registry(
+        &settings.substitutes,
+        &settings.derives,
+        &registry,
+    )
+    .unwrap_err();
+
+    // we expect only errors for type T because S is in the registry, T is not.
+    let expected_err = SettingsValidationError {
+        derives_for_unknown_types: vec![(
+            parse_quote!(scale_typegen::tests::T),
+            [parse_quote!(Clone), parse_quote!(Reflect)].into(),
+        )],
+        attributes_for_unknown_types: vec![(
+            parse_quote!(scale_typegen::tests::T),
+            [parse_quote!(#[nice])].into(),
+        )],
+        substitutes_for_unknown_types: vec![(
+            parse_quote!(scale_typegen::tests::T),
+            parse_quote!(::hello::T),
+        )],
+    };
+
+    assert_eq!(err, expected_err);
+}
+
+#[test]
+fn find_similar_type_paths() {
+    #[allow(unused)]
+    #[derive(TypeInfo)]
+    struct S;
+    mod types {
+        #[allow(unused)]
+        #[derive(scale_info::TypeInfo)]
+        pub struct T;
+
+        #[allow(unused)]
+        #[derive(scale_info::TypeInfo)]
+        pub struct S;
+
+        pub mod abc {
+            #[allow(unused)]
+            #[derive(scale_info::TypeInfo)]
+            pub struct S;
+        }
+    }
+
+    let registry = Testgen::new()
+        .with::<S>()
+        .with::<types::S>()
+        .with::<types::T>()
+        .with::<types::abc::S>()
+        .into_portable_registry();
+
+    // user gives the wrong type location types::xyz::S => show them suggestions for correct paths.
+    let similar = similar_type_paths_in_registry(&registry, &parse_quote!(types::xyz::S));
+
+    let expected: Vec<syn::Path> = vec![
+        parse_quote!(scale_typegen::tests::S),
+        parse_quote!(scale_typegen::tests::types::S),
+        parse_quote!(scale_typegen::tests::types::abc::S),
+    ];
+    assert_eq!(similar, expected);
+}

typegen/src/typegen/error.rs

@@ -1,4 +1,7 @@
+use std::collections::HashSet;
+
 use proc_macro2::Span;
+use quote::ToTokens;
 
 /// Error for when something went wrong during type generation.
 #[derive(Debug, thiserror::Error)]
@@ -25,6 +28,9 @@ pub enum TypegenError {
     /// Type substitution error.
     #[error("Type substitution error: {0}")]
     InvalidSubstitute(#[from] TypeSubstitutionError),
+    /// The settings do not fit the given type registry.
+    #[error("Settings do not fit the given type registry: {0}")]
+    SettingsValidation(SettingsValidationError),
 }
 
 /// Error attempting to do type substitution.
@@ -68,3 +74,80 @@ pub enum TypeSubstitutionErrorKind {
     #[error("Cannot find matching param on 'from' type.")]
     NoMatchingFromType,
 }
+
+/// Error attempting to do type substitution.
+#[derive(Debug, thiserror::Error, Default, PartialEq, Eq)]
+pub struct SettingsValidationError {
+    /// Cannot add derive for type that is not present in the registry.
+    pub derives_for_unknown_types: Vec<(syn::Path, HashSet<syn::Path>)>,
+    /// Cannot add attribute for type that is not present in the registry.
+    pub attributes_for_unknown_types: Vec<(syn::Path, HashSet<syn::Attribute>)>,
+    /// Invalid path to replace: the type getting substituted is not present in the registry.
+    pub substitutes_for_unknown_types: Vec<(syn::Path, syn::Path)>,
+}
+
+impl std::fmt::Display for SettingsValidationError {
+    fn fmt(
+        &self,
+        f: &mut scale_info::prelude::fmt::Formatter<'_>,
+    ) -> scale_info::prelude::fmt::Result {
+        fn display_one(e: &impl ToTokens) -> String {
+            e.to_token_stream().to_string().replace(' ', "")
+        }
+
+        fn display_many(set: &HashSet<impl ToTokens>) -> String {
+            set.iter()
+                .map(|e| display_one(e))
+                .collect::<Vec<_>>()
+                .join(", ")
+        }
+
+        writeln!(f, "Settings validation error:")?;
+
+        if !self.derives_for_unknown_types.is_empty() {
+            writeln!(f, "  Derives for unknown types:")?;
+            for (path, derives) in &self.derives_for_unknown_types {
+                writeln!(
+                    f,
+                    "    {} (Derives: {})",
+                    display_one(path),
+                    display_many(derives)
+                )?;
+            }
+        }
+
+        if !self.attributes_for_unknown_types.is_empty() {
+            writeln!(f, "  Attributes for unknown types:")?;
+            for (path, attributes) in &self.attributes_for_unknown_types {
+                writeln!(
+                    f,
+                    "    {} (Attributes: {})",
+                    display_one(path),
+                    display_many(attributes)
+                )?;
+            }
+        }
+
+        if !self.substitutes_for_unknown_types.is_empty() {
+            writeln!(f, "  Substitutes for unknown types:")?;
+            for (original, substitute) in &self.substitutes_for_unknown_types {
+                writeln!(
+                    f,
+                    "    {} (Substitute: {})",
+                    display_one(original),
+                    display_one(substitute),
+                )?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl SettingsValidationError {
+    pub(crate) fn is_empty(&self) -> bool {
+        self.derives_for_unknown_types.is_empty()
+            && self.attributes_for_unknown_types.is_empty()
+            && self.substitutes_for_unknown_types.is_empty()
+    }
+}