fix: do not invent a variant for structs that flatten one

A struct holding a flattened variant cannot derive `Default` — the untagged
enum has no default, and choosing one would invent data the same way a required
field would. The generated request builder has the same problem: it constructs
the struct field by field and has no variant to supply.

Both are now skipped when a variant is present, which is what Cloudflare,
GitHub, LaunchDarkly, and Lithic needed to compile again.

Refs #65

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TD3TSeWKu4VqLtEnRMDjry

Author: lightsofapollo

src/generator.rs

@@ -2060,9 +2060,12 @@ impl CodeGenerator {
         // additional-properties map (when present) is empty by default. We do
         // not invent values for required data, even when the Rust type itself
         // happens to implement Default.
-        let can_derive_default = emitted_properties
-            .iter()
-            .all(|property| !property.is_required);
+        // A flattened variant is one of several shapes, and picking one would
+        // invent data the same way a required field would.
+        let can_derive_default = variant.is_none()
+            && emitted_properties
+                .iter()
+                .all(|property| !property.is_required);
 
         // Generate derives with optional Specta support
         // Note: We use snake_case everywhere (matching the OpenAPI spec) for consistency
@@ -2085,6 +2088,7 @@ impl CodeGenerator {
         };
 
         let builder = if type_context.index.request_body_roots.contains(&schema.name)
+            && variant.is_none()
             && emitted_properties
                 .iter()
                 .any(|property| property.is_required)

tests/recoverable_typing_test.rs

@@ -592,6 +592,39 @@ fn an_object_that_also_declares_variants_keeps_both_halves() {
     );
 }
 
+#[test]
+fn a_struct_with_a_flattened_variant_derives_no_default() {
+    // `Default` on the struct would have to invent a variant, which is the same
+    // problem as inventing a required field. Deriving it anyway does not
+    // compile, since the untagged enum has no default either.
+    let generated = generate(spec_with_schemas(json!({
+        "A": { "type": "object", "additionalProperties": false,
+               "properties": { "a": { "type": "string" } } },
+        "B": { "type": "object", "additionalProperties": false,
+               "properties": { "b": { "type": "string" } } },
+        "Holder": {
+            "properties": { "note": { "type": "string" } },
+            "anyOf": [
+                { "$ref": "#/components/schemas/A" },
+                { "$ref": "#/components/schemas/B" }
+            ]
+        }
+    })));
+
+    let struct_start = generated
+        .find("pub struct Holder")
+        .expect("the struct is generated");
+    let derive_line = generated[..struct_start]
+        .lines()
+        .rev()
+        .find(|line| line.contains("#[derive("))
+        .expect("a derive line precedes the struct");
+    assert!(
+        !derive_line.contains("Default"),
+        "a struct holding a flattened variant must not derive Default: {derive_line}"
+    );
+}
+
 #[test]
 fn a_requiredness_only_union_inside_a_property_is_the_object_it_describes() {
     // The same shape one level down, which the named-schema check did not see: