[generated] Re-generate code

hamishknight · hamishknight · commit 33ed2d6fa3bf · 2023-09-01T14:32:52.000+01:00
diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/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:
diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md
@@ -175,6 +175,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>
diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
@@ -3063,6 +3063,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:
diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift
@@ -201,6 +201,7 @@ public enum Keyword: UInt8, Hashable {
   case swift
   case `switch`
   case target
+  case then
   case `throw`
   case `throws`
   case transpose
@@ -312,6 +313,8 @@ public enum Keyword: UInt8, Hashable {
         self = .Self
       case "some":
         self = .some
+      case "then":
+        self = .then
       case "true":
         self = .true
       case "Type":
@@ -956,6 +959,7 @@ public enum Keyword: UInt8, Hashable {
       "swift", 
       "switch", 
       "target", 
+      "then", 
       "throw", 
       "throws", 
       "transpose", 
diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
@@ -2000,6 +2000,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)
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/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)
@@ -966,6 +967,7 @@ extension Syntax {
           .node(SwitchDefaultLabelSyntax.self),
           .node(SwitchExprSyntax.self),
           .node(TernaryExprSyntax.self),
+          .node(ThenStmtSyntax.self),
           .node(ThrowStmtSyntax.self),
           .node(TryExprSyntax.self),
           .node(TupleExprSyntax.self),
diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
@@ -258,6 +258,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)
@@ -784,6 +785,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:
diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift
@@ -258,6 +258,7 @@ public enum SyntaxKind: CaseIterable {
   case switchDefaultLabel
   case switchExpr
   case ternaryExpr
+  case thenStmt
   case throwStmt
   case tryExpr
   case tupleExpr
@@ -905,6 +906,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:
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -1781,6 +1781,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
@@ -3061,6 +3068,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl($0, TernaryExprSyntax.self, self.visit)
       }
+    case .thenStmt:
+      return {
+        self.visitImpl($0, ThenStmtSyntax.self, self.visit)
+      }
     case .throwStmt:
       return {
         self.visitImpl($0, ThrowStmtSyntax.self, self.visit)
@@ -3685,6 +3696,8 @@ open class SyntaxRewriter {
       return visitImpl(data, SwitchExprSyntax.self, visit)
     case .ternaryExpr:
       return visitImpl(data, TernaryExprSyntax.self, visit)
+    case .thenStmt:
+      return visitImpl(data, ThenStmtSyntax.self, visit)
     case .throwStmt:
       return visitImpl(data, ThrowStmtSyntax.self, visit)
     case .tryExpr:
diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift
@@ -1235,6 +1235,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.
@@ -3102,6 +3107,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.
@@ -3816,6 +3828,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):
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -2950,6 +2950,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.
@@ -4368,6 +4380,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl($0, TernaryExprSyntax.self, self.visit, self.visitPost)
       }
+    case .thenStmt:
+      return {
+        self.visitImpl($0, ThenStmtSyntax.self, self.visit, self.visitPost)
+      }
     case .throwStmt:
       return {
         self.visitImpl($0, ThrowStmtSyntax.self, self.visit, self.visitPost)
@@ -4995,6 +5011,8 @@ open class SyntaxVisitor {
       visitImpl(data, SwitchExprSyntax.self, visit, visitPost)
     case .ternaryExpr:
       visitImpl(data, TernaryExprSyntax.self, visit, visitPost)
+    case .thenStmt:
+      visitImpl(data, ThenStmtSyntax.self, visit, visitPost)
     case .throwStmt:
       visitImpl(data, ThrowStmtSyntax.self, visit, visitPost)
     case .tryExpr:
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift
@@ -1056,7 +1056,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
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift
@@ -107,6 +107,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)
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
@@ -2451,6 +2451,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))
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift

Original file line number	Diff line number	Diff line change
`@@ -2000,6 +2000,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {`
`2000`	`2000`	`visitAnyPost(node._syntaxNode)`
`2001`	`2001`	`}`
`2002`	`2002`
	`2003`	`+ override open func visit(_ node: ThenStmtSyntax) -> SyntaxVisitorContinueKind {`
	`2004`	`+ return visitAny(node._syntaxNode)`
	`2005`	`+ }`
	`2006`	`+`
	`2007`	`+ override open func visitPost(_ node: ThenStmtSyntax) {`
	`2008`	`+ visitAnyPost(node._syntaxNode)`
	`2009`	`+ }`
	`2010`	`+`
`2003`	`2011`	`override open func visit(_ node: ThrowStmtSyntax) -> SyntaxVisitorContinueKind {`
`2004`	`2012`	`return visitAny(node._syntaxNode)`
`2005`	`2013`	`}`