refactor(rust): implement true anyOf support with OR semantics

- anyOf now generates struct with optional fields instead of enum
- Each anyOf option becomes an optional field prefixed with 'as_'
- Added validate_any_of() method to ensure at least one field is set
- Maintains semantic difference between anyOf (OR) and oneOf (XOR)
- oneOf continues to use untagged enums (exactly one match)
- anyOf uses struct with optional fields (one or more matches possible)

BREAKING CHANGE: anyOf schemas now generate different code structure.
Previously generated enums, now generates structs with optional fields
to properly support OpenAPI anyOf semantics where multiple schemas can
validate simultaneously.

Author: timvw

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java

@@ -307,8 +307,8 @@ public CodegenModel fromModel(String name, Schema model) {
             mdl.getComposedSchemas().setOneOf(newOneOfs);
         }
 
-        // Handle anyOf schemas similarly to oneOf
-        // This is pragmatic since Rust's untagged enum will deserialize to the first matching variant
+        // Handle anyOf schemas with true OR semantics (one or more schemas must match)
+        // Unlike oneOf (XOR - exactly one), anyOf allows multiple schemas to validate
         if (mdl.getComposedSchemas() != null && mdl.getComposedSchemas().getAnyOf() != null
                 && !mdl.getComposedSchemas().getAnyOf().isEmpty()) {
 
@@ -366,8 +366,9 @@ public CodegenModel fromModel(String name, Schema model) {
                 }
             }
 
-            // Set anyOf as oneOf for template processing since we want the same output
-            mdl.getComposedSchemas().setOneOf(newAnyOfs);
+            // Keep anyOf separate from oneOf - they have different semantics
+            // anyOf will be processed with a different template structure
+            // that allows multiple schemas to match (OR logic)
         }
 
         return mdl;

modules/openapi-generator/src/main/resources/rust/model.mustache

@@ -152,7 +152,46 @@ impl Default for {{classname}} {
 {{/-last}}
 {{/oneOf}}
 {{^oneOf}}
-{{! composedSchemas exists but no oneOf - generate normal struct}}
+{{#composedSchemas.anyOf}}
+{{#-first}}
+{{! Model with composedSchemas.anyOf - generate struct with optional fields for true OR semantics}}
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct {{classname}} {
+{{/-first}}
+{{/composedSchemas.anyOf}}
+{{#composedSchemas.anyOf}}
+    {{#description}}
+    /// {{{.}}} (anyOf option)
+    {{/description}}
+    #[serde(skip_serializing_if = "Option::is_none", rename = "as_{{{baseName}}}")]
+    pub as_{{{name}}}: Option<{{#isModel}}{{^avoidBoxedModels}}Box<{{/avoidBoxedModels}}{{/isModel}}{{{dataType}}}{{#isModel}}{{^avoidBoxedModels}}>{{/avoidBoxedModels}}{{/isModel}}>,
+{{/composedSchemas.anyOf}}
+{{#composedSchemas.anyOf}}
+{{#-last}}
+}
+
+impl {{classname}} {
+    /// Creates a new {{classname}} with all fields set to None
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Validates that at least one anyOf field is set (OR semantics)
+    pub fn validate_any_of(&self) -> Result<(), String> {
+        {{#composedSchemas.anyOf}}
+        {{#-first}}
+        if {{/-first}}self.as_{{{name}}}.is_none(){{^-last}}
+            && {{/-last}}{{#-last}} {
+            return Err("At least one anyOf field must be set".to_string());
+        }{{/-last}}
+        {{/composedSchemas.anyOf}}
+        Ok(())
+    }
+}
+{{/-last}}
+{{/composedSchemas.anyOf}}
+{{^composedSchemas.anyOf}}
+{{! composedSchemas exists but no oneOf or anyOf - generate normal struct}}
 {{#vendorExtensions.x-rust-has-byte-array}}#[serde_as]
 {{/vendorExtensions.x-rust-has-byte-array}}#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct {{{classname}}} {
@@ -204,6 +243,7 @@ impl {{{classname}}} {
         }
     }
 }
+{{/composedSchemas.anyOf}}
 {{/oneOf}}
 {{/composedSchemas}}
 {{^composedSchemas}}

modules/openapi-generator/src/test/java/org/openapitools/codegen/rust/RustClientCodegenTest.java

@@ -287,21 +287,21 @@ public void testAnyOfSupport() throws IOException {
         Path modelIdentifierPath = Path.of(target.toString(), "/src/models/model_identifier.rs");
         TestUtils.assertFileExists(modelIdentifierPath);
 
-        // Should generate an untagged enum
-        TestUtils.assertFileContains(modelIdentifierPath, "#[serde(untagged)]");
-        TestUtils.assertFileContains(modelIdentifierPath, "pub enum ModelIdentifier");
+        // Should generate a struct with optional fields for anyOf (true OR semantics)
+        TestUtils.assertFileContains(modelIdentifierPath, "pub struct ModelIdentifier");
+        TestUtils.assertFileContains(modelIdentifierPath, "Option<String>");
 
-        // Should have String variant (for anyOf with string types)
-        TestUtils.assertFileContains(modelIdentifierPath, "String(String)");
+        // Should have validation method for anyOf
+        TestUtils.assertFileContains(modelIdentifierPath, "pub fn validate_any_of(&self)");
 
-        // Should NOT generate an empty struct
-        TestUtils.assertFileNotContains(modelIdentifierPath, "pub struct ModelIdentifier {");
-        TestUtils.assertFileNotContains(modelIdentifierPath, "pub fn new()");
+        // Should NOT generate an enum (that would be oneOf behavior)
+        TestUtils.assertFileNotContains(modelIdentifierPath, "pub enum ModelIdentifier");
+        TestUtils.assertFileNotContains(modelIdentifierPath, "#[serde(untagged)]");
 
         // Test AnotherAnyOfTest with mixed types
         Path anotherTestPath = Path.of(target.toString(), "/src/models/another_any_of_test.rs");
         TestUtils.assertFileExists(anotherTestPath);
-        TestUtils.assertFileContains(anotherTestPath, "#[serde(untagged)]");
-        TestUtils.assertFileContains(anotherTestPath, "pub enum AnotherAnyOfTest");
+        TestUtils.assertFileContains(anotherTestPath, "pub struct AnotherAnyOfTest");
+        TestUtils.assertFileContains(anotherTestPath, "pub fn validate_any_of(&self)");
     }
 }