Result<T, E> + return inlined NDT for built-in impls

Cargo.toml

@@ -15,7 +15,10 @@ unwrap_used = { level = "warn", priority = -1 }
 panic = { level = "warn", priority = -1 }
 todo = { level = "warn", priority = -1 }
 panic_in_result_fn = { level = "warn", priority = -1 }
+
+# I hate these. For internal code I don't care.
 too_many_arguments = { level = "allow", priority = 0 }
+type_complexity = { level = "allow", priority = 0 }
 
 [profile.dev.package]
 insta.opt-level = 3

specta-jsonschema/src/import.rs

@@ -40,7 +40,7 @@ fn schema_object_to_datatype(obj: &JsonMap<String, Value>) -> Result<DataType, E
     // Handle const values (literals)
     if obj.get("const").is_some() {
         // Specta does not currently expose a direct literal DataType variant.
-        return Ok(DataType::Primitive(Primitive::String));
+        return Ok(DataType::Primitive(Primitive::str));
     }
 
     // Handle enum values (for string enums)
@@ -112,7 +112,7 @@ fn instance_type_name_to_datatype(
             Ok(DataType::Tuple(Tuple::new(vec![])))
         }
         "boolean" => Ok(DataType::Primitive(Primitive::bool)),
-        "string" => Ok(DataType::Primitive(Primitive::String)),
+        "string" => Ok(DataType::Primitive(Primitive::str)),
         "number" => {
             if let Some(format) = obj.get("format").and_then(Value::as_str) {
                 match format {
@@ -190,13 +190,13 @@ fn instance_type_name_to_datatype(
                     Value::Object(_) => {
                         let value_dt = value_to_datatype(additional)?;
                         return Ok(DataType::Map(Map::new(
-                            DataType::Primitive(Primitive::String),
+                            DataType::Primitive(Primitive::str),
                             value_dt,
                         )));
                     }
                     Value::Bool(true) => {
                         return Ok(DataType::Map(Map::new(
-                            DataType::Primitive(Primitive::String),
+                            DataType::Primitive(Primitive::str),
                             Struct::named().build(),
                         )));
                     }

specta-jsonschema/src/primitives.rs

@@ -107,22 +107,18 @@ pub fn datatype_to_schema(
                 Reference::Opaque(_) => Err(Error::UnsupportedDataType(
                     "Opaque references are not supported by JSON Schema exporter".to_string(),
                 )),
+                // JsonSchema doesn't have generics, so we use a placeholder,
+                // This should typically be resolved before export.
+                Reference::Generic(_) => Ok(json!({})), // Empty schema accepts anything
             }
         }
-
-        // Generic
-        DataType::Generic(_g) => {
-            // JSON Schema doesn't have generics, so we use a placeholder
-            // This should typically be resolved before export
-            Ok(json!({})) // Empty schema accepts anything
-        }
     }
 }
 
 fn primitive_to_schema(p: &Primitive) -> Value {
     match p {
         Primitive::bool => json!({"type": "boolean"}),
-        Primitive::String => json!({"type": "string"}),
+        Primitive::str => json!({"type": "string"}),
         Primitive::char => json!({"type": "string", "minLength": 1, "maxLength": 1}),
 
         // Integers

specta-kotlin/src/lib.rs

@@ -26,7 +26,7 @@
 // fn datatype(t: &DataType) -> Result<String, String> {
 //     Ok(match t {
 //         DataType::Primitive(p) => match p {
-//             Primitive::String => "String",
+//             Primitive::str => "String",
 //             Primitive::char => "Char",
 //             Primitive::i8 => "Byte",
 //             Primitive::i16 => "Short",

specta-macros/src/type/mod.rs

@@ -142,34 +142,47 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
         &used_generic_types,
     );
 
-    let shadow_generics = {
-        let g = generics.params.iter().map(|param| match param {
-            // Pulled from outside
-            GenericParam::Lifetime(_) | GenericParam::Const(_) => quote!(),
-            // We shadow the generics to replace them.
-            GenericParam::Type(t) => {
-                let ident = &t.ident;
-                let placeholder_ident = format_ident!("PLACEHOLDER_{}", t.ident);
-                quote!(type #ident = datatype::GenericPlaceholder<#placeholder_ident>;)
-            }
-        });
-
-        quote!(#(#g)*)
-    };
-
-    let generic_placeholders = generics.params.iter().filter_map(|param| match param {
+    let (generic_placeholders, shadow_generics): (Vec<_>, Vec<_>) = generics.params.iter().filter_map(|param| match param {
         GenericParam::Lifetime(_) | GenericParam::Const(_) => None,
         GenericParam::Type(t) => {
-            let ident = format_ident!("PLACEHOLDER_{}", t.ident);
-            let ident_str = t.ident.to_string();
-            Some(quote!(
-                pub struct #ident;
-                impl datatype::ConstGenericPlaceholder for #ident {
-                    const PLACEHOLDER: &'static str = #ident_str;
+            let ident = &t.ident;
+            let placeholder_ident = format_ident!("PLACEHOLDER_{ident}");
+            Some((quote!(
+                pub struct #placeholder_ident;
+                impl #crate_ref::Type for #placeholder_ident {
+                    fn definition(_: &mut #crate_ref::TypeCollection) -> datatype::DataType {
+                        datatype::GenericReference::new::<Self>().into()
+                    }
                 }
-            ))
+            ), quote!(type #ident = #placeholder_ident;)))
         }
-    });
+    }).unzip();
+
+    let (generics_for_ndt, generics_for_ref): (Vec<_>, Vec<_>) = generics
+        .params
+        .iter()
+        .filter_map(|param| match param {
+            GenericParam::Lifetime(_) | GenericParam::Const(_) => None,
+            GenericParam::Type(t) => {
+                let i = &t.ident;
+                let placeholder_ident = format_ident!("PLACEHOLDER_{}", t.ident);
+                if !used_generic_types.iter().any(|used| used == i) {
+                    return None;
+                }
+                let i_str = i.to_string();
+                Some((
+                    quote!((
+                        #crate_ref::datatype::GenericReference::new::<#placeholder_ident>(),
+                        Cow::Borrowed(#i_str),
+                    )),
+                    quote!((
+                        #crate_ref::datatype::GenericReference::new::<#placeholder_ident>(),
+                        <#i as #crate_ref::Type>::definition(types),
+                    )),
+                ))
+            }
+        })
+        .unzip();
 
     let collect = (cfg!(feature = "DO_NOT_USE_collect") && container_attrs.collect.unwrap_or(true))
         .then(|| {
@@ -194,26 +207,6 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
     let inline = container_attrs.inline || container_attrs.r#type.is_some();
     let deprecated = container_attrs.common.deprecated_as_tokens();
 
-    let reference_generics = generics.params.iter().filter_map(|param| match param {
-        GenericParam::Lifetime(_) | GenericParam::Const(_) => None,
-        GenericParam::Type(t) => {
-            let i = &t.ident;
-            if !used_generic_types.iter().any(|used| used == i) {
-                return None;
-            }
-            let i_str = i.to_string();
-            Some(quote!((#crate_ref::datatype::Generic::new(#i_str), <#i as #crate_ref::Type>::definition(types))))
-        }
-    });
-
-    let definition_generics = generics.params.iter().filter_map(|p| match p {
-        GenericParam::Type(t) => {
-            let ident = t.ident.to_string();
-            Some(quote!(std::borrow::Cow::Borrowed(#ident).into()))
-        }
-        _ => None,
-    });
-
     Ok(quote! {
         #[allow(non_camel_case_types)]
         const _: () = {
@@ -226,9 +219,11 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
                     #(#generic_placeholders)*
 
                     static SENTINEL: &str = concat!(module_path!(), "::", stringify!(#raw_ident));
+                    static GENERICS: &[(datatype::GenericReference, Cow<'static, str>)] = &[#(#generics_for_ndt),*];
                     datatype::DataType::Reference(
                         datatype::NamedDataType::init_with_sentinel(
-                            vec![#(#reference_generics),*],
+                            GENERICS,
+                            vec![#(#generics_for_ref),*],
                             #inline,
                             types,
                             SENTINEL,
@@ -237,9 +232,8 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
                                 ndt.set_docs(Cow::Borrowed(#comments));
                                 ndt.set_deprecated(#deprecated);
                                 ndt.set_module_path(Cow::Borrowed(module_path!()));
-                                *ndt.generics_mut() = vec![#(#definition_generics),*];
                                 ndt.set_ty({
-                                    #shadow_generics
+                                    #(#shadow_generics)*
 
                                     #dt_expr
                                 });

specta-openapi/src/lib.rs

@@ -83,7 +83,7 @@ pub fn to_openapi(typ: &DataType) -> ReferenceOr<Schema> {
             schema_data,
             schema_kind: SchemaKind::Type(Type::Number(NumberType::default())), // TODO: Configure number type. Ts: `bigint`
         }),
-        primitive_def!(String char) => ReferenceOr::Item(Schema {
+        primitive_def!(str char) => ReferenceOr::Item(Schema {
             schema_data,
             schema_kind: SchemaKind::Type(Type::String(StringType::default())), // TODO: Configure string type. Ts: `string`
         }),