[generated] Re-generate code

Author: hamishknight

Sources/SwiftParser/Statements.swift

@@ -849,13 +849,7 @@ extension Parser.Lookahead {
   ///
   /// - Note: This function must be kept in sync with `parseStatement()`.
   /// - Seealso: ``Parser/parseStatement()``
-<<<<<<< HEAD
-  mutating func atStartOfStatement(allowRecovery: Bool = false) -> Bool {
-||||||| parent of a2c4f722 (Introduce `then` statements)
-  mutating func isStartOfStatement(allowRecovery: Bool = false) -> Bool {
-=======
-  mutating func isStartOfStatement(allowRecovery: Bool = false, preferExpr: Bool = false) -> Bool {
->>>>>>> a2c4f722 (Introduce `then` statements)
+  mutating func atStartOfStatement(allowRecovery: Bool = false, preferExpr: Bool = false) -> 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

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -357,6 +357,8 @@ extension SyntaxKind {
       return "'switch' statement"
     case .ternaryExpr:
       return "ternay expression"
+    case .thenStmt:
+      return "'then' statement"
     case .throwStmt:
       return "'throw' statement"
     case .tryExpr:

Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md

@@ -174,6 +174,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax
 - <doc:SwiftSyntax/LabeledStmtSyntax>
 - <doc:SwiftSyntax/RepeatStmtSyntax>
 - <doc:SwiftSyntax/ReturnStmtSyntax>
+- <doc:SwiftSyntax/ThenStmtSyntax>
 - <doc:SwiftSyntax/ThrowStmtSyntax>
 - <doc:SwiftSyntax/WhileStmtSyntax>
 - <doc:SwiftSyntax/YieldStmtSyntax>

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -3059,6 +3059,16 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "elseExpression"
   case \TernaryExprSyntax.unexpectedAfterElseExpression:
     return "unexpectedAfterElseExpression"
+  case \ThenStmtSyntax.unexpectedBeforeThenKeyword:
+    return "unexpectedBeforeThenKeyword"
+  case \ThenStmtSyntax.thenKeyword:
+    return "thenKeyword"
+  case \ThenStmtSyntax.unexpectedBetweenThenKeywordAndExpression:
+    return "unexpectedBetweenThenKeywordAndExpression"
+  case \ThenStmtSyntax.expression:
+    return "expression"
+  case \ThenStmtSyntax.unexpectedAfterExpression:
+    return "unexpectedAfterExpression"
   case \ThrowStmtSyntax.unexpectedBeforeThrowKeyword:
     return "unexpectedBeforeThrowKeyword"
   case \ThrowStmtSyntax.throwKeyword:

Sources/SwiftSyntax/generated/Keyword.swift

@@ -196,6 +196,7 @@ public enum Keyword: UInt8, Hashable {
   case swift
   case `switch`
   case target
+  case then
   case `throw`
   case `throws`
   case transpose
@@ -307,6 +308,8 @@ public enum Keyword: UInt8, Hashable {
         self = .`Self`
       case "some":
         self = .some
+      case "then":
+        self = .then
       case "true":
         self = .`true`
       case "Type":
@@ -945,6 +948,7 @@ public enum Keyword: UInt8, Hashable {
       "swift", 
       "switch", 
       "target", 
+      "then", 
       "throw", 
       "throws", 
       "transpose", 

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -1989,6 +1989,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: ThenStmtSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+  
+  override open func visitPost(_ node: ThenStmtSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  
   override open func visit(_ node: ThrowStmtSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -486,7 +486,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
 
   public init?(_ node: some SyntaxProtocol) {
     switch node.raw.kind {
-    case .breakStmt, .continueStmt, .deferStmt, .discardStmt, .doStmt, .expressionStmt, .fallThroughStmt, .forStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
+    case .breakStmt, .continueStmt, .deferStmt, .discardStmt, .doStmt, .expressionStmt, .fallThroughStmt, .forStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatStmt, .returnStmt, .thenStmt, .throwStmt, .whileStmt, .yieldStmt:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -498,7 +498,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   /// is undefined.
   internal init(_ data: SyntaxData) {
     switch data.raw.kind {
-    case .breakStmt, .continueStmt, .deferStmt, .discardStmt, .doStmt, .expressionStmt, .fallThroughStmt, .forStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
+    case .breakStmt, .continueStmt, .deferStmt, .discardStmt, .doStmt, .expressionStmt, .fallThroughStmt, .forStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatStmt, .returnStmt, .thenStmt, .throwStmt, .whileStmt, .yieldStmt:
       break
     default:
       preconditionFailure("Unable to create StmtSyntax from \(data.raw.kind)")
@@ -547,6 +547,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
           .node(MissingStmtSyntax.self),
           .node(RepeatStmtSyntax.self),
           .node(ReturnStmtSyntax.self),
+          .node(ThenStmtSyntax.self),
           .node(ThrowStmtSyntax.self),
           .node(WhileStmtSyntax.self),
           .node(YieldStmtSyntax.self)
@@ -929,6 +930,7 @@ extension Syntax {
           .node(SwitchDefaultLabelSyntax.self),
           .node(SwitchExprSyntax.self),
           .node(TernaryExprSyntax.self),
+          .node(ThenStmtSyntax.self),
           .node(ThrowStmtSyntax.self),
           .node(TryExprSyntax.self),
           .node(TupleExprSyntax.self),

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -257,6 +257,7 @@ public enum SyntaxEnum {
   case switchDefaultLabel(SwitchDefaultLabelSyntax)
   case switchExpr(SwitchExprSyntax)
   case ternaryExpr(TernaryExprSyntax)
+  case thenStmt(ThenStmtSyntax)
   case throwStmt(ThrowStmtSyntax)
   case tryExpr(TryExprSyntax)
   case tupleExpr(TupleExprSyntax)
@@ -781,6 +782,8 @@ public extension Syntax {
       return .switchExpr(SwitchExprSyntax(self)!)
     case .ternaryExpr:
       return .ternaryExpr(TernaryExprSyntax(self)!)
+    case .thenStmt:
+      return .thenStmt(ThenStmtSyntax(self)!)
     case .throwStmt:
       return .throwStmt(ThrowStmtSyntax(self)!)
     case .tryExpr:

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -257,6 +257,7 @@ public enum SyntaxKind: CaseIterable {
   case switchDefaultLabel
   case switchExpr
   case ternaryExpr
+  case thenStmt
   case throwStmt
   case tryExpr
   case tupleExpr
@@ -900,6 +901,8 @@ public enum SyntaxKind: CaseIterable {
       return SwitchExprSyntax.self
     case .ternaryExpr:
       return TernaryExprSyntax.self
+    case .thenStmt:
+      return ThenStmtSyntax.self
     case .throwStmt:
       return ThrowStmtSyntax.self
     case .tryExpr:

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -1774,6 +1774,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a ``ThenStmtSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: ThenStmtSyntax) -> StmtSyntax {
+    return StmtSyntax(visitChildren(node))
+  }
+  
   /// Visit a ``ThrowStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -5421,6 +5428,20 @@ open class SyntaxRewriter {
     return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplThenStmtSyntax(_ data: SyntaxData) -> Syntax {
+    let node = ThenStmtSyntax(data)
+    // Accessing _syntaxNode directly is faster than calling Syntax(node)
+    visitPre(node._syntaxNode)
+    defer {
+      visitPost(node._syntaxNode)
+    }
+    if let newNode = visitAny(node._syntaxNode) {
+      return newNode
+    }
+    return Syntax(visit(node))
+  }
+  
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplThrowStmtSyntax(_ data: SyntaxData) -> Syntax {
     let node = ThrowStmtSyntax(data)
@@ -6395,6 +6416,8 @@ open class SyntaxRewriter {
       return visitImplSwitchExprSyntax
     case .ternaryExpr:
       return visitImplTernaryExprSyntax
+    case .thenStmt:
+      return visitImplThenStmtSyntax
     case .throwStmt:
       return visitImplThrowStmtSyntax
     case .tryExpr:
@@ -6953,6 +6976,8 @@ open class SyntaxRewriter {
       return visitImplSwitchExprSyntax(data)
     case .ternaryExpr:
       return visitImplTernaryExprSyntax(data)
+    case .thenStmt:
+      return visitImplThenStmtSyntax(data)
     case .throwStmt:
       return visitImplThrowStmtSyntax(data)
     case .tryExpr:

Sources/SwiftSyntax/generated/SyntaxTransform.swift

@@ -1229,6 +1229,11 @@ public protocol SyntaxTransformVisitor {
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: TernaryExprSyntax) -> ResultType
 
+  /// Visiting ``ThenStmtSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: the sum of whatever the child visitors return.
+  func visit(_ node: ThenStmtSyntax) -> ResultType
+  
   /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
@@ -3089,6 +3094,13 @@ extension SyntaxTransformVisitor {
     visitAny(Syntax(node))
   }
 
+  /// Visiting ``ThenStmtSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: nil by default.
+  public func visit(_ node: ThenStmtSyntax) -> ResultType {
+    visitAny(Syntax(node))
+  }
+  
   /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -3801,6 +3813,8 @@ extension SyntaxTransformVisitor {
       return visit(derived)
     case .ternaryExpr(let derived):
       return visit(derived)
+    case .thenStmt(let derived):
+      return visit(derived)
     case .throwStmt(let derived):
       return visit(derived)
     case .tryExpr(let derived):

Sources/SwiftSyntax/generated/SyntaxVisitor.swift

@@ -2938,6 +2938,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: TernaryExprSyntax) {
   }
 
+  /// Visiting ``ThenStmtSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: ThenStmtSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+  
+  /// The function called after visiting ``ThenStmtSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: ThenStmtSyntax) {
+  }
+  
   /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -5996,6 +6008,17 @@ open class SyntaxVisitor {
     visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplThenStmtSyntax(_ data: SyntaxData) {
+    let node = ThenStmtSyntax(data)
+    let needsChildren = (visit(node) == .visitChildren)
+    // Avoid calling into visitChildren if possible.
+    if needsChildren && !node.raw.layoutView!.children.isEmpty {
+      visitChildren(node)
+    }
+    visitPost(node)
+  }
+  
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplThrowStmtSyntax(_ data: SyntaxData) {
     let node = ThrowStmtSyntax(data)
@@ -6839,6 +6862,8 @@ open class SyntaxVisitor {
       visitImplSwitchExprSyntax(data)
     case .ternaryExpr:
       visitImplTernaryExprSyntax(data)
+    case .thenStmt:
+      visitImplThenStmtSyntax(data)
     case .throwStmt:
       visitImplThrowStmtSyntax(data)
     case .tryExpr:

Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift

@@ -18737,7 +18737,7 @@ public struct RawStmtSyntax: RawStmtSyntaxNodeProtocol {
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
     switch raw.kind {
-    case .breakStmt, .continueStmt, .deferStmt, .discardStmt, .doStmt, .expressionStmt, .fallThroughStmt, .forStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
+    case .breakStmt, .continueStmt, .deferStmt, .discardStmt, .doStmt, .expressionStmt, .fallThroughStmt, .forStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatStmt, .returnStmt, .thenStmt, .throwStmt, .whileStmt, .yieldStmt:
       return true
     default:
       return false
@@ -20229,6 +20229,76 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
+@_spi(RawSyntax)
+public struct RawThenStmtSyntax: RawStmtSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+  
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .thenStmt
+  }
+  
+  public var raw: RawSyntax
+  
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+  
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+  
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+  
+  public init(
+      _ unexpectedBeforeThenKeyword: RawUnexpectedNodesSyntax? = nil, 
+      thenKeyword: RawTokenSyntax, 
+      _ unexpectedBetweenThenKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, 
+      expression: RawExprSyntax, 
+      _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil, 
+      arena: __shared SyntaxArena
+    ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .thenStmt, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeThenKeyword?.raw
+      layout[1] = thenKeyword.raw
+      layout[2] = unexpectedBetweenThenKeywordAndExpression?.raw
+      layout[3] = expression.raw
+      layout[4] = unexpectedAfterExpression?.raw
+    }
+    self.init(unchecked: raw)
+  }
+  
+  public var unexpectedBeforeThenKeyword: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var thenKeyword: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  
+  public var unexpectedBetweenThenKeywordAndExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var expression: RawExprSyntax {
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
+  }
+  
+  public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol {
   @_spi(RawSyntax)

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -2439,6 +2439,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 9, verify(layout[9], as: RawExprSyntax.self))
     assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self))
+  case .thenStmt:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("then")]))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .throwStmt:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))