tbs

Author: rintaro

Sources/SwiftParser/CollectionNodes+Parsable.swift

@@ -116,7 +116,7 @@ extension CodeBlockItemListSyntax: SyntaxParseable {
 extension MemberBlockItemListSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     return parse(from: &parser) { parser in
-      return parser.parseMemberDeclList()
+      return parser.parseMemberDeclList(until: { _ in false })
     } makeMissing: { remainingTokens, arena in
       let missingDecl = RawMissingDeclSyntax(
         attributes: RawAttributeListSyntax(elements: [], arena: arena),

Sources/SwiftParser/Declarations.swift

@@ -966,13 +966,9 @@ extension Parser {
       decl = self.parseDeclaration(in: .memberDeclList)
       attachSemi = true
     } else {
+      // Otherwise, eat the unexpected tokens into an "decl".
       decl = RawDeclSyntax(
-        self.parseUnexpectedCodeDeclaration(
-          allowInitDecl: true,
-          requiresDecl: true,
-          skipToDeclOnly: true,
-          until: stopCondition
-        )
+        self.parseUnexpectedCodeDeclaration(allowInitDecl: true, requiresDecl: true, until: stopCondition)
       )
       attachSemi = true
     }
@@ -1009,7 +1005,7 @@ extension Parser {
   }
 
   mutating func parseMemberDeclList(
-    until stopCondition: (inout Parser) -> Bool = { $0.at(.rightBrace) }
+    until stopCondition: (inout Parser) -> Bool = { $0.at(.rightBrace) || $0.atEndOfIfConfigClauseBody() }
   ) -> RawMemberBlockItemListSyntax {
     var elements = [RawMemberBlockItemSyntax]()
     do {
@@ -1765,7 +1761,7 @@ extension Parser {
     // There can only be an implicit getter if no other accessors were
     // seen before this one.
     guard let accessorList else {
-      let body = parseCodeBlockItemList(until: { $0.at(.rightBrace) })
+      let body = parseCodeBlockItemList()
 
       let (unexpectedBeforeRBrace, rbrace) = self.expect(.rightBrace)
       return RawAccessorBlockSyntax(
@@ -2326,20 +2322,20 @@ extension Parser {
     )
   }
 
-  /// Eat tokens until a start of decl, or if `skipToDeclOnly` is not set until
-  /// a start of statement or expression.
+  /// Eats tokens until a start of decl, statement, or expression.
   /// Returns consumed tokens as a `RawUnexpectedCodeDeclSyntax` declaration.
   mutating func parseUnexpectedCodeDeclaration(
     allowInitDecl: Bool,
     requiresDecl: Bool,
-    skipToDeclOnly: Bool,
     until stopCondition: (inout Parser) -> Bool
   ) -> RawUnexpectedCodeDeclSyntax {
     var unexpectedTokens = [RawSyntax]()
-    while !self.at(.endOfFile, .semicolon) && !stopCondition(&self) {
-      let numTokensToSkip = self.withLookahead({
-        $0.skipSingle(); return $0.tokensConsumed
-      })
+    var loopProgress = LoopProgressCondition()
+    while !self.at(.endOfFile, .semicolon), !stopCondition(&self), self.hasProgressed(&loopProgress) {
+      let numTokensToSkip = self.withLookahead {
+        $0.skipSingle()
+        return $0.tokensConsumed
+      }
       for _ in 0..<numTokensToSkip {
         unexpectedTokens.append(RawSyntax(self.consumeAnyTokenWithoutAdjustingNestingLevel()))
       }
@@ -2354,13 +2350,14 @@ extension Parser {
         break
       }
 
-      if skipToDeclOnly {
+      // If a declaration is expected, ignore statements and expressions.
+      if requiresDecl {
         continue
       }
       if self.atStartOfStatement(preferExpr: false) {
         break
       }
-      // Recover to an expression only if it's on the next line.
+      // Recover to an expression only if it's on a new line.
       if self.currentToken.isAtStartOfLine && self.atStartOfExpression() {
         break
       }

Sources/SwiftParser/Expressions.swift

@@ -1773,7 +1773,7 @@ extension Parser {
     let signature = self.parseClosureSignatureIfPresent()
 
     // Parse the body.
-    let elements = parseCodeBlockItemList(until: { $0.at(.rightBrace) })
+    let elements = parseCodeBlockItemList()
 
     // Parse the closing '}'.
     let (unexpectedBeforeRBrace, rbrace) = self.expect(.rightBrace)
@@ -2331,9 +2331,7 @@ extension Parser {
   mutating func parseSwitchCases(allowStandaloneStmtRecovery: Bool) -> RawSwitchCaseListSyntax {
     var elements = [RawSwitchCaseListSyntax.Element]()
     var elementsProgress = LoopProgressCondition()
-    while !self.at(.endOfFile, .rightBrace) && !self.at(.poundEndif, .poundElseif, .poundElse)
-      && self.hasProgressed(&elementsProgress)
-    {
+    while !self.at(.endOfFile, .rightBrace), !self.atEndOfIfConfigClauseBody(), self.hasProgressed(&elementsProgress) {
       if self.withLookahead({ $0.atStartOfSwitchCase(allowRecovery: false) }) {
         elements.append(.switchCase(self.parseSwitchCase()))
       } else if self.canRecoverTo(.poundIf) != nil {
@@ -2346,10 +2344,7 @@ extension Parser {
             })
           )
         )
-      } else if allowStandaloneStmtRecovery
-        && (self.atStartOfExpression() || self.atStartOfStatement(preferExpr: false)
-          || self.atStartOfDeclaration())
-      {
+      } else if allowStandaloneStmtRecovery {
         // Synthesize a label for the statement or declaration that isn't covered by a case right now.
         let statements = parseSwitchCaseBody()
         if statements.isEmpty {
@@ -2385,8 +2380,6 @@ extension Parser {
             )
           )
         )
-      } else if self.withLookahead({ $0.atStartOfSwitchCase(allowRecovery: true) }) {
-        elements.append(.switchCase(self.parseSwitchCase()))
       } else {
         break
       }
@@ -2396,14 +2389,11 @@ extension Parser {
 
   mutating func parseSwitchCaseBody() -> RawCodeBlockItemListSyntax {
     parseCodeBlockItemList(until: {
-      if $0.at(.rightBrace) || $0.at(.poundEndif, .poundElseif, .poundElse) {
-        return true
-      }
-      if $0.at(.keyword(.case), .keyword(.default)) {
+      if $0.at(.rightBrace, .keyword(.case), .keyword(.default)) || $0.atEndOfIfConfigClauseBody() {
         return true
       }
-      if $0.at(.atSign)
-        && $0.withLookahead({
+      if $0.at(.atSign),
+        $0.withLookahead({
           $0.consumeAnyAttribute(); return $0.at(.keyword(.case), .keyword(.default))
         })
       {

Sources/SwiftParser/Statements.swift

@@ -1095,18 +1095,8 @@ extension Parser.Lookahead {
     // Check for and consume attributes. The only valid attribute is `@unknown`
     // but that's a semantic restriction.
     var lookahead = self.lookahead()
-    var loopProgress = LoopProgressCondition()
-    var hasAttribute = false
-    while lookahead.at(.atSign) && lookahead.hasProgressed(&loopProgress) {
-      guard lookahead.peek().rawTokenKind == .identifier else {
-        return false
-      }
-
-      lookahead.eat(.atSign)
-      lookahead.eat(.identifier)
-      hasAttribute = true
-    }
-
+    
+    let hasAttribute = lookahead.consumeAttributeList()
     if hasAttribute && lookahead.at(.rightBrace) {
       // If we are at an attribute that's the last token in the SwitchCase, parse
       // that as an attribute to a missing 'case'. That way, if the developer writes

Sources/SwiftParser/TopLevel.swift

@@ -68,11 +68,11 @@ extension Parser {
 extension Parser {
   mutating func parseCodeBlockItemList(
     allowInitDecl: Bool = true,
-    until stopCondition: (inout Parser) -> Bool
+    until stopCondition: (inout Parser) -> Bool = { $0.at(.rightBrace) || $0.atEndOfIfConfigClauseBody() }
   ) -> RawCodeBlockItemListSyntax {
     var elements = [RawCodeBlockItemSyntax]()
     var loopProgress = LoopProgressCondition()
-    while !stopCondition(&self), self.hasProgressed(&loopProgress) {
+    while !stopCondition(&self), !self.at(.endOfFile), self.hasProgressed(&loopProgress) {
       let newItemAtStartOfLine = self.atStartOfLine
       guard let newElement = self.parseCodeBlockItem(allowInitDecl: allowInitDecl, until: stopCondition) else {
         break
@@ -118,7 +118,7 @@ extension Parser {
   /// indented to close this code block or a surrounding context. See `expectRightBrace`.
   mutating func parseCodeBlock(introducer: RawTokenSyntax? = nil, allowInitDecl: Bool = true) -> RawCodeBlockSyntax {
     let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace)
-    let itemList = parseCodeBlockItemList(allowInitDecl: allowInitDecl, until: { $0.at(.rightBrace) })
+    let itemList = parseCodeBlockItemList(allowInitDecl: allowInitDecl)
     let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: introducer)
 
     return .init(
@@ -223,14 +223,10 @@ extension Parser {
       attachSemi = true
 
     } else {
+      // Otherwise, eat the unexpected tokens into an "decl".
       item = .decl(
         RawDeclSyntax(
-          self.parseUnexpectedCodeDeclaration(
-            allowInitDecl: allowInitDecl,
-            requiresDecl: false,
-            skipToDeclOnly: false,
-            until: stopCondition
-          )
+          self.parseUnexpectedCodeDeclaration(allowInitDecl: allowInitDecl, requiresDecl: false, until: stopCondition)
         )
       )
       attachSemi = true

Tests/SwiftParserTest/DirectiveTests.swift

@@ -462,13 +462,104 @@ final class DirectiveTests: ParserTestCase {
   func testOrphanEndifInMember() {
     assertParse(
       """
-      struct S {
-        1️⃣#endif
+      struct S ℹ️{1️⃣
+        2️⃣#endif
       }
       """,
       diagnostics: [
-        DiagnosticSpec(message: "unexpected code '#endif' in struct")
-      ]
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '}' to end struct",
+          notes: [NoteSpec(message: "to match this opening '{'")],
+          fixIts: ["insert '}'"],
+        ),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code in source file"),
+      ],
+      fixedSource: """
+        struct S {
+        }
+          #endif
+        }
+        """
+    )
+  }
+
+  func testOrphanEndifInCodeBlock() {
+    assertParse(
+      """
+      func foo() ℹ️{1️⃣
+        2️⃣#endif
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '}' to end function",
+          notes: [NoteSpec(message: "to match this opening '{'")],
+          fixIts: ["insert '}'"],
+        ),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code in source file"),
+      ],
+      fixedSource: """
+        func foo() {
+        }
+          #endif
+        }
+        """
+    )
+  }
+
+  func testOrphanEndifInSwitch() {
+    assertParse(
+      """
+      switch subject ℹ️{1️⃣
+        2️⃣#endif
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '}' to end 'switch' statement",
+          notes: [NoteSpec(message: "to match this opening '{'")],
+          fixIts: ["insert '}'"],
+        ),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code in source file"),
+      ],
+      fixedSource: """
+        switch subject {
+        }
+          #endif
+        }
+        """
+    )
+  }
+
+  func testOrphanEndifInSwitchCase() {
+    assertParse(
+      """
+      switch subject ℹ️{
+      case foo:
+        print()1️⃣
+        2️⃣#endif
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '}' to end 'switch' statement",
+          notes: [NoteSpec(message: "to match this opening '{'")],
+          fixIts: ["insert '}'"],
+        ),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code in source file"),
+      ],
+      fixedSource: """
+        switch subject {
+        case foo:
+          print()
+        }
+          #endif
+        }
+        """
     )
   }
 
@@ -492,4 +583,32 @@ final class DirectiveTests: ParserTestCase {
       ]
     )
   }
+
+  func testMismatchedPoundIfAndCodeBlock() {
+    assertParse(
+      """
+      #if FOO
+      func foo() ℹ️{1️⃣
+      #endif
+      2️⃣}
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '}' to end function",
+          notes: [NoteSpec(message: "to match this opening '{'")],
+          fixIts: ["insert '}'"],
+        ),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected brace in source file"),
+      ],
+      fixedSource: """
+        #if FOO
+        func foo() {
+        }
+        #endif
+        }
+        """
+    )
+  }
+
 }

Tests/SwiftParserTest/ExpressionTests.swift

@@ -2662,10 +2662,26 @@ final class StatementExpressionTests: ParserTestCase {
     assertParse(
       """
       switch x {
-        1️⃣@case
+        @1️⃣case2️⃣
       }
       """,
-      diagnostics: [DiagnosticSpec(message: "unexpected code '@case' in 'switch' statement")]
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          // FIXME: "expected attribute name after '@'".
+          message: "expected type in attribute", fixIts: ["insert type"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          // FIXME: "expected pattern and ':' in switch case"
+          message: "expected expression and ':' in switch case", fixIts: ["insert expression and ':'"]
+        ),
+      ],
+      fixedSource: """
+        switch x {
+          @<#identifier#> case <#expression#>:
+        }
+        """
     )
   }
 

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -3429,8 +3429,8 @@ final class RecoveryTests: ParserTestCase {
   func testTTT() {
     assertParse(
       """
-      struct S {
-       :
+      switch s {
+      @
       }
       """
     )