Allow non-unique values in oneOf.discriminator.mapping (#225)

Allow non-unique values in oneOf.discriminator.mapping

### Motivation

Fixes #223, see the issue for details.

### Modifications

Changed the logic for deriving the enum cases to take both the mapping and the list of subschemas into account. Documented it more in code.

### Result

Now adopter can actually have different keys pointing to the same types in their mapping - originally reported by an adopter, so it's a real issue.

### Test Plan

Adapted tests.

Reviewed by: glbrntt

Builds:
     ✔︎ pull request validation (5.8) - Build finished. 
     ✔︎ pull request validation (5.9) - Build finished. 
     ✔︎ pull request validation (docc test) - Build finished. 
     ✔︎ pull request validation (integration test) - Build finished. 
     ✔︎ pull request validation (nightly) - Build finished. 
     ✔︎ pull request validation (soundness) - Build finished. 

#225

Author: czechboy0

Sources/_OpenAPIGeneratorCore/Layers/StructuredSwiftRepresentation.swift

@@ -636,6 +636,11 @@ enum SwitchCaseKind: Equatable, Codable {
     /// For example: `case let foo(bar):`.
     case `case`(Expression, [String])
 
+    /// A case with multiple comma-separated expressions.
+    ///
+    /// For example: `case "foo", "bar":`.
+    case multiCase([Expression])
+
     /// A default. Spelled as `default:`.
     case `default`
 }

Sources/_OpenAPIGeneratorCore/Renderer/TextBasedRenderer.swift

@@ -152,6 +152,9 @@ struct TextBasedRenderer: RendererProtocol {
                 maybeLet = ""
             }
             return "case \(maybeLet)\(renderedExpression(expression))\(associatedValues)"
+        case .multiCase(let expressions):
+            let expressions = expressions.map(renderedExpression).joined(separator: ", ")
+            return "case \(expressions)"
         case .`default`:
             return "default"
         }

Sources/_OpenAPIGeneratorCore/Translator/CommonTranslations/translateAllAnyOneOf.swift

@@ -124,55 +124,71 @@ extension FileTranslator {
         discriminator: OpenAPI.Discriminator?,
         schemas: [JSONSchema]
     ) throws -> Declaration {
-        // > When using the discriminator, inline schemas will not be considered.
-        // > — https://spec.openapis.org/oas/v3.0.3#discriminator-object
-        let includedSchemas: [JSONSchema]
-        if discriminator != nil {
-            includedSchemas = schemas.filter(\.isReference)
-        } else {
-            includedSchemas = schemas
-        }
-
-        let cases: [(String, Comment?, TypeUsage, [Declaration])] =
-            try includedSchemas
-            .enumerated()
-            .map { index, schema in
-                let key = "case\(index+1)"
-                let childType = try typeAssigner.typeUsage(
-                    forAllOrAnyOrOneOfChildSchemaNamed: key,
-                    withSchema: schema,
-                    inParent: typeName
-                )
-                let caseName: String
-                // Only use the type name for the case for references,
-                // as inline schemas have nothing that guarantees uniqueness.
-                if schema.isReference {
-                    // Use the type name.
-                    caseName = childType.typeName.shortSwiftName
-                } else {
-                    // Use a position-based key.
-                    caseName = key
+        let cases: [(String, [String]?, Comment?, TypeUsage, [Declaration])]
+        if let discriminator {
+            // > When using the discriminator, inline schemas will not be considered.
+            // > — https://spec.openapis.org/oas/v3.0.3#discriminator-object
+            let includedSchemas: [JSONReference<JSONSchema>] =
+                schemas
+                .compactMap { schema in
+                    guard case let .reference(ref, _) = schema.value else {
+                        return nil
+                    }
+                    return ref
                 }
+            let mappedTypes = try discriminator.allTypes(
+                schemas: includedSchemas,
+                typeAssigner: typeAssigner
+            )
+            cases = mappedTypes.map { mappedType in
                 let comment: Comment? = .child(
-                    originalName: key,
-                    userDescription: schema.description,
+                    originalName: mappedType.typeName.shortSwiftName,
+                    userDescription: nil,
                     parent: typeName
                 )
-                let associatedDeclarations: [Declaration]
-                if TypeMatcher.isInlinable(schema) {
-                    associatedDeclarations = try translateSchema(
-                        typeName: childType.typeName,
-                        schema: schema,
-                        overrides: .none
+                let caseName = safeSwiftNameForOneOfMappedType(mappedType)
+                return (caseName, mappedType.rawNames, comment, mappedType.typeName.asUsage, [])
+            }
+        } else {
+            cases = try schemas.enumerated()
+                .map { index, schema in
+                    let key = "case\(index+1)"
+                    let childType = try typeAssigner.typeUsage(
+                        forAllOrAnyOrOneOfChildSchemaNamed: key,
+                        withSchema: schema,
+                        inParent: typeName
                     )
-                } else {
-                    associatedDeclarations = []
+                    let caseName: String
+                    // Only use the type name for the case for references,
+                    // as inline schemas have nothing that guarantees uniqueness.
+                    if schema.isReference {
+                        // Use the type name.
+                        caseName = childType.typeName.shortSwiftName
+                    } else {
+                        // Use a position-based key.
+                        caseName = key
+                    }
+                    let comment: Comment? = .child(
+                        originalName: key,
+                        userDescription: schema.description,
+                        parent: typeName
+                    )
+                    let associatedDeclarations: [Declaration]
+                    if TypeMatcher.isInlinable(schema) {
+                        associatedDeclarations = try translateSchema(
+                            typeName: childType.typeName,
+                            schema: schema,
+                            overrides: .none
+                        )
+                    } else {
+                        associatedDeclarations = []
+                    }
+                    return (caseName, nil, comment, childType, associatedDeclarations)
                 }
-                return (caseName, comment, childType, associatedDeclarations)
-            }
+        }
 
         let caseDecls: [Declaration] = cases.flatMap { caseInfo in
-            let (caseName, comment, childType, associatedDeclarations) = caseInfo
+            let (caseName, _, comment, childType, associatedDeclarations) = caseInfo
             return associatedDeclarations + [
                 .commentable(
                     comment,
@@ -211,12 +227,9 @@ extension FileTranslator {
                     ]
                 )
             ]
-
-            let allTypes = cases.map { $0.2.typeName }
-            let mappedTypes = try discriminator.mappedTypes(allTypes)
             decoder = translateOneOfWithDiscriminatorDecoder(
                 discriminatorName: swiftName,
-                cases: mappedTypes
+                cases: cases.map { ($0.0, $0.1!) }
             )
         } else {
             undocumentedType = .valueContainer

Sources/_OpenAPIGeneratorCore/Translator/CommonTranslations/translateCodable.swift

@@ -420,23 +420,20 @@ extension FileTranslator {
     }
 
     /// Returns a declaration of a oneOf with a discriminator decoder implementation.
-    /// - Parameters:
-    ///   - caseNames: The cases to decode, first element is the raw string to check for, the second
-    ///     element is the case name (without the leading dot).
     func translateOneOfWithDiscriminatorDecoder(
         discriminatorName: String,
-        cases: [OneOfMappedType]
+        cases: [(caseName: String, rawNames: [String])]
     ) -> Declaration {
         let cases: [SwitchCaseDescription] =
             cases
-            .map { caseInfo in
+            .map { caseName, rawNames in
                 .init(
-                    kind: .case(.literal(caseInfo.rawName)),
+                    kind: .multiCase(rawNames.map { .literal($0) }),
                     body: [
                         .expression(
                             .assignment(
                                 left: .identifier("self"),
-                                right: .dot(caseInfo.caseName)
+                                right: .dot(caseName)
                                     .call([
                                         .init(
                                             label: nil,