TypeMap + TypeCollection (#294)

* wip * fix size_hint * call `language.format` on `TypeMap::export_to` * rename `TypeMap` to `TypeCollection` * move `specta_util::export` to `specta::export` --------- Co-authored-by: Oscar Beaumont <[email protected]>
specta-rs · Dec 4, 2024 · d13f097 · d13f097
1 parent a0950d0
commit d13f097
Show file tree

Hide file tree

Showing 41 changed files with 398 additions and 347 deletions.
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
@@ -5,9 +5,8 @@ edition = "2021"
 publish = false
 
 [dependencies]
-specta = { path = "../specta", features = ["derive"] }
+specta = { path = "../specta", features = ["derive", "export"] }
 specta-typescript = { path = "../specta-typescript" }
-specta-util = { path = "../specta-util", features = ["export"] }
 
 [lints]
 workspace = true
diff --git a/examples/examples/export.rs b/examples/examples/export.rs
@@ -14,16 +14,16 @@ pub struct TypeTwo {
 
 fn main() {
     // Export as string
-    let string = specta_util::export().export(Typescript::default()).unwrap();
+    let string = specta::export().export(Typescript::default()).unwrap();
     println!("{string}");
 
     // Export to file
-    specta_util::export()
+    specta::export()
         .export_to(Typescript::default(), "./bindings.ts")
         .unwrap();
 
     // Override the export configuration.
-    specta_util::export()
+    specta::export()
         .export_to(
             Typescript::default()
                 // Be aware this won't be typesafe unless your using a ser/deserializer that converts BigInt types to a number.

diff --git a/specta-go/src/lib.rs b/specta-go/src/lib.rs
@@ -5,11 +5,14 @@
     html_favicon_url = "https://github.com/oscartbeaumont/specta/raw/main/.github/logo-128.png"
 )]
 
-use specta::{datatype::DataType, Generics, Type, TypeMap};
+use specta::{datatype::DataType, Generics, Type, TypeCollection};
 
 /// TODO
 pub fn export<T: Type>() -> Result<String, String> {
-    datatype(&T::inline(&mut TypeMap::default(), Generics::Definition))
+    datatype(&T::inline(
+        &mut TypeCollection::default(),
+        Generics::Definition,
+    ))
 }
 
 fn datatype(t: &DataType) -> Result<String, String> {

diff --git a/specta-jsdoc/src/lib.rs b/specta-jsdoc/src/lib.rs
@@ -7,7 +7,7 @@
 
 use std::{borrow::Cow, path::Path};
 
-use specta::{Language, TypeMap};
+use specta::{Language, TypeCollection};
 use specta_typescript::{BigIntExportBehavior, CommentFormatterFn, FormatterFn};
 
 // TODO: Ensure this is up to our `Typescript` exporters standards.
@@ -79,7 +79,7 @@ impl Language for JSDoc {
     type Error = specta_typescript::ExportError; // TODO: Custom error type
 
     // TODO: Make this properly export JSDoc
-    fn export(&self, type_map: TypeMap) -> Result<String, Self::Error> {
+    fn export(&self, _type_map: &TypeCollection) -> Result<String, Self::Error> {
         todo!("Coming soon...");
         // let mut out = self.0.header.to_string();
         // if !self.0.remove_default_header {

diff --git a/specta-kotlin/src/lib.rs b/specta-kotlin/src/lib.rs
@@ -7,12 +7,15 @@
 
 use specta::{
     datatype::{DataType, PrimitiveType},
-    Generics, Type, TypeMap,
+    Generics, Type, TypeCollection,
 };
 
 /// TODO
 pub fn export<T: Type>() -> Result<String, String> {
-    datatype(&T::inline(&mut TypeMap::default(), Generics::Definition))
+    datatype(&T::inline(
+        &mut TypeCollection::default(),
+        Generics::Definition,
+    ))
 }
 
 fn datatype(t: &DataType) -> Result<String, String> {

diff --git a/specta-macros/src/specta.rs b/specta-macros/src/specta.rs
@@ -106,7 +106,7 @@ pub fn attribute(item: proc_macro::TokenStream) -> syn::Result<proc_macro::Token
         macro_rules! #wrapper {
             // We take in `$function` from the invocation so we have `fn_name::<concrete_generics_types>`
             (@export_fn; $function:path) => {{
-                fn export(type_map: &mut #crate_ref::TypeMap) -> #crate_ref::datatype::Function {
+                fn export(type_map: &mut #crate_ref::TypeCollection) -> #crate_ref::datatype::Function {
                     #crate_ref::internal::get_fn_datatype(
                         $function as fn(#(#arg_signatures),*) -> _,
                         #function_asyncness,

diff --git a/specta-macros/src/type/mod.rs b/specta-macros/src/type/mod.rs
@@ -39,7 +39,6 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
         .unwrap_or_else(|| ident.to_token_stream());
 
     let crate_ref: TokenStream = container_attrs.crate_name.clone().unwrap_or(quote!(specta));
-    let internal_crate_ref: TokenStream = quote!(specta_util); // TODO: This should be overridable by attribute but it's not. // TODO: container_attrs.crate_name.clone().unwrap_or(
 
     let name = container_attrs.rename.clone().unwrap_or_else(|| {
         unraw_raw_ident(&format_ident!("{}", raw_ident.to_string())).to_token_stream()
@@ -119,9 +118,9 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
 
             quote! {
                 #[allow(non_snake_case)]
-                #[#internal_crate_ref::export::internal::ctor]
+                #[#crate_ref::export::internal::ctor]
                 fn #export_fn_name() {
-                    #internal_crate_ref::export::internal::register::<#ident<#(#generic_params),*>>();
+                    #crate_ref::export::internal::register::<#ident<#(#generic_params),*>>();
                 }
             }
         });
@@ -138,7 +137,7 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
 
             #[automatically_derived]
             #type_impl_heading {
-                fn inline(type_map: &mut #crate_ref::TypeMap, generics: #crate_ref::Generics) -> #crate_ref::datatype::DataType {
+                fn inline(type_map: &mut #crate_ref::TypeCollection, generics: #crate_ref::Generics) -> #crate_ref::datatype::DataType {
                     let generics = match generics {
                         #crate_ref::Generics::Definition => DEFINITION_GENERICS,
                         #crate_ref::Generics::Provided(generics) => generics,
@@ -147,7 +146,7 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
                     #inlines
                 }
 
-                fn reference(type_map: &mut #crate_ref::TypeMap, generics: &[#crate_ref::datatype::DataType]) -> #crate_ref::datatype::reference::Reference {
+                fn reference(type_map: &mut #crate_ref::TypeCollection, generics: &[#crate_ref::datatype::DataType]) -> #crate_ref::datatype::reference::Reference {
                     #reference
                 }
             }
@@ -158,7 +157,7 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
                     #sid
                 }
 
-                fn named_data_type(type_map: &mut #crate_ref::TypeMap, generics: &[#crate_ref::datatype::DataType]) -> #crate_ref::datatype::NamedDataType {
+                fn named_data_type(type_map: &mut #crate_ref::TypeCollection, generics: &[#crate_ref::datatype::DataType]) -> #crate_ref::datatype::NamedDataType {
                     #crate_ref::internal::construct::named_data_type(
                         #name.into(),
                         #comments.into(),
@@ -169,7 +168,7 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
                     )
                 }
 
-                fn definition_named_data_type(type_map: &mut #crate_ref::TypeMap) -> #crate_ref::datatype::NamedDataType {
+                fn definition_named_data_type(type_map: &mut #crate_ref::TypeCollection) -> #crate_ref::datatype::NamedDataType {
                     #crate_ref::internal::construct::named_data_type(
                         #name.into(),
                         #comments.into(),

diff --git a/specta-rust/src/lib.rs b/specta-rust/src/lib.rs
@@ -5,11 +5,14 @@
     html_favicon_url = "https://github.com/oscartbeaumont/specta/raw/main/.github/logo-128.png"
 )]
 
-use specta::{datatype::DataType, Generics, Type, TypeMap};
+use specta::{datatype::DataType, Generics, Type, TypeCollection};
 
 /// TODO
 pub fn export<T: Type>() -> Result<String, String> {
-    datatype(&T::inline(&mut TypeMap::default(), Generics::Definition))
+    datatype(&T::inline(
+        &mut TypeCollection::default(),
+        Generics::Definition,
+    ))
 }
 
 fn datatype(t: &DataType) -> Result<String, String> {

diff --git a/specta-serde/src/lib.rs b/specta-serde/src/lib.rs
@@ -14,7 +14,7 @@ use specta::{
         DataType, EnumRepr, EnumType, EnumVariants, LiteralType, PrimitiveType, StructFields,
     },
     internal::{resolve_generics, skip_fields, skip_fields_named},
-    SpectaID, TypeMap,
+    SpectaID, TypeCollection,
 };
 
 // TODO: The error should show a path to the type causing the issue like the BigInt error reporting.
@@ -32,13 +32,13 @@ pub enum SerdeError {
 /// Check that a [DataType] is a valid for Serde.
 ///
 /// This can be used by exporters which wanna do export-time checks that all types are compatible with Serde formats.
-pub fn is_valid_ty(dt: &DataType, type_map: &TypeMap) -> Result<(), SerdeError> {
+pub fn is_valid_ty(dt: &DataType, type_map: &TypeCollection) -> Result<(), SerdeError> {
     is_valid_ty_internal(dt, type_map, &mut Default::default())
 }
 
 fn is_valid_ty_internal(
     dt: &DataType,
-    type_map: &TypeMap,
+    type_map: &TypeCollection,
     checked_references: &mut HashSet<SpectaID>,
 ) -> Result<(), SerdeError> {
     match dt {
@@ -106,7 +106,7 @@ fn is_valid_ty_internal(
 }
 
 // Typescript: Must be assignable to `string | number | symbol` says Typescript.
-fn is_valid_map_key(key_ty: &DataType, type_map: &TypeMap) -> Result<(), SerdeError> {
+fn is_valid_map_key(key_ty: &DataType, type_map: &TypeCollection) -> Result<(), SerdeError> {
     match key_ty {
         DataType::Any => Ok(()),
         DataType::Primitive(ty) => match ty {
@@ -171,7 +171,7 @@ fn is_valid_map_key(key_ty: &DataType, type_map: &TypeMap) -> Result<(), SerdeEr
 }
 
 // Serde does not allow serializing a variant of certain types of enum's.
-fn validate_enum(e: &EnumType, type_map: &TypeMap) -> Result<(), SerdeError> {
+fn validate_enum(e: &EnumType, type_map: &TypeCollection) -> Result<(), SerdeError> {
     // You can't `#[serde(skip)]` your way to an empty enum.
     let valid_variants = e.variants().iter().filter(|(_, v)| !v.skip()).count();
     if valid_variants == 0 && !e.variants().is_empty() {
@@ -187,7 +187,7 @@ fn validate_enum(e: &EnumType, type_map: &TypeMap) -> Result<(), SerdeError> {
 }
 
 // Checks for specially internally tagged enums.
-fn validate_internally_tag_enum(e: &EnumType, type_map: &TypeMap) -> Result<(), SerdeError> {
+fn validate_internally_tag_enum(e: &EnumType, type_map: &TypeCollection) -> Result<(), SerdeError> {
     for (_variant_name, variant) in e.variants() {
         match &variant.inner() {
             EnumVariants::Unit => {}
@@ -215,7 +215,7 @@ fn validate_internally_tag_enum(e: &EnumType, type_map: &TypeMap) -> Result<(),
 // Which makes sense when you can't represent `{ "type": "A" } & string` in a single JSON value.
 fn validate_internally_tag_enum_datatype(
     ty: &DataType,
-    type_map: &TypeMap,
+    type_map: &TypeCollection,
 ) -> Result<(), SerdeError> {
     match ty {
         // `serde_json::Any` can be *technically* be either valid or invalid based on the actual data but we are being strict and reject it.

diff --git a/specta-swift/src/lib.rs b/specta-swift/src/lib.rs
@@ -7,12 +7,15 @@
 
 use specta::{
     datatype::{DataType, PrimitiveType},
-    Generics, Type, TypeMap,
+    Generics, Type, TypeCollection,
 };
 
 /// TODO
 pub fn export<T: Type>() -> Result<String, String> {
-    datatype(&T::inline(&mut TypeMap::default(), Generics::Definition))
+    datatype(&T::inline(
+        &mut TypeCollection::default(),
+        Generics::Definition,
+    ))
 }
 
 fn datatype(t: &DataType) -> Result<String, String> {

diff --git a/specta-typescript/src/js_doc.rs b/specta-typescript/src/js_doc.rs
@@ -2,13 +2,17 @@ use std::borrow::Borrow;
 
 use specta::{
     datatype::{DeprecatedType, GenericType},
-    TypeMap,
+    TypeCollection,
 };
 use typescript::CommentFormatterArgs;
 
 use super::*;
 
-pub fn typedef_named_datatype(cfg: &Typescript, typ: &NamedDataType, type_map: &TypeMap) -> Output {
+pub fn typedef_named_datatype(
+    cfg: &Typescript,
+    typ: &NamedDataType,
+    type_map: &TypeCollection,
+) -> Output {
     typedef_named_datatype_inner(
         &ExportContext {
             cfg,
@@ -24,7 +28,7 @@ pub fn typedef_named_datatype(cfg: &Typescript, typ: &NamedDataType, type_map: &
 fn typedef_named_datatype_inner(
     ctx: &ExportContext,
     typ: &NamedDataType,
-    type_map: &TypeMap,
+    type_map: &TypeCollection,
 ) -> Output {
     let name = typ.name();
     let docs = typ.docs();