Recover and detect a missing comma in a tupel

Author: flashspys

Sources/SwiftParser/Parser.swift

@@ -149,7 +149,7 @@ public struct Parser: TokenConsumer {
   }
 
   @_spi(RawSyntax)
-  public mutating func missingToken(_ kind: RawTokenKind, text: SyntaxText?) -> RawTokenSyntax {
+  public mutating func missingToken(_ kind: RawTokenKind, text: SyntaxText? = nil) -> RawTokenSyntax {
     return RawTokenSyntax(missing: kind, text: text, arena: self.arena)
   }
 
@@ -327,7 +327,7 @@ extension Parser {
         if let remapping = remapping {
           return $0.missingToken(remapping, text: kind.defaultText)
         } else {
-          return $0.missingToken(kind, text: nil)
+          return $0.missingToken(kind)
         }
       }
     )
@@ -366,7 +366,7 @@ extension Parser {
     return expectImpl(
       consume: { $0.consume(ifAny: kinds, contextualKeywords: contextualKeywords) },
       canRecoverTo: { $0.canRecoverTo(kinds, contextualKeywords: contextualKeywords) },
-      makeMissing: { $0.missingToken(defaultKind, text: nil) }
+      makeMissing: { $0.missingToken(defaultKind) }
     )
   }
 
@@ -390,7 +390,7 @@ extension Parser {
     if let unknown = self.consume(if: .unknown) {
       return (
         RawUnexpectedNodesSyntax(elements: [RawSyntax(unknown)], arena: self.arena),
-        self.missingToken(.identifier, text: nil)
+        self.missingToken(.identifier)
       )
     }
     if let number = self.consume(ifAny: [.integerLiteral, .floatingLiteral]) {
@@ -407,7 +407,7 @@ extension Parser {
     }
     return (
       nil,
-      self.missingToken(.identifier, text: nil)
+      self.missingToken(.identifier)
     )
   }
 
@@ -419,12 +419,12 @@ extension Parser {
     if let unknown = self.consume(if: .unknown) {
       return (
         RawUnexpectedNodesSyntax(elements: [RawSyntax(unknown)], arena: self.arena),
-        self.missingToken(.identifier, text: nil)
+        self.missingToken(.identifier)
       )
     }
     return (
       nil,
-      self.missingToken(.identifier, text: nil)
+      self.missingToken(.identifier)
     )
   }
 

Sources/SwiftParser/Types.swift

@@ -426,10 +426,36 @@ extension Parser {
           unexpectedBeforeColon = nil
           colon = nil
         }
+        
+        // In the case that the input is "(foo bar)" we have to decide whether we parse it as "(foo: bar)" or "(foo, bar)".
+        // As most people write identifiers lowercase and types capitalized, we decide on the first character of the first token
+        if let first = first,
+            second == nil,
+            colon?.isMissing == true,
+            first.tokenText.description.first?.isUppercase == true {
+          elements.append(RawTupleTypeElementSyntax(
+            inOut: nil,
+            name: nil,
+            secondName: nil,
+            unexpectedBeforeColon,
+            colon: nil,
+            type: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: first, genericArgumentClause: nil, arena: self.arena)),
+            ellipsis: nil,
+            initializer: nil,
+            trailingComma: self.missingToken(.comma),
+            arena: self.arena
+          ))
+          keepGoing = true
+          continue
+        }
         // Parse the type annotation.
         let type = self.parseType(misplacedSpecifiers: misplacedSpecifiers)
         let ellipsis = self.currentToken.isEllipsis ? self.consumeAnyToken() : nil
-        let trailingComma = self.consume(if: .comma)
+        var trailingComma = self.consume(if: .comma)
+        if trailingComma == nil && self.withLookahead({ $0.canParseType() }) {
+          // If the next token does not close the tuple, it is very likely the user forgot the comma.
+          trailingComma = self.missingToken(.comma)
+        }
         keepGoing = trailingComma != nil
         elements.append(RawTupleTypeElementSyntax(
             inOut: nil,

Tests/SwiftParserTest/Types.swift

@@ -357,10 +357,87 @@ final class TypeParameterPackTests: XCTestCase {
   func testParameterPacks28() throws {
     // We allow whitespace between the generic parameter and the '...', this is
     // consistent with regular variadic parameters.
+    AssertParse(
+    """
+    func f1<T ...>(_ x: T ...) -> (T ...) {}
+    """)
+  }
+  
+  func testMissingCommaInType() throws {
     AssertParse(
       """
-      func f1<T ...>(_ x: T ...) -> (T ...) {}
+      var foo: (Int)
       """)
+    
+    AssertParse(
+      """
+      var foo: (Int, Int)
+      """)
+    
+    AssertParse(
+      """
+      var foo: (bar: Int 1️⃣bar2: Int)
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ',' in tuple type")
+      ])
+    
+    AssertParse(
+      """
+      var foo: (bar: Int 1️⃣Int)
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ',' in tuple type")
+      ])
+    
+    AssertParse(
+      """
+      var foo: (a 1️⃣Int)
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ':' in tuple type")
+      ])
+    
+    AssertParse(
+      """
+      var foo: (A 1️⃣Int)
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ',' in tuple type")
+      ])
+    
+    AssertParse(
+      """
+      var foo: (_ 1️⃣a 2️⃣Int)
+      """,
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "1️⃣", message: "expected ':' in tuple type"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "expected ',' in tuple type")
+      ])
+    
+    AssertParse(
+      """
+      var foo: (Array<Foo> 1️⃣Array<Bar>)
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ',' in tuple type"),
+      ])
+    
+    AssertParse(
+      """
+      var foo: (a 1️⃣Array<Bar>)
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ':' in tuple type"),
+      ])
+    
+    AssertParse(
+      """
+      var foo: (Array<Foo> 1️⃣a)
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ',' in tuple type"),
+      ])
   }
 }