support references in TypeMatcher isOptional

Author: brandonbloom

Sources/_OpenAPIGeneratorCore/Translator/TypeAssignment/TypeMatcher.swift

@@ -244,32 +244,59 @@ struct TypeMatcher {
     /// - Parameters:
     ///   - schema: The schema to check.
     ///   - components: The OpenAPI components for looking up references.
+    ///   - cache: Memoised optionality by reference.
     /// - Throws: An error if there's an issue while checking the schema.
     /// - Returns: `true` if the schema is optional, `false` otherwise.
-    func isOptional(_ schema: JSONSchema, components: OpenAPI.Components) throws -> Bool {
+    func isOptional(_ schema: JSONSchema, components: OpenAPI.Components, cache: [JSONReference<JSONSchema>: Bool] = [:]) throws -> Bool {
         if schema.nullable || !schema.required { return true }
-        guard case .reference(let ref, _) = schema.value else { return false }
-        let targetSchema = try components.lookup(ref)
-        return try isOptional(targetSchema, components: components)
+        switch schema.value {
+        case .null(_):
+            return true
+        case .reference(let ref, _):
+            return try isOptional(ref, components: components, cache: cache)
+        case .one(of: let schemas, core: _):
+            return try schemas.contains(where: { try isOptional($0, components: components, cache: cache) })
+        default:
+            return schema.nullable
+        }
     }
 
     /// Returns a Boolean value indicating whether the schema is optional.
     /// - Parameters:
     ///   - schema: The schema to check.
     ///   - components: The OpenAPI components for looking up references.
+    ///   - cache: Memoised optionality by reference.
     /// - Throws: An error if there's an issue while checking the schema.
     /// - Returns: `true` if the schema is optional, `false` otherwise.
-    func isOptional(_ schema: UnresolvedSchema?, components: OpenAPI.Components) throws -> Bool {
+    func isOptional(_ schema: UnresolvedSchema?, components: OpenAPI.Components, cache: [JSONReference<JSONSchema>: Bool] = [:]) throws -> Bool {
         guard let schema else {
             // A nil unresolved schema represents a non-optional fragment.
             return false
         }
         switch schema {
         case .a(let ref):
-            let targetSchema = try components.lookup(ref)
-            return try isOptional(targetSchema, components: components)
-        case .b(let schema): return try isOptional(schema, components: components)
+            return try isOptional(ref.jsonReference, components: components, cache: cache)
+        case .b(let schema): return try isOptional(schema, components: components, cache: cache)
+        }
+    }
+
+    /// Returns a Boolean value indicating whether the referenced schema is optional.
+    /// - Parameters:
+    ///   - schema: The reference to check.
+    ///   - components: The OpenAPI components for looking up references.
+    ///   - cache: Memoised optionality by reference.
+    /// - Throws: An error if there's an issue while checking the schema.
+    /// - Returns: `true` if the schema is optional, `false` otherwise.
+    func isOptional(_ ref: JSONReference<JSONSchema>, components: OpenAPI.Components, cache: [JSONReference<JSONSchema>: Bool] = [:]) throws -> Bool {
+        if let result = cache[ref] {
+            return result
         }
+        let targetSchema = try components.lookup(ref)
+        var cache = cache
+        cache[ref] = false // Pre-cache to treat directly recursive types as non-nullable.
+        let result = try isOptional(targetSchema, components: components, cache: cache)
+        cache[ref] = result
+        return result
     }
 
     // MARK: - Private

Tests/OpenAPIGeneratorCoreTests/Translator/TypeAssignment/Test_TypeMatcher.swift

@@ -216,6 +216,8 @@ final class Test_TypeMatcher: Test_Core {
     }
 
     static let optionalTestCases: [(JSONSchema, Bool)] = [
+        // Explicit null.
+        (.null(), true),
 
         // A required string.
         (.string, false), (.string(required: true, nullable: false), false),
@@ -227,10 +229,26 @@ final class Test_TypeMatcher: Test_Core {
         // A reference pointing to a required schema.
         (.reference(.component(named: "RequiredString")), false),
         (.reference(.component(named: "NullableString")), true),
+
+        // Unknown type.
+        (.fragment(), false),
+        (.fragment(nullable: true), true),
+
+        // References.
+        (.reference(.component(named: "List")), true),
+        (.reference(.component(named: "Loop")), false),
     ]
     func testOptionalSchemas() throws {
         let components = OpenAPI.Components(schemas: [
             "RequiredString": .string, "NullableString": .string(nullable: true),
+            // Singlely linked list where null is an empty list.
+            "List": .one(of: [
+                .null(),
+                .object(properties: ["next": .reference(.component(named: "List"),
+                                                        required: true)])]),
+            // A non-empty circular linked list.
+            "Loop": .object(properties: ["next": .reference(.component(named: "Loop"),
+                                                            required: true)]),
         ])
         for (schema, expectedIsOptional) in Self.optionalTestCases {
             let actualIsOptional = try typeMatcher.isOptional(schema, components: components)