Parse SwitchExprSyntax

Update the parser to support parsing SwitchExprSyntax.
For now, this only updates the existing statement
parsing, and does not attempt to parse in
expression position.

Author: hamishknight

Sources/SwiftParser/Expressions.swift

@@ -2621,6 +2621,288 @@ extension Parser {
   }
 }
 
+// MARK: Switch Expressions
+
+extension Parser {
+  /// Parse a switch expression.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     switch-expression → 'switch' expression '{' switch-cases? '}'
+  ///     switch-cases → switch-case switch-cases?
+  @_spi(RawSyntax)
+  public mutating func parseSwitchExpression(
+    switchHandle: RecoveryConsumptionHandle
+  ) -> RawSwitchExprSyntax {
+    let (unexpectedBeforeSwitchKeyword, switchKeyword) = self.eat(switchHandle)
+
+    let subject = self.parseExpression(.basic)
+    let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace)
+
+    let cases = self.parseSwitchCases(allowStandaloneStmtRecovery: !lbrace.isMissing)
+
+    let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: switchKeyword)
+    return RawSwitchExprSyntax(
+      unexpectedBeforeSwitchKeyword,
+      switchKeyword: switchKeyword,
+      expression: subject,
+      unexpectedBeforeLBrace,
+      leftBrace: lbrace,
+      cases: cases,
+      unexpectedBeforeRBrace,
+      rightBrace: rbrace,
+      arena: self.arena
+    )
+  }
+
+  /// Parse a list of switch case clauses.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     switch-cases → switch-case switch-cases?
+  ///
+  /// If `allowStandaloneStmtRecovery` is `true` and we discover a statement that
+  /// isn't covered by a case, we assume that the developer forgot to wrote the
+  /// `case` and synthesize it. If `allowStandaloneStmtOrDeclRecovery` is `false`,
+  /// this recovery is disabled.
+  @_spi(RawSyntax)
+  public mutating func parseSwitchCases(allowStandaloneStmtRecovery: Bool) -> RawSwitchCaseListSyntax {
+    var elements = [RawSwitchCaseListSyntax.Element]()
+    var elementsProgress = LoopProgressCondition()
+    while !self.at(any: [.eof, .rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword])
+      && elementsProgress.evaluate(currentToken)
+    {
+      if self.lookahead().isAtStartOfSwitchCase(allowRecovery: false) {
+        elements.append(.switchCase(self.parseSwitchCase()))
+      } else if self.canRecoverTo(.poundIfKeyword) != nil {
+        // '#if' in 'case' position can enclose zero or more 'case' or 'default'
+        // clauses.
+        elements.append(
+          .ifConfigDecl(
+            self.parsePoundIfDirective(
+              { $0.parseSwitchCases(allowStandaloneStmtRecovery: allowStandaloneStmtRecovery) },
+              syntax: { parser, cases in
+                guard cases.count == 1, let firstCase = cases.first else {
+                  assert(cases.isEmpty)
+                  return .switchCases(RawSwitchCaseListSyntax(elements: [], arena: parser.arena))
+                }
+                return .switchCases(firstCase)
+              }
+            )
+          )
+        )
+      } else if allowStandaloneStmtRecovery && (self.atStartOfExpression() || self.atStartOfStatement() || self.atStartOfDeclaration()) {
+        // Synthesize a label for the stamenent or declaration that isn't coverd by a case right now.
+        let statements = parseSwitchCaseBody()
+        elements.append(
+          .switchCase(
+            RawSwitchCaseSyntax(
+              unknownAttr: nil,
+              label: .case(
+                RawSwitchCaseLabelSyntax(
+                  caseKeyword: missingToken(.keyword(.case), text: nil),
+                  caseItems: RawCaseItemListSyntax(
+                    elements: [
+                      RawCaseItemSyntax(
+                        pattern: RawPatternSyntax(
+                          RawIdentifierPatternSyntax(
+                            identifier: missingToken(.identifier, text: nil),
+                            arena: self.arena
+                          )
+                        ),
+                        whereClause: nil,
+                        trailingComma: nil,
+                        arena: self.arena
+                      )
+                    ],
+                    arena: self.arena
+                  ),
+                  colon: missingToken(.colon, text: nil),
+                  arena: self.arena
+                )
+              ),
+              statements: statements,
+              arena: self.arena
+            )
+          )
+        )
+      } else if self.lookahead().isAtStartOfSwitchCase(allowRecovery: true) {
+        elements.append(.switchCase(self.parseSwitchCase()))
+      } else {
+        break
+      }
+    }
+    return RawSwitchCaseListSyntax(elements: elements, arena: self.arena)
+  }
+
+  mutating func parseSwitchCaseBody() -> RawCodeBlockItemListSyntax {
+    var items = [RawCodeBlockItemSyntax]()
+    var loopProgress = LoopProgressCondition()
+    while !self.at(any: [.rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword])
+      && !self.lookahead().isStartOfConditionalSwitchCases(),
+      let newItem = self.parseCodeBlockItem(),
+      loopProgress.evaluate(currentToken)
+    {
+      items.append(newItem)
+    }
+    return RawCodeBlockItemListSyntax(elements: items, arena: self.arena)
+  }
+
+  /// Parse a single switch case clause.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     switch-case → case-label statements
+  ///     switch-case → default-label statements
+  ///     switch-case → conditional-switch-case
+  @_spi(RawSyntax)
+  public mutating func parseSwitchCase() -> RawSwitchCaseSyntax {
+    var unknownAttr: RawAttributeSyntax?
+    if let at = self.consume(if: .atSign) {
+      let (unexpectedBeforeIdent, ident) = self.expectIdentifier()
+
+      unknownAttr = RawAttributeSyntax(
+        atSignToken: at,
+        unexpectedBeforeIdent,
+        attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: ident, genericArgumentClause: nil, arena: self.arena)),
+        leftParen: nil,
+        argument: nil,
+        rightParen: nil,
+        arena: self.arena
+      )
+    } else {
+      unknownAttr = nil
+    }
+
+    let label: RawSwitchCaseSyntax.Label
+    switch self.canRecoverTo(anyIn: SwitchCaseStart.self) {
+    case (.caseKeyword, let handle)?:
+      label = .case(self.parseSwitchCaseLabel(handle))
+    case (.defaultKeyword, let handle)?:
+      label = .default(self.parseSwitchDefaultLabel(handle))
+    case nil:
+      label = .case(
+        RawSwitchCaseLabelSyntax(
+          caseKeyword: missingToken(.keyword(.case)),
+          caseItems: RawCaseItemListSyntax(
+            elements: [
+              RawCaseItemSyntax(
+                pattern: RawPatternSyntax(RawIdentifierPatternSyntax(identifier: missingToken(.identifier), arena: self.arena)),
+                whereClause: nil,
+                trailingComma: nil,
+                arena: self.arena
+              )
+            ],
+            arena: self.arena
+          ),
+          colon: missingToken(.colon),
+          arena: self.arena
+        )
+      )
+    }
+
+    // Parse the body.
+    let statements = parseSwitchCaseBody()
+
+    return RawSwitchCaseSyntax(
+      unknownAttr: unknownAttr,
+      label: label,
+      statements: statements,
+      arena: self.arena
+    )
+  }
+
+  /// Parse a switch case with a 'case' label.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     case-label → attributes? case case-item-list ':'
+  ///     case-item-list → pattern where-clause? | pattern where-clause? ',' case-item-list
+  @_spi(RawSyntax)
+  public mutating func parseSwitchCaseLabel(
+    _ handle: RecoveryConsumptionHandle
+  ) -> RawSwitchCaseLabelSyntax {
+    let (unexpectedBeforeCaseKeyword, caseKeyword) = self.eat(handle)
+    var caseItems = [RawCaseItemSyntax]()
+    do {
+      var keepGoing: RawTokenSyntax? = nil
+      var loopProgress = LoopProgressCondition()
+      repeat {
+        let (pattern, whereClause) = self.parseGuardedCasePattern()
+        keepGoing = self.consume(if: .comma)
+        caseItems.append(
+          RawCaseItemSyntax(
+            pattern: pattern,
+            whereClause: whereClause,
+            trailingComma: keepGoing,
+            arena: self.arena
+          )
+        )
+      } while keepGoing != nil && loopProgress.evaluate(currentToken)
+    }
+    let (unexpectedBeforeColon, colon) = self.expect(.colon)
+    return RawSwitchCaseLabelSyntax(
+      unexpectedBeforeCaseKeyword,
+      caseKeyword: caseKeyword,
+      caseItems: RawCaseItemListSyntax(elements: caseItems, arena: self.arena),
+      unexpectedBeforeColon,
+      colon: colon,
+      arena: self.arena
+    )
+  }
+
+  /// Parse a switch case with a 'default' label.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     default-label → attributes? 'default' ':'
+  @_spi(RawSyntax)
+  public mutating func parseSwitchDefaultLabel(
+    _ handle: RecoveryConsumptionHandle
+  ) -> RawSwitchDefaultLabelSyntax {
+    let (unexpectedBeforeDefaultKeyword, defaultKeyword) = self.eat(handle)
+    let (unexpectedBeforeColon, colon) = self.expect(.colon)
+    return RawSwitchDefaultLabelSyntax(
+      unexpectedBeforeDefaultKeyword,
+      defaultKeyword: defaultKeyword,
+      unexpectedBeforeColon,
+      colon: colon,
+      arena: self.arena
+    )
+  }
+
+  /// Parse a pattern-matching clause for a case statement,
+  /// including the guard expression.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     case-item     → pattern where-clause?
+  mutating func parseGuardedCasePattern() -> (RawPatternSyntax, RawWhereClauseSyntax?) {
+    let pattern = self.parseMatchingPattern(context: .matching)
+
+    // Parse the optional 'where' guard, with this particular pattern's bound
+    // vars in scope.
+    let whereClause: RawWhereClauseSyntax?
+    if let whereKeyword = self.consume(if: .keyword(.where)) {
+      let guardExpr = self.parseExpression(.trailingClosure)
+      whereClause = RawWhereClauseSyntax(
+        whereKeyword: whereKeyword,
+        guardResult: guardExpr,
+        arena: self.arena
+      )
+    } else {
+      whereClause = nil
+    }
+    return (pattern, whereClause)
+  }
+}
+
 // MARK: Lookahead
 
 extension Parser.Lookahead {