[generated] Re-generate code

Author: hamishknight

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -359,6 +359,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/generated/ChildNameForKeyPath.swift

@@ -3073,6 +3073,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,8 @@ public enum Keyword: UInt8, Hashable {
   case swift
   case `switch`
   case target
+  @_spi(ExperimentalLanguageFeatures)
+  case then
   case `throw`
   case `throws`
   case transpose
@@ -307,6 +309,8 @@ public enum Keyword: UInt8, Hashable {
         self = .`Self`
       case "some":
         self = .some
+      case "then":
+        self = .then
       case "true":
         self = .`true`
       case "Type":
@@ -945,6 +949,7 @@ public enum Keyword: UInt8, Hashable {
       "swift", 
       "switch", 
       "target", 
+      "then", 
       "throw", 
       "throws", 
       "transpose", 

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -2005,6 +2005,16 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  @_spi(ExperimentalLanguageFeatures)
+  override open func visit(_ node: ThenStmtSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+  
+  @_spi(ExperimentalLanguageFeatures)
+  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

@@ -512,7 +512,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
@@ -525,7 +525,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   ///    If it is not, the behaviour 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)")
@@ -576,6 +576,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)
@@ -967,6 +968,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

@@ -259,6 +259,8 @@ public enum SyntaxEnum {
   case switchDefaultLabel(SwitchDefaultLabelSyntax)
   case switchExpr(SwitchExprSyntax)
   case ternaryExpr(TernaryExprSyntax)
+  @_spi(ExperimentalLanguageFeatures)
+  case thenStmt(ThenStmtSyntax)
   case throwStmt(ThrowStmtSyntax)
   case tryExpr(TryExprSyntax)
   case tupleExpr(TupleExprSyntax)
@@ -787,6 +789,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

@@ -259,6 +259,8 @@ public enum SyntaxKind: CaseIterable {
   case switchDefaultLabel
   case switchExpr
   case ternaryExpr
+  @_spi(ExperimentalLanguageFeatures)
+  case thenStmt
   case throwStmt
   case tryExpr
   case tupleExpr
@@ -908,6 +910,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

@@ -1788,6 +1788,14 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a ``ThenStmtSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  @_spi(ExperimentalLanguageFeatures)
+  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
@@ -5463,6 +5471,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)
@@ -6441,6 +6463,8 @@ open class SyntaxRewriter {
       return visitImplSwitchExprSyntax
     case .ternaryExpr:
       return visitImplTernaryExprSyntax
+    case .thenStmt:
+      return visitImplThenStmtSyntax
     case .throwStmt:
       return visitImplThrowStmtSyntax
     case .tryExpr:
@@ -7003,6 +7027,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

@@ -3114,6 +3114,14 @@ extension SyntaxTransformVisitor {
     visitAny(Syntax(node))
   }
 
+  /// Visiting ``ThenStmtSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: nil by default.
+  @_spi(ExperimentalLanguageFeatures)
+  public func visit(_ node: ThenStmtSyntax) -> ResultType {
+    visitAny(Syntax(node))
+  }
+  
   /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -3830,6 +3838,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

@@ -2962,6 +2962,20 @@ open class SyntaxVisitor {
   open func visitPost(_ node: TernaryExprSyntax) {
   }
 
+  /// Visiting ``ThenStmtSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  @_spi(ExperimentalLanguageFeatures)
+  open func visit(_ node: ThenStmtSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+  
+  /// The function called after visiting ``ThenStmtSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  @_spi(ExperimentalLanguageFeatures)
+  open func visitPost(_ node: ThenStmtSyntax) {
+  }
+  
   /// Visiting ``ThrowStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -6042,6 +6056,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)
@@ -6889,6 +6914,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

@@ -18869,7 +18869,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
@@ -20361,6 +20361,76 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
+@_spi(ExperimentalLanguageFeatures) @_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

@@ -2452,6 +2452,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))