Don’t eat closing braces while trying to recover to a declaration start keyword

Author: ahoppen

Sources/SwiftParser/Declarations.swift

@@ -190,7 +190,12 @@ extension Parser {
     let attrs = DeclAttributes(
       attributes: self.parseAttributeList(),
       modifiers: self.parseModifierList())
-    switch self.canRecoverTo(anyIn: DeclarationStart.self) {
+
+    // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context)
+    // while recoverying to the declaration start.
+    let recoveryPrecedence = inMemberDeclList ? TokenPrecedence.closingBrace : nil
+    
+    switch self.canRecoverTo(anyIn: DeclarationStart.self, recoveryPrecedence: recoveryPrecedence) {
     case (.importKeyword, let handle)?:
       return RawDeclSyntax(self.parseImportDeclaration(attrs, handle))
     case (.classKeyword, let handle)?:

Sources/SwiftParser/Parser.swift

@@ -263,13 +263,14 @@ extension Parser {
   /// If so, return the token that we can recover to and a handle that can be
   /// used to consume the unexpected tokens and the token we recovered to.
   func canRecoverTo<Subset: RawTokenKindSubset>(
-    anyIn subset: Subset.Type
+    anyIn subset: Subset.Type,
+    recoveryPrecedence: TokenPrecedence? = nil
   ) -> (Subset, RecoveryConsumptionHandle)? {
     if let (kind, handle) = self.at(anyIn: subset) {
       return (kind, RecoveryConsumptionHandle(unexpectedTokens: 0, tokenConsumptionHandle: handle))
     }
     var lookahead = self.lookahead()
-    return lookahead.canRecoverTo(anyIn: subset)
+    return lookahead.canRecoverTo(anyIn: subset, recoveryPrecedence: recoveryPrecedence)
   }
 
   /// Eat a token that we know we are currently positioned at, based on `canRecoverTo(anyIn:)`.

Tests/SwiftParserTest/DeclarationTests.swift

@@ -1215,6 +1215,86 @@ final class DeclarationTests: XCTestCase {
     // `actor` cannot recover from a missing identifier since it's contextual
     // based on the presence of the identifier.
   }
+
+  func testDontNestClassesIfTheyContainUnexpectedTokens() {
+    // There used to be a bug where `class B` was parsed as a nested class of A
+    // because recovery to the `class` keyword of B consumed the closing brace.
+    AssertParse(
+      """
+      class A {
+        1️⃣^2️⃣
+      }
+      class B {
+      }
+      """,
+      substructure: Syntax(CodeBlockItemListSyntax([
+          CodeBlockItemSyntax(
+            item: .init(ClassDeclSyntax(
+              attributes: nil,
+              modifiers: nil,
+              classKeyword: .classKeyword(),
+              identifier: .identifier("A"),
+              genericParameterClause: nil,
+              inheritanceClause: nil,
+              genericWhereClause: nil,
+              members: MemberDeclBlockSyntax(
+                leftBrace: .leftBraceToken(),
+                members: MemberDeclListSyntax([
+                  MemberDeclListItemSyntax(
+                    decl: Decl(FunctionDeclSyntax(
+                      attributes: nil,
+                      modifiers: nil,
+                      funcKeyword: .funcKeyword(presence: .missing),
+                      identifier: .spacedBinaryOperator("^"),
+                      genericParameterClause: nil,
+                      signature: FunctionSignatureSyntax(
+                        input: ParameterClauseSyntax(
+                          leftParen: .leftParenToken(presence: .missing),
+                          parameterList: FunctionParameterListSyntax([]),
+                          rightParen: .rightParenToken(presence: .missing)
+                        ),
+                        asyncOrReasyncKeyword: nil,
+                        throwsOrRethrowsKeyword: nil,
+                        output: nil
+                      ),
+                      genericWhereClause: nil,
+                      body: nil
+                    )),
+                    semicolon: nil
+                  )
+                ]),
+                rightBrace: .rightBraceToken()
+              )
+            )),
+            semicolon: nil,
+            errorTokens: nil
+          ),
+          CodeBlockItemSyntax(
+            item: .init(ClassDeclSyntax(
+              attributes: nil,
+              modifiers: nil,
+              classKeyword: .classKeyword(),
+              identifier: .identifier("B"),
+              genericParameterClause: nil,
+              inheritanceClause: nil,
+              genericWhereClause: nil,
+              members: MemberDeclBlockSyntax(
+                leftBrace: .leftBraceToken(),
+                members: MemberDeclListSyntax([]),
+                rightBrace: .rightBraceToken()
+              )
+            )),
+            semicolon: nil,
+            errorTokens: nil
+          )
+        ])
+      ),
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "1️⃣", message: "expected 'func' in function"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "expected parameter clause in function signature"),
+      ]
+    )
+  }
 }
 
 extension Parser.DeclAttributes {