use inferred union variant names in more places

Author: arlyon

typify-impl/src/enums.rs

@@ -1,6 +1,6 @@
 // Copyright 2025 Oxide Computer Company
 
-use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
 use heck::{ToKebabCase, ToPascalCase};
 use proc_macro2::TokenStream;
@@ -609,33 +609,52 @@ impl TypeSpace {
             // account for types such as Uuid whose names come from outside of
             // the schema... but you can't win them all.
             .map(schema_is_named)
-            .collect::<Option<Vec<_>>>()
-            // Prune the common prefixes from all variant names. If this
-            // results in any of them being empty, we don't use these names.
-            .and_then(|variant_names| {
-                let common_prefix = variant_names
-                    .iter()
-                    .cloned()
-                    .reduce(|a, b| get_common_prefix(&a, &b))
-                    .unwrap();
-                variant_names
-                    .into_iter()
-                    .map(|var_name| {
-                        let var_name = &var_name[common_prefix.len()..];
-                        if var_name.is_empty() {
-                            None
-                        } else {
-                            Some(var_name.to_string())
-                        }
-                    })
-                    .collect::<Option<Vec<_>>>()
+            .collect::<Vec<_>>();
+
+        let common_prefix = variant_names
+            .iter()
+            .cloned()
+            .flatten()
+            .reduce(|a, b| get_common_prefix(&a, &b))
+            .unwrap_or_else(String::new);
+
+        // Store seen, un-stripped names here. Any item for which their
+        // name appears more than once, ALL the items with that clashing
+        // name will be converted to the `VariantN` scheme.
+        let duplicate_names = variant_names
+            .iter()
+            .cloned()
+            .flatten()
+            .fold(HashMap::new(), |mut counter: HashMap<_, u8>, name| {
+                *counter.entry(name).or_default() += 1;
+                counter
             })
-            // Fall back to `VariantN` naming.
-            .unwrap_or_else(|| {
-                (0..subschemas.len())
-                    .map(|idx| format!("Variant{}", idx))
-                    .collect()
-            });
+            .into_iter()
+            .filter_map(|(name, count)| if count > 1 { Some(name) } else { None })
+            .collect::<HashSet<_>>();
+
+        // Prune the common prefixes from all variant names. If this
+        // results in any of them being empty, we don't use these names.
+        //
+        // Fall back to VariantN if the variant name cannot be derived from
+        // the schema.
+        let variant_names = variant_names
+            .into_iter()
+            .enumerate()
+            .map(|(idx, var_name)| {
+                match var_name {
+                    None => None,
+                    var_name => {
+                        var_name.filter(|var_name| !duplicate_names.contains(var_name.as_str()))
+                    }
+                }
+                .map(|var_name| var_name[common_prefix.len()..].to_string())
+                .filter(|var_name| !var_name.is_empty())
+                .map(|var_name| var_name.to_string())
+                // Fall back to `VariantN` naming.
+                .unwrap_or_else(|| format!("Variant{}", idx))
+            })
+            .collect::<Vec<_>>();
 
         // Gather the variant details along with its name.
         let variant_details = subschemas

typify-impl/src/util.rs

@@ -622,6 +622,20 @@ pub(crate) fn schema_is_named(schema: &Schema) -> Option<String> {
             extensions: _,
         }) => singleton_subschema(subschemas).and_then(schema_is_named),
 
+        // Best-effort fallback for things with raw types that can be easily inferred
+        Schema::Object(SchemaObject {
+            instance_type: Some(SingleOrVec::Single(single)),
+            ..
+        }) => match **single {
+            InstanceType::Boolean => Some("Boolean".to_string()),
+            InstanceType::Integer => Some("Integer".to_string()),
+            InstanceType::Number => Some("Number".to_string()),
+            InstanceType::String => Some("String".to_string()),
+            InstanceType::Array => Some("Array".to_string()),
+            InstanceType::Object => Some("Object".to_string()),
+            InstanceType::Null => Some("Null".to_string()),
+        },
+
         _ => None,
     }?;
 

typify-impl/src/value.rs

@@ -1089,7 +1089,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    super::Test::Variant0
+                    super::Test::Null
                 }
                 .to_string()
             )
@@ -1100,7 +1100,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    super::Test::Variant1("xx".to_string(), "yy".to_string())
+                    super::Test::Array("xx".to_string(), "yy".to_string())
                 }
                 .to_string()
             )
@@ -1117,7 +1117,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    super::Test::Variant2 {
+                    super::Test::Object {
                         cc: "xx".to_string(),
                         dd: "yy".to_string()
                     }
@@ -1147,7 +1147,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    Test::Variant0
+                    Test::Null
                 }
                 .to_string()
             )
@@ -1158,7 +1158,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    Test::Variant1("xx".to_string(), "yy".to_string())
+                    Test::Array("xx".to_string(), "yy".to_string())
                 }
                 .to_string()
             )
@@ -1175,7 +1175,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    Test::Variant2 {
+                    Test::Object {
                         cc: "xx".to_string(),
                         dd: "yy".to_string()
                     }