[generated] Re-generate generated code

hamishknight · hamishknight · commit 3971f555acea · 2023-10-09T20:13:57.000+01:00
diff --git a/Sources/SwiftParser/generated/ExperimentalFeatures.swift b/Sources/SwiftParser/generated/ExperimentalFeatures.swift
@@ -32,4 +32,7 @@ extension Parser.ExperimentalFeatures {
   
   /// Whether to enable the parsing of typed throws.
   public static let typedThrows = Self(rawValue: 1 << 2)
+  
+  /// Whether to enable the parsing of 'do' expressions.
+  public static let doExpressions = Self(rawValue: 1 << 3)
 }
diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift
@@ -92,6 +92,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "value type"
   case \DifferentiabilityWithRespectToArgumentSyntax.arguments:
     return "arguments"
+  case \DoExprSyntax.body:
+    return "body"
   case \DoStmtSyntax.body:
     return "body"
   case \DocumentationAttributeArgumentSyntax.label:
diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift
@@ -131,6 +131,8 @@ extension SyntaxKind {
       return "'@differentiable' arguments"
     case .discardStmt:
       return "'discard' statement"
+    case .doExpr:
+      return "'do' block"
     case .doStmt:
       return "'do' statement"
     case .documentationAttributeArgumentList:
diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
@@ -1015,6 +1015,20 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "expression"
   case \DiscardStmtSyntax.unexpectedAfterExpression:
     return "unexpectedAfterExpression"
+  case \DoExprSyntax.unexpectedBeforeDoKeyword:
+    return "unexpectedBeforeDoKeyword"
+  case \DoExprSyntax.doKeyword:
+    return "doKeyword"
+  case \DoExprSyntax.unexpectedBetweenDoKeywordAndBody:
+    return "unexpectedBetweenDoKeywordAndBody"
+  case \DoExprSyntax.body:
+    return "body"
+  case \DoExprSyntax.unexpectedBetweenBodyAndCatchClauses:
+    return "unexpectedBetweenBodyAndCatchClauses"
+  case \DoExprSyntax.catchClauses:
+    return "catchClauses"
+  case \DoExprSyntax.unexpectedAfterCatchClauses:
+    return "unexpectedAfterCatchClauses"
   case \DoStmtSyntax.unexpectedBeforeDoKeyword:
     return "unexpectedBeforeDoKeyword"
   case \DoStmtSyntax.doKeyword:
diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
@@ -728,6 +728,20 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
   
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  override open func visit(_ node: DoExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+  
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  override open func visitPost(_ node: DoExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  
   override open func visit(_ node: DoStmtSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
@@ -474,6 +474,7 @@ public extension Syntax {
 /// - ``DeclReferenceExprSyntax``
 /// - ``DictionaryExprSyntax``
 /// - ``DiscardAssignmentExprSyntax``
+/// - ``DoExprSyntax``
 /// - ``EditorPlaceholderExprSyntax``
 /// - ``FloatLiteralExprSyntax``
 /// - ``ForceUnwrapExprSyntax``
@@ -546,7 +547,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public init?(_ node: some SyntaxProtocol) {
     switch node.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .canImportExpr, .canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .canImportExpr, .canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -587,6 +588,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
           .node(DeclReferenceExprSyntax.self),
           .node(DictionaryExprSyntax.self),
           .node(DiscardAssignmentExprSyntax.self),
+          .node(DoExprSyntax.self),
           .node(EditorPlaceholderExprSyntax.self),
           .node(FloatLiteralExprSyntax.self),
           .node(ForceUnwrapExprSyntax.self),
@@ -1608,6 +1610,7 @@ extension Syntax {
           .node(DifferentiableAttributeArgumentsSyntax.self),
           .node(DiscardAssignmentExprSyntax.self),
           .node(DiscardStmtSyntax.self),
+          .node(DoExprSyntax.self),
           .node(DoStmtSyntax.self),
           .node(DocumentationAttributeArgumentListSyntax.self),
           .node(DocumentationAttributeArgumentSyntax.self),
diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift
@@ -229,6 +229,7 @@ public struct AvailabilityArgumentListSyntax: SyntaxCollection, SyntaxHashable {
 ///
 /// ### Contained in
 /// 
+///  - ``DoExprSyntax``.``DoExprSyntax/catchClauses``
 ///  - ``DoStmtSyntax``.``DoStmtSyntax/catchClauses``
 public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable {
   public typealias Element = CatchClauseSyntax
diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
@@ -99,6 +99,10 @@ public enum SyntaxEnum {
   case differentiableAttributeArguments(DifferentiableAttributeArgumentsSyntax)
   case discardAssignmentExpr(DiscardAssignmentExprSyntax)
   case discardStmt(DiscardStmtSyntax)
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case doExpr(DoExprSyntax)
   case doStmt(DoStmtSyntax)
   case documentationAttributeArgumentList(DocumentationAttributeArgumentListSyntax)
   case documentationAttributeArgument(DocumentationAttributeArgumentSyntax)
@@ -471,6 +475,8 @@ public extension Syntax {
       return .discardAssignmentExpr(DiscardAssignmentExprSyntax(self)!)
     case .discardStmt:
       return .discardStmt(DiscardStmtSyntax(self)!)
+    case .doExpr:
+      return .doExpr(DoExprSyntax(self)!)
     case .doStmt:
       return .doStmt(DoStmtSyntax(self)!)
     case .documentationAttributeArgumentList:
diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift
@@ -99,6 +99,10 @@ public enum SyntaxKind: CaseIterable {
   case differentiableAttributeArguments
   case discardAssignmentExpr
   case discardStmt
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case doExpr
   case doStmt
   case documentationAttributeArgumentList
   case documentationAttributeArgument
@@ -592,6 +596,8 @@ public enum SyntaxKind: CaseIterable {
       return DiscardAssignmentExprSyntax.self
     case .discardStmt:
       return DiscardStmtSyntax.self
+    case .doExpr:
+      return DoExprSyntax.self
     case .doStmt:
       return DoStmtSyntax.self
     case .documentationAttributeArgumentList:
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -668,6 +668,16 @@ open class SyntaxRewriter {
     return StmtSyntax(visitChildren(node))
   }
   
+  /// Visit a ``DoExprSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visit(_ node: DoExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+  
   /// Visit a ``DoStmtSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2442,6 +2452,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl($0, DiscardStmtSyntax.self, self.visit)
       }
+    case .doExpr:
+      return {
+        self.visitImpl($0, DoExprSyntax.self, self.visit)
+      }
     case .doStmt:
       return {
         self.visitImpl($0, DoStmtSyntax.self, self.visit)
@@ -3392,6 +3406,8 @@ open class SyntaxRewriter {
       return visitImpl(node, DiscardAssignmentExprSyntax.self, visit)
     case .discardStmt:
       return visitImpl(node, DiscardStmtSyntax.self, visit)
+    case .doExpr:
+      return visitImpl(node, DoExprSyntax.self, visit)
     case .doStmt:
       return visitImpl(node, DoStmtSyntax.self, visit)
     case .documentationAttributeArgumentList:
diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift
@@ -699,6 +699,8 @@ extension DictionaryElementSyntax: WithTrailingCommaSyntax {}
 
 extension DifferentiabilityArgumentSyntax: WithTrailingCommaSyntax {}
 
+extension DoExprSyntax: WithCodeBlockSyntax {}
+
 extension DoStmtSyntax: WithCodeBlockSyntax {}
 
 extension DocumentationAttributeArgumentSyntax: WithTrailingCommaSyntax {}
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -1042,6 +1042,24 @@ open class SyntaxVisitor {
   open func visitPost(_ node: DiscardStmtSyntax) {
   }
   
+  /// Visiting ``DoExprSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visit(_ node: DoExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+  
+  /// The function called after visiting ``DoExprSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visitPost(_ node: DoExprSyntax) {
+  }
+  
   /// Visiting ``DoStmtSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -3762,6 +3780,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl($0, DiscardStmtSyntax.self, self.visit, self.visitPost)
       }
+    case .doExpr:
+      return {
+        self.visitImpl($0, DoExprSyntax.self, self.visit, self.visitPost)
+      }
     case .doStmt:
       return {
         self.visitImpl($0, DoStmtSyntax.self, self.visit, self.visitPost)
@@ -4715,6 +4737,8 @@ open class SyntaxVisitor {
       visitImpl(node, DiscardAssignmentExprSyntax.self, visit, visitPost)
     case .discardStmt:
       visitImpl(node, DiscardStmtSyntax.self, visit, visitPost)
+    case .doExpr:
+      visitImpl(node, DoExprSyntax.self, visit, visitPost)
     case .doStmt:
       visitImpl(node, DoStmtSyntax.self, visit, visitPost)
     case .documentationAttributeArgumentList:
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift
@@ -1908,6 +1908,91 @@ public struct RawDiscardStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
 }
 
+#if compiler(>=5.8)
+@_spi(ExperimentalLanguageFeatures)
+#endif
+@_spi(RawSyntax)
+public struct RawDoExprSyntax: RawExprSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+  
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .doExpr
+  }
+  
+  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(
+      _ unexpectedBeforeDoKeyword: RawUnexpectedNodesSyntax? = nil, 
+      doKeyword: RawTokenSyntax, 
+      _ unexpectedBetweenDoKeywordAndBody: RawUnexpectedNodesSyntax? = nil, 
+      body: RawCodeBlockSyntax, 
+      _ unexpectedBetweenBodyAndCatchClauses: RawUnexpectedNodesSyntax? = nil, 
+      catchClauses: RawCatchClauseListSyntax, 
+      _ unexpectedAfterCatchClauses: RawUnexpectedNodesSyntax? = nil, 
+      arena: __shared SyntaxArena
+    ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .doExpr, uninitializedCount: 7, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeDoKeyword?.raw
+      layout[1] = doKeyword.raw
+      layout[2] = unexpectedBetweenDoKeywordAndBody?.raw
+      layout[3] = body.raw
+      layout[4] = unexpectedBetweenBodyAndCatchClauses?.raw
+      layout[5] = catchClauses.raw
+      layout[6] = unexpectedAfterCatchClauses?.raw
+    }
+    self.init(unchecked: raw)
+  }
+  
+  public var unexpectedBeforeDoKeyword: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var doKeyword: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  
+  public var unexpectedBetweenDoKeywordAndBody: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var body: RawCodeBlockSyntax {
+    layoutView.children[3].map(RawCodeBlockSyntax.init(raw:))!
+  }
+  
+  public var unexpectedBetweenBodyAndCatchClauses: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var catchClauses: RawCatchClauseListSyntax {
+    layoutView.children[5].map(RawCatchClauseListSyntax.init(raw:))!
+  }
+  
+  public var unexpectedAfterCatchClauses: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawDoStmtSyntax: RawStmtSyntaxNodeProtocol {
   @_spi(RawSyntax)
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift
@@ -974,7 +974,7 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol {
   
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
     switch raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .canImportExpr, .canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .canImportExpr, .canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
       return true
     default:
       return false
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
@@ -993,6 +993,15 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     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 .doExpr:
+    assert(layout.count == 7)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("do")]))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawCodeBlockSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 5, verify(layout[5], as: RawCatchClauseListSyntax.self))
+    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
   case .doStmt:
     assert(layout.count == 7)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift
@@ -3226,6 +3226,7 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo
 ///  - ``CatchClauseSyntax``.``CatchClauseSyntax/body``
 ///  - ``DeferStmtSyntax``.``DeferStmtSyntax/body``
 ///  - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/body``
+///  - ``DoExprSyntax``.``DoExprSyntax/body``
 ///  - ``DoStmtSyntax``.``DoStmtSyntax/body``
 ///  - ``ForStmtSyntax``.``ForStmtSyntax/body``
 ///  - ``FunctionDeclSyntax``.``FunctionDeclSyntax/body``
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift
diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift

Original file line number	Diff line number	Diff line change
`@@ -32,4 +32,7 @@ extension Parser.ExperimentalFeatures {`
`32`	`32`
`33`	`33`	`/// Whether to enable the parsing of typed throws.`
`34`	`34`	`public static let typedThrows = Self(rawValue: 1 << 2)`
	`35`	`+`
	`36`	`+ /// Whether to enable the parsing of 'do' expressions.`
	`37`	`+ public static let doExpressions = Self(rawValue: 1 << 3)`
`35`	`38`	`}`