[BUG] Harden isOptional resolving (#67)

Co-authored-by: Michael O’Brien <obrien.michael1@police.qld.gov.au>

Author: mobrien-ghost

Sources/SyntaxSparrow/Internal/Extensions/SyntaxProtocol+IsOptional.swift

@@ -18,27 +18,13 @@ extension SyntaxProtocol {
     func resolveIsSyntaxOptional(viewMode: SyntaxTreeViewMode = .fixedUp) -> Bool {
         guard self.as(OptionalTypeSyntax.self) == nil else { return true }
         guard parent?.as(OptionalTypeSyntax.self) == nil else { return true }
-        // Token assessment approach
-        var result = false
-        var nextToken = nextToken(viewMode: .fixedUp)
-        var potentialOptional: Bool = nextToken?.text == "?"
-        while nextToken != nil {
-            if nextToken?.text == ")" {
-                potentialOptional = true
-            }
-            if potentialOptional, nextToken?.text == ")" {
-                break
-            }
-            if potentialOptional, nextToken?.text == "?" {
-                result = true
-                break
-            }
-            nextToken = nextToken?.nextToken(viewMode: .fixedUp)
+        if let parent = parent?.as(TypeAnnotationSyntax.self) {
+            return parent.type.as(OptionalTypeSyntax.self) != nil
+        } else if let tupleElement = self.as(TupleTypeElementSyntax.self) {
+            return tupleElement.type.as(OptionalTypeSyntax.self) != nil
+        } else if let generic = self.as(GenericArgumentSyntax.self) {
+            return generic.argument.as(OptionalTypeSyntax.self) != nil
         }
-        // Fallback child approach
-        if !result, children(viewMode: viewMode).contains(where: { $0.syntaxNodeType == OptionalTypeSyntax.self }) {
-            return true
-        }
-        return result
+        return false
     }
 }

Tests/SyntaxSparrowTests/Supporting Types/EntityTypeTests.swift

@@ -78,7 +78,7 @@ final class EntityTypeTests: XCTestCase {
     func test_array_asVariable_willReturnExpectedTypes() throws {
         let source = """
         var arrayShorthand: [(name: String, age: Int?)]?
-        var arrayIdentifier: Array<String>)
+        var arrayIdentifier: Array<String>?
         """
         instanceUnderTest.updateToSource(source)
         XCTAssertTrue(instanceUnderTest.isStale)
@@ -111,11 +111,11 @@ final class EntityTypeTests: XCTestCase {
         target = instanceUnderTest.variables[1]
         XCTAssertEqual(target.keyword, "var")
         XCTAssertEqual(target.name, "arrayIdentifier")
-        XCTAssertFalse(target.isOptional)
+        XCTAssertTrue(target.isOptional)
 
         if case let EntityType.array(array) = target.type {
             XCTAssertEqual(array.declType, .generic)
-            XCTAssertFalse(array.isOptional)
+            XCTAssertTrue(array.isOptional)
             XCTAssertEqual(array.elementType, .simple("String"))
         } else {
             XCTFail("variable type should be Array")