Support replacement also in inline defined schemas

Author: simonbility

Sources/_OpenAPIGeneratorCore/Translator/CommonTranslations/translateSchema.swift

@@ -87,16 +87,11 @@ extension TypesFileTranslator {
                 )
             )
         }
-        if let substituteTypeName = schema.vendorExtensions["x-swift-open-api-substitute-type"]?.value
-            as? String
-        {
-            try diagnostics.emit(.note(message: "Substituting type \(typeName) with \(substituteTypeName)"))
-            let substitutedType = TypeName(swiftKeyPath: substituteTypeName.components(separatedBy: ".")).asUsage
-            
-            let typealiasDecl = try translateTypealias(
+        if let substituteType = schema.value.substituteType() {
+            let typealiasDecl = try translateSubstitutedType(
                 named: typeName,
                 userDescription: overrides.userDescription ?? schema.description,
-                to: substitutedType.withOptional(
+                to: substituteType.asUsage.withOptional(
                     overrides.isOptional ?? typeMatcher.isOptional(schema, components: components)
                 )
             )

Sources/_OpenAPIGeneratorCore/Translator/CommonTranslations/translateSubstitutedType.swift

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftOpenAPIGenerator open source project
+//
+// Copyright (c) 2023 Apple Inc. and the SwiftOpenAPIGenerator project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftOpenAPIGenerator project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+import OpenAPIKit
+
+extension FileTranslator {
+
+    /// Returns a declaration of a typealias.
+    /// - Parameters:
+    ///   - typeName: The name of the type to give to the declared typealias.
+    ///   - userDescription: A user-specified description from the OpenAPI document.
+    ///   - existingTypeUsage: The existing type the alias points to.
+    /// - Throws: An error if there is an issue during translation.
+    /// - Returns: A declaration representing the translated typealias.
+    func translateSubstitutedType(named typeName: TypeName, userDescription: String?, to existingTypeUsage: TypeUsage) throws
+        -> Declaration
+    {
+        let typealiasDescription = TypealiasDescription(
+            accessModifier: config.access,
+            name: typeName.shortSwiftName,
+            existingType: .init(existingTypeUsage.withOptional(false))
+        )
+        let typealiasComment: Comment? = typeName.docCommentWithUserDescription(userDescription)
+        return .commentable(typealiasComment, .typealias(typealiasDescription))
+    }
+}

Sources/_OpenAPIGeneratorCore/Translator/CommonTypes/Constants.swift

@@ -372,6 +372,8 @@ enum Constants {
         /// The substring used in method names for the multipart coding strategy.
         static let multipart: String = "Multipart"
     }
+    /// Constants related to the vendor extensions..
+    enum VendorExtension { static let replaceType: String = "x-swift-open-api-replace-type" }
 
     /// Constants related to types used in many components.
     enum Global {

Sources/_OpenAPIGeneratorCore/Translator/TypeAssignment/TypeMatcher.swift

@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 import OpenAPIKit
+import Foundation
 
 /// A set of functions that match Swift types onto OpenAPI types.
 struct TypeMatcher {
@@ -46,7 +47,11 @@ struct TypeMatcher {
             matchedArrayHandler: { elementType, nullableItems in
                 nullableItems ? elementType.asOptional.asArray : elementType.asArray
             },
-            genericArrayHandler: { TypeName.arrayContainer.asUsage }
+            genericArrayHandler: { TypeName.arrayContainer.asUsage },
+            substitutedTypeHandler: { substitute in
+                // never built-in
+                nil
+            }
         )
     }
 
@@ -75,7 +80,10 @@ struct TypeMatcher {
             matchedArrayHandler: { elementType, nullableItems in
                 nullableItems ? elementType.asOptional.asArray : elementType.asArray
             },
-            genericArrayHandler: { TypeName.arrayContainer.asUsage }
+            genericArrayHandler: { TypeName.arrayContainer.asUsage },
+            substitutedTypeHandler: { substitute in
+                substitute.asUsage
+            }
         )?
         .withOptional(isOptional(schema, components: components))
     }
@@ -98,7 +106,8 @@ struct TypeMatcher {
                 return true
             },
             matchedArrayHandler: { elementIsReferenceable, _ in elementIsReferenceable },
-            genericArrayHandler: { true }
+            genericArrayHandler: { true },
+            substitutedTypeHandler: { _ in true }
         ) ?? false
     }
 
@@ -353,8 +362,10 @@ struct TypeMatcher {
         for schema: JSONSchema.Schema,
         test: (JSONSchema.Schema) throws -> R?,
         matchedArrayHandler: (R, _ nullableItems: Bool) -> R,
-        genericArrayHandler: () -> R
+        genericArrayHandler: () -> R,
+        substitutedTypeHandler: (TypeName) -> R?
     ) rethrows -> R? {
+        if let substitute = schema.substituteType() { return substitutedTypeHandler(substitute) }
         switch schema {
         case let .array(_, arrayContext):
             guard let items = arrayContext.items else { return genericArrayHandler() }
@@ -363,11 +374,39 @@ struct TypeMatcher {
                     for: items.value,
                     test: test,
                     matchedArrayHandler: matchedArrayHandler,
-                    genericArrayHandler: genericArrayHandler
+                    genericArrayHandler: genericArrayHandler,
+                    substitutedTypeHandler: substitutedTypeHandler
                 )
             else { return nil }
             return matchedArrayHandler(itemsResult, items.nullable)
         default: return try test(schema)
         }
     }
 }
+
+extension JSONSchema.Schema {
+    func substituteType() -> TypeName? {
+        let extensions: [String: AnyCodable] =
+            switch self {
+            case .null(let context): context.vendorExtensions
+            case .boolean(let context): context.vendorExtensions
+            case .number(let context, _): context.vendorExtensions
+            case .integer(let context, _): context.vendorExtensions
+            case .string(let context, _): context.vendorExtensions
+            case .object(let context, _): context.vendorExtensions
+            case .array(let context, _): context.vendorExtensions
+            case .all(of: _, core: let context): context.vendorExtensions
+            case .one(of: _, core: let context): context.vendorExtensions
+            case .any(of: _, core: let context): context.vendorExtensions
+            case .not: [:]
+            case .reference(_, let context): context.vendorExtensions
+            case .fragment(let context): context.vendorExtensions
+            }
+        guard let substituteTypeName = extensions[Constants.VendorExtension.replaceType]?.value as? String else {
+            return nil
+        }
+        assert(!substituteTypeName.isEmpty)
+        
+        return TypeName(swiftKeyPath: substituteTypeName.components(separatedBy: "."))
+    }
+}