fix(normalizer): support OAS 3.1 annotated enums (oneOf + const) for consistent enum generation (C#) (OpenAPITools#23869)

* fix(csharp): use numeric .NET version check to prevent double URL-encoding on .NET 9+

On .NET 9+, HttpUtility.ParseQueryString() already URL-encodes values internally.
The previous fix only checked for '.NET 9' literally, missing .NET 10+ (PowerShell 7.6).
Replace the string prefix check with a numeric major version comparison (>= 9) and
move the RuntimeInformation check outside the foreach loop to avoid redundant parsing.

Fixes: CSCwu08056

* Introducing Annotated Enum with const

* fix: support OpenAPI 3.1 const in annotated enum normalization

* fix(docs): use forward slashes in path separators for cross-platform portability

* revert: remove unrelated doc file changes from PR scope

* refactor(normalizer): extract definesEnum variable per reviewer suggestion

* fix(normalizer): preserve x-enum-deprecated for oneOf/anyOf const enums

* chore: regenerate samples after normalization improvements

* chore(samples): normalize generated samples for cross-platform output

* adding samples

* chore(csharp): sync HttpSigningConfiguration.mustache from upstream/master

* Revert "adding samples"

This reverts commit 6ef74e7.

* add annotated enum csharp config and regenerate samples

* Revert "add annotated enum csharp config and regenerate samples"

This reverts commit 5e4b895.

* add csharp generichost annotated enum config

* regenerate samples for csharp generichost annotated enum

* ci(csharp): add AnnotatedEnum sample to .NET 10 workflow

* chore(samples): regenerate AnnotatedEnum after upstream merge

* chore(samples): align AnnotatedEnum FILES manifest with double-regen convention

CI's samples job runs bin/generate-samples.sh twice. On the second pass the generator skips idempotent files (.openapi-generator-ignore and Test/{Api,Model}/*Tests.cs already on disk), so they are omitted from the FILES manifest. Other generichost samples (e.g. ComposedEnum) follow this convention; AnnotatedEnum's FILES was previously committed after a single regen and included 17 stale entries. Regenerated to match CI output.

---------

Co-authored-by: sagadira <sagadira@cisco.com>
Co-authored-by: Vikrant Balyan <vvb@users.noreply.github.com>

Author: 3 people

.github/workflows/samples-dotnet10.yaml

@@ -23,6 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         sample:
+          - samples/client/petstore/csharp/generichost/latest/AnnotatedEnum
           - samples/client/petstore/csharp/generichost/latest/ComposedEnum
           - samples/client/petstore/csharp/generichost/latest/InlineEnumAnyOf
           - samples/client/petstore/csharp/generichost/latest/Tags

bin/configs/csharp-generichost-latest-annotatedEnum.yaml

@@ -0,0 +1,10 @@
+# for csharp generichost - OAS 3.1 annotated enum with const + deprecated
+generatorName: csharp
+outputDir: samples/client/petstore/csharp/generichost/latest/AnnotatedEnum
+inputSpec: modules/openapi-generator/src/test/resources/3_1/simplifyOneOfAnyOf_test.yaml
+templateDir: modules/openapi-generator/src/main/resources/csharp
+additionalProperties:
+  packageGuid: '{A2B4C6D8-1234-5678-9ABC-DEF012345678}'
+  modelPropertySorting: alphabetical
+  operationParameterSorting: alphabetical
+validateSpec: false

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

@@ -1643,6 +1643,7 @@ protected Schema processSimplifyOneOfEnum(Schema schema) {
      */
     protected Schema simplifyComposedSchemaWithEnums(Schema schema, List<Object> subSchemas, String composedType) {
         Map<Object, String> enumValues = new LinkedHashMap<>();
+        Map<Object, Boolean> deprecatedValues = new LinkedHashMap<>();
 
         if(schema.getTypes() != null && schema.getTypes().size() > 1) {
             // we cannot handle enums with multiple types
@@ -1663,10 +1664,15 @@ protected Schema simplifyComposedSchemaWithEnums(Schema schema, List<Object> sub
 
             Schema subSchema = ModelUtils.getReferencedSchema(openAPI, (Schema) item);
 
-            // Check if this sub-schema has an enum (with one or more values)
-            if (subSchema.getEnum() == null || subSchema.getEnum().isEmpty()) {
+            // Check if this sub-schema has an enum or const value (OAS 3.1 uses const for single-value enums)
+            boolean definesEnum = ModelUtils.hasEnum(subSchema);
+            if (!definesEnum && subSchema.getConst() == null) {
                 return schema;
             }
+            // If const is present but enum is not, treat const as a single enum value
+            List<Object> subSchemaEnumValues = definesEnum
+                    ? subSchema.getEnum()
+                    : Arrays.asList(subSchema.getConst());
 
             // Ensure all sub-schemas have the same type (if type is specified)
             if(subSchema.getTypes() != null && subSchema.getTypes().size() > 1) {
@@ -1681,25 +1687,28 @@ protected Schema simplifyComposedSchemaWithEnums(Schema schema, List<Object> sub
                     return schema;
                 }
             }
+            boolean subSchemaDeprecated = Boolean.TRUE.equals(subSchema.getDeprecated());
             // Add all enum values from this sub-schema to our collection
-            if(subSchema.getEnum().size() == 1) {
+            if(subSchemaEnumValues.size() == 1) {
                 String description = subSchema.getTitle() == null ? "" : subSchema.getTitle();
                 if(subSchema.getDescription() != null) {
                     if(!description.isEmpty()) {
                         description += " - ";
                     }
                     description += subSchema.getDescription();
                 }
-                enumValues.put(subSchema.getEnum().get(0), description);
+                enumValues.put(subSchemaEnumValues.get(0), description);
+                deprecatedValues.put(subSchemaEnumValues.get(0), subSchemaDeprecated);
             } else {
-                for(Object e: subSchema.getEnum()) {
+                for(Object e: subSchemaEnumValues) {
                     enumValues.put(e, "");
+                    deprecatedValues.put(e, subSchemaDeprecated);
                 }
             }
 
         }
 
-        return createSimplifiedEnumSchema(schema, enumValues, schemaType, composedType);
+        return createSimplifiedEnumSchema(schema, enumValues, deprecatedValues, schemaType, composedType);
     }
 
 
@@ -1708,11 +1717,12 @@ protected Schema simplifyComposedSchemaWithEnums(Schema schema, List<Object> sub
      *
      * @param originalSchema Original schema to modify
      * @param enumValues Collected enum values
+     * @param deprecatedValues Per-value deprecated flags (aligned with enumValues key order)
      * @param schemaType Consistent type across sub-schemas
      * @param composedType Type of composed schema being simplified
      * @return Simplified enum schema
      */
-    protected Schema createSimplifiedEnumSchema(Schema originalSchema, Map<Object, String> enumValues, String schemaType, String composedType) {
+    protected Schema createSimplifiedEnumSchema(Schema originalSchema, Map<Object, String> enumValues, Map<Object, Boolean> deprecatedValues, String schemaType, String composedType) {
         // Clear the composed schema type
         if ("oneOf".equals(composedType)) {
             originalSchema.setOneOf(null);
@@ -1730,6 +1740,10 @@ protected Schema createSimplifiedEnumSchema(Schema originalSchema, Map<Object, S
             //set x-enum-descriptions only if there's at least one non-empty description
             originalSchema.addExtension(X_ENUM_DESCRIPTIONS, new ArrayList<>(enumValues.values()));
         }
+        if (deprecatedValues != null && deprecatedValues.values().stream().anyMatch(Boolean.TRUE::equals)) {
+            // preserve per-value deprecated flags from OAS 3.1 oneOf/anyOf + const sub-schemas
+            originalSchema.addExtension("x-enum-deprecated", new ArrayList<>(deprecatedValues.values()));
+        }
 
         LOGGER.debug("Simplified {} with enum sub-schemas to single enum: {}", composedType, originalSchema);
 

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

@@ -1568,9 +1568,16 @@ public void testOpenAPINormalizerSimplifyOneOfAnyOf31Spec() {
         assertEquals(schema14.getType(), null);
 
         Schema schema16 = openAPI.getComponents().getSchemas().get("TypeIntegerWithOneOf");
-        assertEquals(schema16.getOneOf().size(),3);
-        assertEquals(((Schema) schema16.getOneOf().get(0)).getConst(), 1);
-        assertEquals(((Schema) schema16.getOneOf().get(0)).getDeprecated(), true);
+        // After normalization, oneOf with const values should be simplified to enum
+        assertEquals(schema16.getOneOf(), null);
+        assertEquals(schema16.getEnum().size(), 3);
+        assertEquals(schema16.getEnum().get(0), 1);
+        // per-value deprecated flags from oneOf sub-schemas should be preserved as x-enum-deprecated
+        List<Boolean> enumDeprecated = (List<Boolean>) schema16.getExtensions().get("x-enum-deprecated");
+        assertEquals(enumDeprecated.size(), 3);
+        assertEquals(enumDeprecated.get(0), Boolean.TRUE);
+        assertEquals(enumDeprecated.get(1), Boolean.FALSE);
+        assertEquals(enumDeprecated.get(2), Boolean.FALSE);
 
         Schema schema18 = openAPI.getComponents().getSchemas().get("OneOfNullAndRef3");
         // original oneOf removed and simplified to just $ref (oneOf sub-schema) instead