Closure Parsing Omnibus

Sources/SwiftParser/Expressions.swift

@@ -1668,12 +1668,18 @@ extension Parser {
             arena: self.arena))
         } while keepGoing != nil && loopProgress.evaluate(currentToken)
       }
+      // We were promised a right square bracket, so we're going to get it.
+      var unexpectedNodes = [RawSyntax]()
+      while !self.at(.eof) && !self.at(.rightSquareBracket) && !self.at(.inKeyword) {
+        unexpectedNodes.append(RawSyntax(self.consumeAnyToken()))
+      }
       let (unexpectedBeforeRSquare, rsquare) = self.expect(.rightSquareBracket)
+      unexpectedNodes.append(contentsOf: unexpectedBeforeRSquare?.elements ?? [])
 
       captures = RawClosureCaptureSignatureSyntax(
         leftSquare: lsquare,
         items: elements.isEmpty ? nil : RawClosureCaptureItemListSyntax(elements: elements, arena: self.arena),
-        unexpectedBeforeRSquare,
+        unexpectedNodes.isEmpty ? nil : RawUnexpectedNodesSyntax(elements: unexpectedNodes, arena: self.arena),
         rightSquare: rsquare, arena: self.arena)
     } else {
       captures = nil
@@ -1694,15 +1700,17 @@ extension Parser {
           // Parse identifier (',' identifier)*
           var keepGoing: RawTokenSyntax? = nil
           repeat {
+            let unexpected: RawUnexpectedNodesSyntax?
             let name: RawTokenSyntax
             if self.currentToken.isIdentifier {
+              unexpected = nil
               name = self.consumeIdentifier()
             } else {
-              name = self.eat(.wildcardKeyword)
+              (unexpected, name) = self.expect(.wildcardKeyword)
             }
             keepGoing = consume(if: .comma)
             params.append(RawClosureParamSyntax(
-              name: name, trailingComma: keepGoing, arena: self.arena))
+              unexpected, name: name, trailingComma: keepGoing, arena: self.arena))
           } while keepGoing != nil && loopProgress.evaluate(currentToken)
         }
 
@@ -1751,10 +1759,14 @@ extension Parser {
         specifiers.append(self.consumeIdentifier())
         if let lparen = self.consume(if: .leftParen) {
           specifiers.append(lparen)
-          specifiers.append(self.expectWithoutLookahead(.identifier, "unsafe"))
+          if self.currentToken.tokenText == "safe" {
+            specifiers.append(self.expectWithoutLookahead(.identifier, "safe"))
+          } else {
+            specifiers.append(self.expectWithoutLookahead(.identifier, "unsafe"))
+          }
           specifiers.append(self.expectWithoutLookahead(.rightParen))
         }
-      } else if (self.currentToken.isIdentifier || self.at(.selfKeyword)) {
+      } else if self.currentToken.isIdentifier || self.at(.selfKeyword) {
         let next = self.peek()
         // "x = 42", "x," and "x]" are all strong captures of x.
         guard next.tokenKind == .equal || next.tokenKind == .comma
@@ -1991,7 +2003,6 @@ extension Parser.Lookahead {
   mutating func consumeEffectsSpecifiers() {
     var loopProgress = LoopProgressCondition()
     while self.currentToken.isEffectsSpecifier
-            && !self.currentToken.isAtStartOfLine
             && loopProgress.evaluate(currentToken) {
       self.consumeAnyToken()
     }

Tests/SwiftParserTest/Assertions.swift

@@ -64,13 +64,25 @@ struct DiagnosticSpec {
   /// If not `nil`, assert that the diagnostic contains fix-its with these messages.
   /// Use the `fixedSource` parameter on `AssertParse` to check that applying the Fix-It yields the expected result.
   let fixIts: [String]?
+  let file: StaticString
+  let line: UInt
 
-  init(locationMarker: String = "DIAG", id: MessageID? = nil, message: String?, highlight: String? = nil, fixIts: [String]? = nil) {
+  init(
+    locationMarker: String = "DIAG",
+    id: MessageID? = nil,
+    message: String?,
+    highlight: String? = nil,
+    fixIts: [String]? = nil,
+    file: StaticString = #file,
+    line: UInt = #line
+  ) {
     self.locationMarker = locationMarker
     self.id = id
     self.message = message
     self.highlight = highlight
     self.fixIts = fixIts
+    self.file = file
+    self.line = line
   }
 }
 
@@ -232,7 +244,7 @@ func AssertParse<Node: RawSyntaxNodeProtocol>(
         """, file: file, line: line)
       }
       for (diag, expectedDiag) in zip(diags, expectedDiagnostics) {
-        AssertDiagnostic(diag, in: tree, markerLocations: markerLocations, expected: expectedDiag, file: file, line: line)
+        AssertDiagnostic(diag, in: tree, markerLocations: markerLocations, expected: expectedDiag, file: expectedDiag.file, line: expectedDiag.line)
       }
 
       // Applying Fix-Its

Tests/SwiftParserTest/Expressions.swift

@@ -443,7 +443,7 @@ final class ExpressionTests: XCTestCase {
     )
   }
 
-  func testClouserExpression() {
+  func testClosureExpression() {
     AssertParse(
       """
       let :(#^DIAG_1^#..)->

Tests/SwiftParserTest/Types.swift

@@ -32,4 +32,25 @@ final class TypeTests: XCTestCase {
       DiagnosticSpec(message: "Unexpected text '..' found in function type")
     ])
   }
+
+  func testClosureSignatures() throws {
+    AssertParse("""
+                { ()
+                throws -> Void in }
+                """,
+                { $0.parseClosureExpression() })
+
+    AssertParse("""
+                { [weak a, unowned(safe) self, b = 3] (a: Int, b: Int, _: Int) -> Int in }
+                """,
+                { $0.parseClosureExpression() })
+
+    AssertParse("{[#^DIAG_1^#class]in#^DIAG_2^#",
+                { $0.parseClosureExpression() },
+                diagnostics: [
+                  DiagnosticSpec(locationMarker: "DIAG_1", message: "Expected '' in closure capture item"),
+                  DiagnosticSpec(locationMarker: "DIAG_1", message: "Unexpected text 'class' found in closure capture signature"),
+                  DiagnosticSpec(locationMarker: "DIAG_2", message: "Expected '}' to end closure"),
+                ])
+  }
 }