tbs

Author: rintaro

Sources/SwiftParser/Statements.swift

@@ -34,16 +34,6 @@ extension TokenConsumer {
   }
 }
 
-extension Parser.Lookahead {
-  mutating func atStartOfSwitchCaseItem() -> Bool {
-    while self.consume(if: .atSign) != nil {
-      self.consume(if: .identifier)
-    }
-
-    return self.at(anyIn: SwitchCaseStart.self) != nil
-  }
-}
-
 extension Parser {
   /// Parse a statement.
   ///
@@ -700,6 +690,9 @@ extension Parser {
     if self.atStartOfStatement(preferExpr: true) || self.atStartOfDeclaration() {
       return false
     }
+    if self.atStartOfLine && self.withLookahead({ $0.atStartOfSwitchCase() }) {
+      return false
+    }
     return true
   }
 
@@ -1037,12 +1030,10 @@ extension Parser.Lookahead {
   /// - Note: This function must be kept in sync with `parseStatement()`.
   /// - Seealso: ``Parser/parseStatement()``
   mutating func atStartOfStatement(preferExpr: Bool) -> Bool {
-    if (self.at(anyIn: SwitchCaseStart.self) != nil || self.at(.atSign))
-      && withLookahead({ $0.atStartOfSwitchCaseItem() })
-    {
-      // We consider SwitchCaseItems statements so we don't parse the start of a new case item as trailing parts of an expression.
-      return true
-    }
+//    if self.atStartOfSwitchCase() {
+//      // We consider 'case' statements so we don't parse the start of a new case item as trailing parts of an expression.
+//      return true
+//    }
 
     _ = self.consume(if: .identifier, followedBy: .colon)
     switch self.at(anyIn: CanBeStatementStart.self)?.0 {
@@ -1095,7 +1086,7 @@ extension Parser.Lookahead {
     // Check for and consume attributes. The only valid attribute is `@unknown`
     // but that's a semantic restriction.
     var lookahead = self.lookahead()
-    
+
     let hasAttribute = lookahead.consumeAttributeList()
     if hasAttribute && lookahead.at(.rightBrace) {
       // If we are at an attribute that's the last token in the SwitchCase, parse

Sources/SwiftParser/TopLevel.swift

@@ -74,11 +74,13 @@ extension Parser {
     var loopProgress = LoopProgressCondition()
     while !stopCondition(&self), !self.at(.endOfFile), self.hasProgressed(&loopProgress) {
       let newItemAtStartOfLine = self.atStartOfLine
-      guard let newElement = self.parseCodeBlockItem(allowInitDecl: allowInitDecl, until: stopCondition) else {
+      guard let newItem = self.parseCodeBlockItem(allowInitDecl: allowInitDecl, until: stopCondition) else {
         break
       }
       if let lastItem = elements.last,
-        lastItem.semicolon == nil && !newItemAtStartOfLine && !newElement.item.is(RawUnexpectedCodeDeclSyntax.self)
+        lastItem.semicolon == nil,
+        !newItemAtStartOfLine,
+        !newItem.item.is(RawUnexpectedCodeDeclSyntax.self)
       {
         elements[elements.count - 1] = RawCodeBlockItemSyntax(
           lastItem.unexpectedBeforeItem,
@@ -89,7 +91,7 @@ extension Parser {
           arena: self.arena
         )
       }
-      elements.append(newElement)
+      elements.append(newItem)
     }
     return .init(elements: elements, arena: self.arena)
   }
@@ -178,18 +180,6 @@ extension Parser {
       )
     }
 
-    if self.at(.keyword(.case), .keyword(.default)) {
-      // 'case' and 'default' are invalid in code block items.
-      // Parse them and put them in their own CodeBlockItem but as an unexpected node.
-      let switchCase = self.parseSwitchCase()
-      return RawCodeBlockItemSyntax(
-        RawUnexpectedNodesSyntax([switchCase], arena: self.arena),
-        item: .init(expr: RawMissingExprSyntax(arena: self.arena)),
-        semicolon: nil,
-        arena: self.arena
-      )
-    }
-
     let item: RawCodeBlockItemSyntax.Item
     let attachSemi: Bool
     if self.at(.poundIf) && !self.withLookahead({ $0.consumeIfConfigOfAttributes() }) {
@@ -221,7 +211,16 @@ extension Parser {
       // expression or statement starting with an attribute.
       item = .decl(self.parseDeclaration())
       attachSemi = true
-
+    } else if self.withLookahead({ $0.atStartOfSwitchCase() }) {
+      // 'case' and 'default' are invalid in code block items.
+      // Parse them and put them in their own CodeBlockItem but as an unexpected node.
+      let switchCase = self.parseSwitchCase()
+      return RawCodeBlockItemSyntax(
+        RawUnexpectedNodesSyntax([switchCase], arena: self.arena),
+        item: .init(expr: RawMissingExprSyntax(arena: self.arena)),
+        semicolon: nil,
+        arena: self.arena
+      )
     } else {
       // Otherwise, eat the unexpected tokens into an "decl".
       item = .decl(

Tests/SwiftParserTest/ExpressionTests.swift

@@ -2669,12 +2669,14 @@ final class StatementExpressionTests: ParserTestCase {
         DiagnosticSpec(
           locationMarker: "1️⃣",
           // FIXME: "expected attribute name after '@'".
-          message: "expected type in attribute", fixIts: ["insert type"]
+          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 ':'"]
+          message: "expected expression and ':' in switch case",
+          fixIts: ["insert expression and ':'"]
         ),
       ],
       fixedSource: """

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -3425,14 +3425,4 @@ final class RecoveryTests: ParserTestCase {
         """
     )
   }
-
-  func testTTT() {
-    assertParse(
-      """
-      switch s {
-      @
-      }
-      """
-    )
-  }
 }