Add guard against duplicate operation function name

Author: dsteeley

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

@@ -70,6 +70,7 @@ public class RustServerCodegen extends AbstractRustCodegen implements CodegenCon
     protected String externCrateName;
     protected Map<String, Map<String, String>> pathSetMap = new HashMap();
     protected Map<String, Map<String, String>> callbacksPathSetMap = new HashMap();
+    protected Set<String> globalOperationIds = new HashSet<>();
 
     private static final String uuidType = "uuid::Uuid";
     private static final String bytesType = "swagger::ByteArray";
@@ -583,8 +584,20 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
         }
 
         String underscoredOperationId = underscore(op.operationId);
-        op.vendorExtensions.put("x-operation-id", underscoredOperationId);
-        op.vendorExtensions.put("x-uppercase-operation-id", underscoredOperationId.toUpperCase(Locale.ROOT));
+        // Deduplicate x-operation-id across all tag groups. All operations are merged into a single
+        // mod.rs, so handle_<x-operation-id>() functions must be globally unique, not just per-tag.
+        String uniqueOperationId = underscoredOperationId;
+        int opIdCounter = 0;
+        while (globalOperationIds.contains(uniqueOperationId)) {
+            uniqueOperationId = underscoredOperationId + "_" + opIdCounter;
+            opIdCounter++;
+        }
+        globalOperationIds.add(uniqueOperationId);
+        if (!uniqueOperationId.equals(underscoredOperationId)) {
+            LOGGER.warn("generated unique x-operation-id `{}` for operationId `{}`", uniqueOperationId, op.operationId);
+        }
+        op.vendorExtensions.put("x-operation-id", uniqueOperationId);
+        op.vendorExtensions.put("x-uppercase-operation-id", uniqueOperationId.toUpperCase(Locale.ROOT));
         String vendorExtensionPath = op.path.replace("{", ":").replace("}", "");
         op.vendorExtensions.put("x-path", vendorExtensionPath);
         op.vendorExtensions.put("x-path-id", pathId);

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

@@ -10,6 +10,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.regex.Pattern;
 
 /**
  * Tests for RustServerCodegen.
@@ -60,6 +61,35 @@ public void testIntegerParameterTypeFitting() throws IOException {
         target.toFile().deleteOnExit();
     }
 
+    /**
+     * Test that two operations whose operationIds normalize to the same snake_case string
+     * (e.g., "fooBar" and "foo_bar" both become "foo_bar") receive distinct x-operation-id
+     * values. All operations are emitted as handle_<x-operation-id>() free functions in a
+     * single mod.rs, so duplicates would cause a Rust compile error.
+     */
+    @Test
+    public void testDuplicateOperationIdDeduplication() throws IOException {
+        Path target = Files.createTempDirectory("test");
+        final CodegenConfigurator configurator = new CodegenConfigurator()
+                .setGeneratorName("rust-server")
+                .setInputSpec("src/test/resources/3_0/rust-server/duplicate-operation-id.yaml")
+                .setSkipOverwrite(false)
+                .setOutputDir(target.toAbsolutePath().toString().replace("\\", "/"));
+        List<File> files = new DefaultGenerator().opts(configurator.toClientOptInput()).generate();
+        files.forEach(File::deleteOnExit);
+
+        Path serverModPath = Path.of(target.toString(), "/src/server/mod.rs");
+        TestUtils.assertFileExists(serverModPath);
+
+        // Both operations produce snake_case "foo_bar". The second should be renamed to
+        // "foo_bar_0" so there are two distinct handle_*() functions, not a duplicate.
+        TestUtils.assertFileContains(serverModPath, "handle_foo_bar(");
+        TestUtils.assertFileContains(serverModPath, "handle_foo_bar_0(");
+
+        // Clean up
+        target.toFile().deleteOnExit();
+    }
+
     /**
      * Test that required query params without examples disable the client example.
      */

modules/openapi-generator/src/test/resources/3_0/rust-server/duplicate-operation-id.yaml

@@ -0,0 +1,30 @@
+
+# Test that two operations in different tags with the same operationId (after snake_case
+# normalization) produce distinct x-operation-id values, avoiding a Rust compile error
+# from duplicate handle_<x-operation-id>() functions in the same mod.rs.
+openapi: 3.1.1
+info:
+  title: Duplicate OperationId Test
+  description: Spec with two operations that normalize to the same snake_case operation ID
+  version: 1.0.0
+servers:
+  - url: http://localhost:8080
+paths:
+  /foo/bar:
+    get:
+      operationId: fooBar
+      summary: First operation
+      tags:
+        - TagA
+      responses:
+        "200":
+          description: OK
+  /foo/baz:
+    get:
+      operationId: foo_bar
+      summary: Second operation - normalizes to same snake_case as fooBar
+      tags:
+        - TagB
+      responses:
+        "200":
+          description: OK