Wip proof of concept auto collect schemas

Implement proof of concept auto collect nested schema references and
register them in call usage call. Currently implemented for named struct
field schemas.

Author: juhaku

utoipa-gen/src/component.rs

@@ -572,10 +572,28 @@ impl ToTokens for ComponentDescription<'_> {
     }
 }
 
+/// Used to store possible inner field schema name and tokens if field contains any schema
+/// references. E.g. field: Vec<Foo> should have name: Foo::name() and tokens: Foo::schema()
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Default)]
+pub struct SchemaReference {
+    name: TokenStream,
+    tokens: TokenStream,
+}
+
+impl SchemaReference {
+    /// Check whether `name` or `tokens` is empty. Will happen if token is partially resolved as a
+    /// reference schema. E.g. inlined schemas does not generated tokens.
+    fn is_empty(&self) -> bool {
+        self.name.is_empty() || self.tokens.is_empty()
+    }
+}
+
 #[cfg_attr(feature = "debug", derive(Debug))]
 pub struct ComponentSchema {
     tokens: TokenStream,
     pub name_tokens: TokenStream,
+    pub schema_reference: Option<SchemaReference>,
 }
 
 impl ComponentSchema {
@@ -589,6 +607,7 @@ impl ComponentSchema {
     ) -> Result<Self, Diagnostics> {
         let mut tokens = TokenStream::new();
         let mut name_tokens = TokenStream::new();
+        let mut schema_reference = SchemaReference::default();
 
         match type_tree.generic_type {
             Some(GenericType::Map) => ComponentSchema::map_to_tokens(
@@ -601,6 +620,7 @@ impl ComponentSchema {
             Some(GenericType::Vec | GenericType::LinkedList | GenericType::Set) => {
                 ComponentSchema::vec_to_tokens(
                     &mut tokens,
+                    &mut schema_reference,
                     container,
                     features,
                     type_tree,
@@ -610,6 +630,7 @@ impl ComponentSchema {
             #[cfg(feature = "smallvec")]
             Some(GenericType::SmallVec) => ComponentSchema::vec_to_tokens(
                 &mut tokens,
+                &mut schema_reference,
                 container,
                 features,
                 type_tree,
@@ -623,8 +644,7 @@ impl ComponentSchema {
                 {
                     features.push(Nullable::new().into());
                 }
-
-                ComponentSchema::new(ComponentSchemaProps {
+                let schema = ComponentSchema::new(ComponentSchemaProps {
                     container,
                     type_tree: type_tree
                         .children
@@ -635,8 +655,13 @@ impl ComponentSchema {
                         .expect("ComponentSchema generic container type should have 1 child"),
                     features,
                     description,
-                })?
-                .to_tokens(&mut tokens)?;
+                })?;
+                schema.to_tokens(&mut tokens)?;
+
+                if let Some(reference) = schema.schema_reference {
+                    schema_reference.name = reference.name;
+                    schema_reference.tokens = reference.tokens;
+                }
             }
             Some(GenericType::Cow | GenericType::Box | GenericType::RefCell) => {
                 ComponentSchema::new(ComponentSchemaProps {
@@ -672,6 +697,7 @@ impl ComponentSchema {
             None => ComponentSchema::non_generic_to_tokens(
                 &mut tokens,
                 &mut name_tokens,
+                &mut schema_reference,
                 container,
                 features,
                 type_tree,
@@ -682,6 +708,11 @@ impl ComponentSchema {
         Ok(Self {
             tokens,
             name_tokens,
+            schema_reference: if schema_reference.is_empty() {
+                None
+            } else {
+                Some(schema_reference)
+            },
         })
     }
 
@@ -764,6 +795,7 @@ impl ComponentSchema {
 
     fn vec_to_tokens(
         tokens: &mut TokenStream,
+        schema_reference: &mut SchemaReference,
         container: &Container,
         mut features: Vec<Feature>,
         type_tree: &TypeTree,
@@ -799,8 +831,6 @@ impl ComponentSchema {
             child
         };
 
-        let unique = matches!(type_tree.generic_type, Some(GenericType::Set));
-
         let component_schema = ComponentSchema::new(ComponentSchemaProps {
             container,
             type_tree: child,
@@ -809,7 +839,12 @@ impl ComponentSchema {
         })?;
         let component_schema_tokens = as_tokens_or_diagnostics!(&component_schema);
 
-        let unique = match unique {
+        if let Some(reference) = component_schema.schema_reference {
+            schema_reference.name = reference.name;
+            schema_reference.tokens = reference.tokens;
+        };
+
+        let unique = match matches!(type_tree.generic_type, Some(GenericType::Set)) {
             true => quote! {
                 .unique_items(true)
             },
@@ -865,6 +900,7 @@ impl ComponentSchema {
     fn non_generic_to_tokens(
         tokens: &mut TokenStream,
         name_tokens: &mut TokenStream,
+        schema_reference: &mut SchemaReference,
         container: &Container,
         mut features: Vec<Feature>,
         type_tree: &TypeTree,
@@ -987,6 +1023,8 @@ impl ComponentSchema {
                     }
                     name_tokens.extend(quote! { format!("{}{}", < #type_path as utoipa::ToSchema >::name(), #component_name_buffer) });
 
+                    schema_reference.name = name_tokens.clone();
+
                     if is_inline {
                         let default = pop_feature!(features => Feature::Default(_));
                         let default_tokens = as_tokens_or_diagnostics!(&default);
@@ -1037,6 +1075,8 @@ impl ComponentSchema {
 
                         schema.to_tokens(tokens);
                     } else {
+                        schema_reference.tokens =
+                            quote! {<#type_path as utoipa::PartialSchema>::schema() };
                         let default = pop_feature!(features => Feature::Default(_));
                         let default_tokens = as_tokens_or_diagnostics!(&default);