Regenerate syntax tree

Author: DougGregor

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -332,6 +332,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "first choice"
   case \TernaryExprSyntax.elseExpression:
     return "second choice"
+  case \ThrownTypeSyntax.type:
+    return "type"
   case \TuplePatternElementSyntax.label:
     return "label"
   case \TupleTypeElementSyntax.firstName:

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -361,6 +361,8 @@ extension SyntaxKind {
       return "'then' statement"
     case .throwStmt:
       return "'throw' statement"
+    case .thrownType:
+      return "thrown type"
     case .tryExpr:
       return "'try' expression"
     case .tupleExpr:

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

@@ -381,6 +381,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax
 - <doc:SwiftSyntax/SourceFileSyntax>
 - <doc:SwiftSyntax/SwitchCaseLabelSyntax>
 - <doc:SwiftSyntax/SwitchDefaultLabelSyntax>
+- <doc:SwiftSyntax/ThrownTypeSyntax>
 - <doc:SwiftSyntax/TypeAnnotationSyntax>
 - <doc:SwiftSyntax/TypeEffectSpecifiersSyntax>
 - <doc:SwiftSyntax/TypeInitializerClauseSyntax>

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -65,8 +65,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier"
   case \AccessorEffectSpecifiersSyntax.throwsSpecifier:
     return "throwsSpecifier"
-  case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier:
-    return "unexpectedAfterThrowsSpecifier"
+  case \AccessorEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType:
+    return "unexpectedBetweenThrowsSpecifierAndThrownType"
+  case \AccessorEffectSpecifiersSyntax.thrownType:
+    return "thrownType"
+  case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrownType:
+    return "unexpectedAfterThrownType"
   case \AccessorParametersSyntax.unexpectedBeforeLeftParen:
     return "unexpectedBeforeLeftParen"
   case \AccessorParametersSyntax.leftParen:
@@ -1401,8 +1405,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier"
   case \FunctionEffectSpecifiersSyntax.throwsSpecifier:
     return "throwsSpecifier"
-  case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier:
-    return "unexpectedAfterThrowsSpecifier"
+  case \FunctionEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType:
+    return "unexpectedBetweenThrowsSpecifierAndThrownType"
+  case \FunctionEffectSpecifiersSyntax.thrownType:
+    return "thrownType"
+  case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrownType:
+    return "unexpectedAfterThrownType"
   case \FunctionParameterClauseSyntax.unexpectedBeforeLeftParen:
     return "unexpectedBeforeLeftParen"
   case \FunctionParameterClauseSyntax.leftParen:
@@ -3083,6 +3091,20 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "expression"
   case \ThrowStmtSyntax.unexpectedAfterExpression:
     return "unexpectedAfterExpression"
+  case \ThrownTypeSyntax.unexpectedBeforeLeftParen:
+    return "unexpectedBeforeLeftParen"
+  case \ThrownTypeSyntax.leftParen:
+    return "leftParen"
+  case \ThrownTypeSyntax.unexpectedBetweenLeftParenAndType:
+    return "unexpectedBetweenLeftParenAndType"
+  case \ThrownTypeSyntax.type:
+    return "type"
+  case \ThrownTypeSyntax.unexpectedBetweenTypeAndRightParen:
+    return "unexpectedBetweenTypeAndRightParen"
+  case \ThrownTypeSyntax.rightParen:
+    return "rightParen"
+  case \ThrownTypeSyntax.unexpectedAfterRightParen:
+    return "unexpectedAfterRightParen"
   case \TryExprSyntax.unexpectedBeforeTryKeyword:
     return "unexpectedBeforeTryKeyword"
   case \TryExprSyntax.tryKeyword:
@@ -3235,8 +3257,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier"
   case \TypeEffectSpecifiersSyntax.throwsSpecifier:
     return "throwsSpecifier"
-  case \TypeEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier:
-    return "unexpectedAfterThrowsSpecifier"
+  case \TypeEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType:
+    return "unexpectedBetweenThrowsSpecifierAndThrownType"
+  case \TypeEffectSpecifiersSyntax.thrownType:
+    return "thrownType"
+  case \TypeEffectSpecifiersSyntax.unexpectedAfterThrownType:
+    return "unexpectedAfterThrownType"
   case \TypeExprSyntax.unexpectedBeforeType:
     return "unexpectedBeforeType"
   case \TypeExprSyntax.type:

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

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

Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -1641,6 +1641,7 @@ extension Syntax {
           .node(TernaryExprSyntax.self),
           .node(ThenStmtSyntax.self),
           .node(ThrowStmtSyntax.self),
+          .node(ThrownTypeSyntax.self),
           .node(TryExprSyntax.self),
           .node(TupleExprSyntax.self),
           .node(TuplePatternElementListSyntax.self),

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -260,6 +260,7 @@ public enum SyntaxEnum {
   case ternaryExpr(TernaryExprSyntax)
   case thenStmt(ThenStmtSyntax)
   case throwStmt(ThrowStmtSyntax)
+  case thrownType(ThrownTypeSyntax)
   case tryExpr(TryExprSyntax)
   case tupleExpr(TupleExprSyntax)
   case tuplePatternElementList(TuplePatternElementListSyntax)
@@ -789,6 +790,8 @@ public extension Syntax {
       return .thenStmt(ThenStmtSyntax(self)!)
     case .throwStmt:
       return .throwStmt(ThrowStmtSyntax(self)!)
+    case .thrownType:
+      return .thrownType(ThrownTypeSyntax(self)!)
     case .tryExpr:
       return .tryExpr(TryExprSyntax(self)!)
     case .tupleExpr:

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -260,6 +260,7 @@ public enum SyntaxKind: CaseIterable {
   case ternaryExpr
   case thenStmt
   case throwStmt
+  case thrownType
   case tryExpr
   case tupleExpr
   case tuplePatternElementList
@@ -910,6 +911,8 @@ public enum SyntaxKind: CaseIterable {
       return ThenStmtSyntax.self
     case .throwStmt:
       return ThrowStmtSyntax.self
+    case .thrownType:
+      return ThrownTypeSyntax.self
     case .tryExpr:
       return TryExprSyntax.self
     case .tupleExpr:

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -1795,6 +1795,13 @@ open class SyntaxRewriter {
     return StmtSyntax(visitChildren(node))
   }
 
+  /// Visit a ``ThrownTypeSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: ThrownTypeSyntax) -> ThrownTypeSyntax {
+    return visitChildren(node)
+  }
+  
   /// Visit a ``TryExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3076,6 +3083,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl($0, ThrowStmtSyntax.self, self.visit)
       }
+    case .thrownType:
+      return {
+        self.visitImpl($0, ThrownTypeSyntax.self, self.visit)
+      }
     case .tryExpr:
       return {
         self.visitImpl($0, TryExprSyntax.self, self.visit)
@@ -3700,6 +3711,8 @@ open class SyntaxRewriter {
       return visitImpl(node, ThenStmtSyntax.self, visit)
     case .throwStmt:
       return visitImpl(node, ThrowStmtSyntax.self, visit)
+    case .thrownType:
+      return visitImpl(node, ThrownTypeSyntax.self, visit)
     case .tryExpr:
       return visitImpl(node, TryExprSyntax.self, visit)
     case .tupleExpr:

Sources/SwiftSyntax/generated/SyntaxTraits.swift

@@ -152,7 +152,17 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol {
     set
   }
 
-  var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? {
+  var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? {
+    get
+    set
+  }
+  
+  var thrownType: ThrownTypeSyntax? {
+    get
+    set
+  }
+  
+  var unexpectedAfterThrownType: UnexpectedNodesSyntax? {
     get
     set
   }