Add diagnostic for array type

Author: kimdv

Sources/SwiftParser/Types.swift

@@ -1052,7 +1052,38 @@ extension Parser {
         )
       )
     } else {
-      return self.parseType()
+      var result = self.parseType()
+
+      guard !result.hasError else {
+        return result
+      }
+
+      if self.at(.rightSquareBracket) {
+        let (unexpectedBeforeRSquareBracket, rightSquareBracket) = self.expect(.rightSquareBracket)
+        result = RawTypeSyntax(
+          RawArrayTypeSyntax(
+            leftSquareBracket: missingToken(.leftSquareBracket),
+            elementType: result,
+            unexpectedBeforeRSquareBracket,
+            rightSquareBracket: rightSquareBracket,
+            arena: self.arena
+          )
+        )
+      }
+
+      // After recovering, we continue parse the remaing `?` or `!` if they are present.
+      var continueParsingQuestionOrExclamationMark = true
+      while continueParsingQuestionOrExclamationMark {
+        if self.at(TokenSpec(.postfixQuestionMark, allowAtStartOfLine: false)) {
+          result = RawTypeSyntax(self.parseOptionalType(result))
+        } else if self.at(TokenSpec(.exclamationMark, allowAtStartOfLine: false)) {
+          result = RawTypeSyntax(self.parseImplicitlyUnwrappedOptionalType(result))
+        } else {
+          continueParsingQuestionOrExclamationMark = false
+        }
+      }
+
+      return result
     }
   }
 }

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -426,6 +426,23 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: ArrayTypeSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if node.leftSquareBracket.presence == .missing && node.rightSquareBracket.presence == .present {
+      addDiagnostic(
+        node.rightSquareBracket,
+        .extraRightBracket,
+        fixIts: [.init(message: InsertFixIt(tokenToBeInserted: node.leftSquareBracket), changes: .makePresent(node.leftSquareBracket))],
+        handledNodes: [node.leftSquareBracket.id]
+      )
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: AttributeSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -140,6 +140,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var expectedSequenceExpressionInForEachLoop: Self {
     .init("expected Sequence expression for for-each loop")
   }
+  public static var extraRightBracket: Self {
+    .init("unexpected ']' in type; did you mean to write an array type?")
+  }
   public static var initializerInPattern: Self {
     .init("unexpected initializer in pattern; did you mean to use '='?")
   }
@@ -557,6 +560,14 @@ extension FixItMessage where Self == StaticParserFixIt {
   }
 }
 
+public struct InsertFixIt: ParserFixIt {
+  public let tokenToBeInserted: TokenSyntax
+
+  public var message: String {
+    "insert '\(tokenToBeInserted.text)'"
+  }
+}
+
 public struct MoveTokensAfterFixIt: ParserFixIt {
   /// The token that should be moved
   public let movedTokens: [TokenSyntax]

Sources/SwiftSyntax/Raw/RawSyntaxNodeProtocol.swift

@@ -46,6 +46,14 @@ public extension RawSyntaxNodeProtocol {
   var isEmpty: Bool {
     return raw.byteLength == 0
   }
+
+  /// Whether the tree contained by this layout has any
+  ///  - missing nodes or
+  ///  - unexpected nodes or
+  ///  - tokens with a `TokenDiagnostic` of severity `error`
+  var hasError: Bool {
+    return raw.recursiveFlags.contains(.hasError)
+  }
 }
 
 /// `RawSyntax` itself conforms to `RawSyntaxNodeProtocol`.

Sources/SwiftSyntax/Syntax.swift

@@ -238,9 +238,9 @@ public extension SyntaxProtocol {
   /// Whether the tree contained by this layout has any
   ///  - missing nodes or
   ///  - unexpected nodes or
-  ///  - tokens with a `TokenDiagnostic` of severity `error`
+  ///  - tokens with a ``TokenDiagnostic`` of severity ``TokenDiagnostic/Severity-swift.enum/error``.
   var hasError: Bool {
-    return raw.recursiveFlags.contains(.hasError)
+    return raw.hasError
   }
 
   /// Whether the tree contained by this layout has any tokens with a

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -118,12 +118,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ActorDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ActorDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ActorDeclSyntax.members:
-    return "members"
-  case \ActorDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ActorDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ActorDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ActorDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \ArrayElementSyntax.unexpectedBeforeExpression:
     return "unexpectedBeforeExpression"
   case \ArrayElementSyntax.expression:
@@ -468,12 +468,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ClassDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ClassDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ClassDeclSyntax.members:
-    return "members"
-  case \ClassDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ClassDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ClassDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ClassDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \ClassRestrictionTypeSyntax.unexpectedBeforeClassKeyword:
     return "unexpectedBeforeClassKeyword"
   case \ClassRestrictionTypeSyntax.classKeyword:
@@ -1168,12 +1168,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \EnumDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \EnumDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \EnumDeclSyntax.members:
-    return "members"
-  case \EnumDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \EnumDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \EnumDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \EnumDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \ExposeAttributeArgumentsSyntax.unexpectedBeforeLanguage:
     return "unexpectedBeforeLanguage"
   case \ExposeAttributeArgumentsSyntax.language:
@@ -1246,12 +1246,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ExtensionDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ExtensionDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ExtensionDeclSyntax.members:
-    return "members"
-  case \ExtensionDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ExtensionDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ExtensionDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ExtensionDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \FallthroughStmtSyntax.unexpectedBeforeFallthroughKeyword:
     return "unexpectedBeforeFallthroughKeyword"
   case \FallthroughStmtSyntax.fallthroughKeyword:
@@ -2586,12 +2586,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ProtocolDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ProtocolDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ProtocolDeclSyntax.members:
-    return "members"
-  case \ProtocolDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ProtocolDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ProtocolDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ProtocolDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \QualifiedDeclNameSyntax.unexpectedBeforeBaseType:
     return "unexpectedBeforeBaseType"
   case \QualifiedDeclNameSyntax.baseType:
@@ -2776,12 +2776,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \StructDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \StructDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \StructDeclSyntax.members:
-    return "members"
-  case \StructDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \StructDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \StructDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \StructDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \SubscriptDeclSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
   case \SubscriptDeclSyntax.attributes:

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -791,7 +791,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)]))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier), .keyword("set")]))
+    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -1138,15 +1138,27 @@ final class RecoveryTests: XCTestCase {
     )
   }
 
-  func testRecovery98a() {
-    assertParse(
-      """
-      let a1: Swift.Int1️⃣]
-      """,
-      diagnostics: [
-        DiagnosticSpec(message: "extraneous code ']' at top level")
-      ]
-    )
+  func testRecovery98() {
+    let testCases: [UInt: (testCase: String, fixedSource: String)] = [
+      #line: ("let a1: Swift.Int1️⃣]", "let a1: [Swift.Int]"),
+      #line: ("let a3: Set<Int>1️⃣]", "let a3: [Set<Int>]"),
+      #line: ("let a4: Int1️⃣]?", "let a4: [Int]?"),
+      #line: ("let a5: Int?1️⃣]", "let a5: [Int?]"),
+      #line: ("let a6: [Int]1️⃣]", "let a6: [[Int]]"),
+      #line: ("let a7: [String: Int]1️⃣]", "let a7: [[String: Int]]"),
+      #line: ("func foo() -> Int1️⃣]??", "func foo() -> [Int]??"),
+    ]
+
+    for (line, testCase) in testCases {
+      assertParse(
+        testCase.testCase,
+        diagnostics: [
+          DiagnosticSpec(message: "unexpected ']' in type; did you mean to write an array type?", fixIts: ["insert '['"], line: line)
+        ],
+        fixedSource: testCase.fixedSource,
+        line: line
+      )
+    }
   }
 
   func testRecovery98b() {
@@ -1161,66 +1173,6 @@ final class RecoveryTests: XCTestCase {
     )
   }
 
-  func testRecovery98c() {
-    assertParse(
-      """
-      let a3: Set<Int>1️⃣]
-      """,
-      diagnostics: [
-        // TODO: Old parser expected error on line 4: unexpected ']' in type; did you mean to write an array type?, Fix-It replacements: 11 - 11 = '['
-        DiagnosticSpec(message: "extraneous code ']' at top level")
-      ]
-    )
-  }
-
-  func testRecovery98d() {
-    assertParse(
-      """
-      let a4: Int1️⃣]?
-      """,
-      diagnostics: [
-        // TODO: Old parser expected error on line 5: unexpected ']' in type; did you mean to write an array type?, Fix-It replacements: 11 - 11 = '['
-        DiagnosticSpec(message: "extraneous code ']?' at top level")
-      ]
-    )
-  }
-
-  func testRecovery98e() {
-    assertParse(
-      """
-      let a5: Int?1️⃣]
-      """,
-      diagnostics: [
-        // TODO: Old parser expected error on line 6: unexpected ']' in type; did you mean to write an array type?, Fix-It replacements: 11 - 11 = '['
-        DiagnosticSpec(message: "extraneous code ']' at top level")
-      ]
-    )
-  }
-
-  func testRecovery98f() {
-    assertParse(
-      """
-      let a6: [Int]1️⃣]
-      """,
-      diagnostics: [
-        // TODO: Old parser expected error on line 7: unexpected ']' in type; did you mean to write an array type?, Fix-It replacements: 11 - 11 = '['
-        DiagnosticSpec(message: "extraneous code ']' at top level")
-      ]
-    )
-  }
-
-  func testRecovery98g() {
-    assertParse(
-      """
-      let a7: [String: Int]1️⃣]
-      """,
-      diagnostics: [
-        // TODO: Old parser expected error on line 8: unexpected ']' in type; did you mean to write an array type?, Fix-It replacements: 11 - 11 = '['
-        DiagnosticSpec(message: "extraneous code ']' at top level")
-      ]
-    )
-  }
-
   func testRecovery99() {
     assertParse(
       """
@@ -1260,8 +1212,7 @@ final class RecoveryTests: XCTestCase {
       diagnostics: [
         DiagnosticSpec(locationMarker: "1️⃣", message: "expected '}' to end struct", fixIts: ["insert '}'"]),
         DiagnosticSpec(locationMarker: "2️⃣", message: "expected ']' to end array", fixIts: ["insert ']'"]),
-        // TODO: Old parser expected error on line 5: unexpected ']' in type; did you mean to write an array type?, Fix-It replacements: 17 - 17 = '['
-        DiagnosticSpec(locationMarker: "3️⃣", message: "unexpected code ']' in function"),
+        DiagnosticSpec(locationMarker: "3️⃣", message: "unexpected ']' in type; did you mean to write an array type?", fixIts: ["insert '['"]),
         DiagnosticSpec(locationMarker: "4️⃣", message: "extraneous brace at top level"),
       ]
     )