diff --git a/CodeGeneration/Package.swift b/CodeGeneration/Package.swift
index 2c6b97f4b7f..83558e6e262 100644
--- a/CodeGeneration/Package.swift
+++ b/CodeGeneration/Package.swift
@@ -11,7 +11,7 @@ let package = Package(
     .executable(name: "generate-swiftsyntax", targets: ["generate-swiftsyntax"])
   ],
   dependencies: [
-    .package(url: "https://github.com/apple/swift-syntax.git", revision: "013a48e2312e57b7b355db25bd3ea75282ebf274"),
+    .package(url: "https://github.com/apple/swift-syntax.git", revision: "d73b60bb61a394c85d7a3c739b034e65a11032e6"),
     .package(url: "https://github.com/apple/swift-argument-parser.git", .upToNextMinor(from: "1.1.4")),
   ],
   targets: [
diff --git a/Sources/IDEUtils/generated/SyntaxClassification.swift b/Sources/IDEUtils/generated/SyntaxClassification.swift
index 196985d1d7a..bfa8f9bbc66 100644
--- a/Sources/IDEUtils/generated/SyntaxClassification.swift
+++ b/Sources/IDEUtils/generated/SyntaxClassification.swift
@@ -89,42 +89,42 @@ extension SyntaxClassification {
     // Separate checks for token nodes (most common checks) versus checks for layout nodes.
     if childKind == .token {
       switch (parentKind, indexInParent) {
-      case (.availabilityVersionRestriction, 1): 
+      case (.availabilityVersionRestriction, 1):
         return (.keyword, false)
-      case (.declModifier, 1): 
+      case (.declModifier, 1):
         return (.attribute, false)
-      case (.expressionSegment, 5): 
+      case (.expressionSegment, 5):
         return (.stringInterpolationAnchor, true)
-      case (.expressionSegment, 9): 
+      case (.expressionSegment, 9):
         return (.stringInterpolationAnchor, true)
-      case (.forInStmt, 5): 
+      case (.forInStmt, 5):
         return (.keyword, false)
-      case (.ifConfigClause, 1): 
+      case (.ifConfigClause, 1):
         return (.buildConfigId, false)
-      case (.ifConfigDecl, 3): 
+      case (.ifConfigDecl, 3):
         return (.buildConfigId, false)
-      case (.memberTypeIdentifier, 5): 
+      case (.memberTypeIdentifier, 5):
         return (.typeIdentifier, false)
-      case (.operatorDecl, 7): 
+      case (.operatorDecl, 7):
         return (.operatorIdentifier, false)
-      case (.precedenceGroupAssociativity, 1): 
+      case (.precedenceGroupAssociativity, 1):
         return (.keyword, false)
-      case (.precedenceGroupRelation, 1): 
+      case (.precedenceGroupRelation, 1):
         return (.keyword, false)
-      case (.simpleTypeIdentifier, 1): 
+      case (.simpleTypeIdentifier, 1):
         return (.typeIdentifier, false)
       default: 
         return nil
       }
     }else {
       switch (parentKind, indexInParent) {
-      case (.attribute, 3): 
+      case (.attribute, 3):
         return (.attribute, false)
-      case (.availabilityVersionRestrictionListEntry, 1): 
+      case (.availabilityVersionRestrictionListEntry, 1):
         return (.keyword, false)
-      case (.ifConfigClause, 3): 
+      case (.ifConfigClause, 3):
         return (.buildConfigId, false)
-      case (.operatorDecl, 3): 
+      case (.operatorDecl, 3):
         return (.attribute, false)
       default: 
         return nil
@@ -136,99 +136,99 @@ extension SyntaxClassification {
 extension RawTokenKind {
   internal var classification: SyntaxClassification {
     switch self {
-    case .wildcard: 
+    case .wildcard:
       return .none
-    case .leftParen: 
+    case .leftParen:
       return .none
-    case .rightParen: 
+    case .rightParen:
       return .none
-    case .leftBrace: 
+    case .leftBrace:
       return .none
-    case .rightBrace: 
+    case .rightBrace:
       return .none
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return .none
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return .none
-    case .leftAngle: 
+    case .leftAngle:
       return .none
-    case .rightAngle: 
+    case .rightAngle:
       return .none
-    case .period: 
+    case .period:
       return .none
-    case .comma: 
+    case .comma:
       return .none
-    case .ellipsis: 
+    case .ellipsis:
       return .none
-    case .colon: 
+    case .colon:
       return .none
-    case .semicolon: 
+    case .semicolon:
       return .none
-    case .equal: 
+    case .equal:
       return .none
-    case .atSign: 
+    case .atSign:
       return .attribute
-    case .pound: 
+    case .pound:
       return .none
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return .none
-    case .arrow: 
+    case .arrow:
       return .none
-    case .backtick: 
+    case .backtick:
       return .none
-    case .backslash: 
+    case .backslash:
       return .none
-    case .exclamationMark: 
+    case .exclamationMark:
       return .none
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return .none
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return .none
-    case .stringQuote: 
+    case .stringQuote:
       return .stringLiteral
-    case .singleQuote: 
+    case .singleQuote:
       return .stringLiteral
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return .stringLiteral
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return .poundDirectiveKeyword
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return .poundDirectiveKeyword
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return .poundDirectiveKeyword
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return .poundDirectiveKeyword
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return .poundDirectiveKeyword
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return .keyword
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return .keyword
-    case .integerLiteral: 
+    case .integerLiteral:
       return .integerLiteral
-    case .floatingLiteral: 
+    case .floatingLiteral:
       return .floatingLiteral
-    case .regexLiteral: 
+    case .regexLiteral:
       return .none
-    case .unknown: 
+    case .unknown:
       return .none
-    case .identifier: 
+    case .identifier:
       return .identifier
-    case .binaryOperator: 
+    case .binaryOperator:
       return .operatorIdentifier
-    case .postfixOperator: 
+    case .postfixOperator:
       return .operatorIdentifier
-    case .prefixOperator: 
+    case .prefixOperator:
       return .operatorIdentifier
-    case .dollarIdentifier: 
+    case .dollarIdentifier:
       return .dollarIdentifier
-    case .keyword: 
+    case .keyword:
       return .keyword
-    case .rawStringDelimiter: 
+    case .rawStringDelimiter:
       return .none
-    case .stringSegment: 
+    case .stringSegment:
       return .stringLiteral
-    case .eof: 
+    case .eof:
       return .none
     }
   }
diff --git a/Sources/SwiftBasicFormat/generated/BasicFormat.swift b/Sources/SwiftBasicFormat/generated/BasicFormat.swift
index 96d29968dc7..acfaec6bc63 100644
--- a/Sources/SwiftBasicFormat/generated/BasicFormat.swift
+++ b/Sources/SwiftBasicFormat/generated/BasicFormat.swift
@@ -74,65 +74,65 @@ open class BasicFormat: SyntaxRewriter {
   
   open func shouldIndent(_ keyPath: AnyKeyPath) -> Bool {
     switch keyPath {
-    case \AccessorBlockSyntax.accessors: 
+    case \AccessorBlockSyntax.accessors:
       return true
-    case \ArrayExprSyntax.elements: 
+    case \ArrayExprSyntax.elements:
       return true
-    case \ClosureExprSyntax.statements: 
+    case \ClosureExprSyntax.statements:
       return true
-    case \CodeBlockSyntax.statements: 
+    case \CodeBlockSyntax.statements:
       return true
-    case \DictionaryElementSyntax.valueExpression: 
+    case \DictionaryElementSyntax.valueExpression:
       return true
-    case \DictionaryExprSyntax.content: 
+    case \DictionaryExprSyntax.content:
       return true
-    case \FunctionCallExprSyntax.argumentList: 
+    case \FunctionCallExprSyntax.argumentList:
       return true
-    case \FunctionTypeSyntax.arguments: 
+    case \FunctionTypeSyntax.arguments:
       return true
-    case \MemberDeclBlockSyntax.members: 
+    case \MemberDeclBlockSyntax.members:
       return true
-    case \ParameterClauseSyntax.parameterList: 
+    case \ParameterClauseSyntax.parameterList:
       return true
-    case \SwitchCaseSyntax.statements: 
+    case \SwitchCaseSyntax.statements:
       return true
-    case \TupleExprSyntax.elementList: 
+    case \TupleExprSyntax.elementList:
       return true
-    case \TupleTypeSyntax.elements: 
+    case \TupleTypeSyntax.elements:
       return true
-    default: 
+    default:
       return false
     }
   }
   
   open func requiresLeadingNewline(_ keyPath: AnyKeyPath) -> Bool {
     switch keyPath {
-    case \AccessorBlockSyntax.rightBrace: 
+    case \AccessorBlockSyntax.rightBrace:
       return true
-    case \ClosureExprSyntax.rightBrace: 
+    case \ClosureExprSyntax.rightBrace:
       return true
-    case \CodeBlockSyntax.rightBrace: 
+    case \CodeBlockSyntax.rightBrace:
       return true
-    case \MemberDeclBlockSyntax.rightBrace: 
+    case \MemberDeclBlockSyntax.rightBrace:
       return true
-    case \SwitchExprSyntax.rightBrace: 
+    case \SwitchExprSyntax.rightBrace:
       return true
-    default: 
+    default:
       return putNextTokenOnNewLine
     }
   }
   
   open func childrenSeparatedByNewline(_ node: Syntax) -> Bool {
     switch node.as(SyntaxEnum.self) {
-    case .accessorList: 
+    case .accessorList:
       return true
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       return true
-    case .memberDeclList: 
+    case .memberDeclList:
       return true
-    case .switchCaseList: 
+    case .switchCaseList:
       return true
-    default: 
+    default:
       return false
     }
   }
@@ -141,9 +141,9 @@ open class BasicFormat: SyntaxRewriter {
   /// leading space behavior of a token.
   open func requiresLeadingSpace(_ keyPath: AnyKeyPath) -> Bool? {
     switch keyPath {
-    case \AvailabilityArgumentSyntax.entry: 
+    case \AvailabilityArgumentSyntax.entry:
       return false
-    default: 
+    default:
       return nil
     }
   }
@@ -153,21 +153,21 @@ open class BasicFormat: SyntaxRewriter {
       return requiresLeadingSpace
     }
     switch token.tokenKind {
-    case .leftBrace: 
+    case .leftBrace:
       return true
-    case .equal: 
+    case .equal:
       return true
-    case .arrow: 
+    case .arrow:
       return true
-    case .binaryOperator: 
+    case .binaryOperator:
       return true
-    case .keyword(.`catch`): 
+    case .keyword(.`catch`):
       return true
-    case .keyword(.`in`): 
+    case .keyword(.`in`):
       return true
-    case .keyword(.`where`): 
+    case .keyword(.`where`):
       return true
-    default: 
+    default:
       return false
     }
   }
@@ -176,23 +176,23 @@ open class BasicFormat: SyntaxRewriter {
   /// trailing space behavior of a token.
   open func requiresTrailingSpace(_ keyPath: AnyKeyPath) -> Bool? {
     switch keyPath {
-    case \AvailabilityArgumentSyntax.entry: 
+    case \AvailabilityArgumentSyntax.entry:
       return false
-    case \BreakStmtSyntax.breakKeyword: 
+    case \BreakStmtSyntax.breakKeyword:
       return false
-    case \DeclNameArgumentSyntax.colon: 
+    case \DeclNameArgumentSyntax.colon:
       return false
-    case \DictionaryExprSyntax.content: 
+    case \DictionaryExprSyntax.content:
       return false
-    case \DynamicReplacementArgumentsSyntax.forLabel: 
+    case \DynamicReplacementArgumentsSyntax.forLabel:
       return false
-    case \SwitchCaseLabelSyntax.colon: 
+    case \SwitchCaseLabelSyntax.colon:
       return false
-    case \SwitchDefaultLabelSyntax.colon: 
+    case \SwitchDefaultLabelSyntax.colon:
       return false
-    case \TryExprSyntax.questionOrExclamationMark: 
+    case \TryExprSyntax.questionOrExclamationMark:
       return true
-    default: 
+    default:
       return nil
     }
   }
@@ -212,121 +212,121 @@ open class BasicFormat: SyntaxRewriter {
      (.postfixQuestionMark, .rightAngle), // Ensures there is not space in `ContiguousArray<RawSyntax?>`
      (.postfixQuestionMark, .rightParen): // Ensures there is not space in `myOptionalClosure?()`
       return false
-    default: 
-      break 
+    default:
+      break
     }
     switch token.tokenKind {
-    case .comma: 
+    case .comma:
       return true
-    case .colon: 
+    case .colon:
       return true
-    case .equal: 
+    case .equal:
       return true
-    case .arrow: 
+    case .arrow:
       return true
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return true
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return true
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return true
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return true
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return true
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return true
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return true
-    case .binaryOperator: 
+    case .binaryOperator:
       return true
-    case .keyword(.`Any`): 
+    case .keyword(.`Any`):
       return true
-    case .keyword(.`as`): 
+    case .keyword(.`as`):
       return true
-    case .keyword(.`associatedtype`): 
+    case .keyword(.`associatedtype`):
       return true
-    case .keyword(.async): 
+    case .keyword(.async):
       return true
-    case .keyword(.`break`): 
+    case .keyword(.`break`):
       return true
-    case .keyword(.`case`): 
+    case .keyword(.`case`):
       return true
-    case .keyword(.`class`): 
+    case .keyword(.`class`):
       return true
-    case .keyword(.`continue`): 
+    case .keyword(.`continue`):
       return true
-    case .keyword(.`defer`): 
+    case .keyword(.`defer`):
       return true
-    case .keyword(.`else`): 
+    case .keyword(.`else`):
       return true
-    case .keyword(.`enum`): 
+    case .keyword(.`enum`):
       return true
-    case .keyword(.`extension`): 
+    case .keyword(.`extension`):
       return true
-    case .keyword(.`fallthrough`): 
+    case .keyword(.`fallthrough`):
       return true
-    case .keyword(.`fileprivate`): 
+    case .keyword(.`fileprivate`):
       return true
-    case .keyword(.`for`): 
+    case .keyword(.`for`):
       return true
-    case .keyword(.`func`): 
+    case .keyword(.`func`):
       return true
-    case .keyword(.`guard`): 
+    case .keyword(.`guard`):
       return true
-    case .keyword(.`if`): 
+    case .keyword(.`if`):
       return true
-    case .keyword(.`import`): 
+    case .keyword(.`import`):
       return true
-    case .keyword(.`in`): 
+    case .keyword(.`in`):
       return true
-    case .keyword(.`inout`): 
+    case .keyword(.`inout`):
       return true
-    case .keyword(.`internal`): 
+    case .keyword(.`internal`):
       return true
-    case .keyword(.`is`): 
+    case .keyword(.`is`):
       return true
-    case .keyword(.`let`): 
+    case .keyword(.`let`):
       return true
-    case .keyword(.`operator`): 
+    case .keyword(.`operator`):
       return true
-    case .keyword(.`precedencegroup`): 
+    case .keyword(.`precedencegroup`):
       return true
-    case .keyword(.`private`): 
+    case .keyword(.`private`):
       return true
-    case .keyword(.`protocol`): 
+    case .keyword(.`protocol`):
       return true
-    case .keyword(.`public`): 
+    case .keyword(.`public`):
       return true
-    case .keyword(.`repeat`): 
+    case .keyword(.`repeat`):
       return true
-    case .keyword(.`rethrows`): 
+    case .keyword(.`rethrows`):
       return true
-    case .keyword(.`return`): 
+    case .keyword(.`return`):
       return true
-    case .keyword(.`static`): 
+    case .keyword(.`static`):
       return true
-    case .keyword(.`struct`): 
+    case .keyword(.`struct`):
       return true
-    case .keyword(.`subscript`): 
+    case .keyword(.`subscript`):
       return true
-    case .keyword(.`switch`): 
+    case .keyword(.`switch`):
       return true
-    case .keyword(.`throw`): 
+    case .keyword(.`throw`):
       return true
-    case .keyword(.`throws`): 
+    case .keyword(.`throws`):
       return true
-    case .keyword(.`try`): 
+    case .keyword(.`try`):
       return true
-    case .keyword(.`typealias`): 
+    case .keyword(.`typealias`):
       return true
-    case .keyword(.`var`): 
+    case .keyword(.`var`):
       return true
-    case .keyword(.`where`): 
+    case .keyword(.`where`):
       return true
-    case .keyword(.`while`): 
+    case .keyword(.`while`):
       return true
-    default: 
+    default:
       return false
     }
   }
diff --git a/Sources/SwiftParser/generated/DeclarationModifier.swift b/Sources/SwiftParser/generated/DeclarationModifier.swift
index f9de7c54410..e8b730f4131 100644
--- a/Sources/SwiftParser/generated/DeclarationModifier.swift
+++ b/Sources/SwiftParser/generated/DeclarationModifier.swift
@@ -85,144 +85,144 @@ enum DeclarationModifier: TokenSpecSet {
   
   init?(lexeme: Lexer.Lexeme) {
     switch PrepareForKeywordMatch(lexeme) {
-    case TokenSpec(.`static`): 
+    case TokenSpec(.`static`):
       self = .`static`
-    case TokenSpec(.`class`): 
+    case TokenSpec(.`class`):
       self = .`class`
-    case TokenSpec(.final): 
+    case TokenSpec(.final):
       self = .final
-    case TokenSpec(.required): 
+    case TokenSpec(.required):
       self = .required
-    case TokenSpec(.optional): 
+    case TokenSpec(.optional):
       self = .optional
-    case TokenSpec(.lazy): 
+    case TokenSpec(.lazy):
       self = .lazy
-    case TokenSpec(.dynamic): 
+    case TokenSpec(.dynamic):
       self = .dynamic
-    case TokenSpec(.infix): 
+    case TokenSpec(.infix):
       self = .infix
-    case TokenSpec(.prefix): 
+    case TokenSpec(.prefix):
       self = .prefix
-    case TokenSpec(.postfix): 
+    case TokenSpec(.postfix):
       self = .postfix
-    case TokenSpec(.__consuming): 
+    case TokenSpec(.__consuming):
       self = .__consuming
-    case TokenSpec(.mutating): 
+    case TokenSpec(.mutating):
       self = .mutating
-    case TokenSpec(.nonmutating): 
+    case TokenSpec(.nonmutating):
       self = .nonmutating
-    case TokenSpec(.convenience): 
+    case TokenSpec(.convenience):
       self = .convenience
-    case TokenSpec(.override): 
+    case TokenSpec(.override):
       self = .override
-    case TokenSpec(.`private`): 
+    case TokenSpec(.`private`):
       self = .`private`
-    case TokenSpec(.`fileprivate`): 
+    case TokenSpec(.`fileprivate`):
       self = .`fileprivate`
-    case TokenSpec(.`internal`): 
+    case TokenSpec(.`internal`):
       self = .`internal`
-    case TokenSpec(.`public`): 
+    case TokenSpec(.`public`):
       self = .`public`
-    case TokenSpec(.package): 
+    case TokenSpec(.package):
       self = .package
-    case TokenSpec(.open): 
+    case TokenSpec(.open):
       self = .open
-    case TokenSpec(.__setter_access): 
+    case TokenSpec(.__setter_access):
       self = .__setter_access
-    case TokenSpec(.weak): 
+    case TokenSpec(.weak):
       self = .weak
-    case TokenSpec(.unowned): 
+    case TokenSpec(.unowned):
       self = .unowned
-    case TokenSpec(.`rethrows`): 
+    case TokenSpec(.`rethrows`):
       self = .`rethrows`
-    case TokenSpec(.indirect): 
+    case TokenSpec(.indirect):
       self = .indirect
-    case TokenSpec(.isolated): 
+    case TokenSpec(.isolated):
       self = .isolated
-    case TokenSpec(.async): 
+    case TokenSpec(.async):
       self = .async
-    case TokenSpec(.reasync): 
+    case TokenSpec(.reasync):
       self = .reasync
-    case TokenSpec(.nonisolated): 
+    case TokenSpec(.nonisolated):
       self = .nonisolated
-    case TokenSpec(.distributed): 
+    case TokenSpec(.distributed):
       self = .distributed
-    case TokenSpec(._const): 
+    case TokenSpec(._const):
       self = ._const
-    case TokenSpec(._local): 
+    case TokenSpec(._local):
       self = ._local
-    default: 
+    default:
       return nil
     }
   }
   
   var spec: TokenSpec {
     switch self {
-    case .`static`: 
+    case .`static`:
       return .keyword(.`static`)
-    case .`class`: 
+    case .`class`:
       return .keyword(.`class`)
-    case .final: 
+    case .final:
       return .keyword(.final)
-    case .required: 
+    case .required:
       return .keyword(.required)
-    case .optional: 
+    case .optional:
       return .keyword(.optional)
-    case .lazy: 
+    case .lazy:
       return .keyword(.lazy)
-    case .dynamic: 
+    case .dynamic:
       return .keyword(.dynamic)
-    case .infix: 
+    case .infix:
       return .keyword(.infix)
-    case .prefix: 
+    case .prefix:
       return .keyword(.prefix)
-    case .postfix: 
+    case .postfix:
       return .keyword(.postfix)
-    case .__consuming: 
+    case .__consuming:
       return .keyword(.__consuming)
-    case .mutating: 
+    case .mutating:
       return .keyword(.mutating)
-    case .nonmutating: 
+    case .nonmutating:
       return .keyword(.nonmutating)
-    case .convenience: 
+    case .convenience:
       return .keyword(.convenience)
-    case .override: 
+    case .override:
       return .keyword(.override)
-    case .`private`: 
+    case .`private`:
       return .keyword(.`private`)
-    case .`fileprivate`: 
+    case .`fileprivate`:
       return .keyword(.`fileprivate`)
-    case .`internal`: 
+    case .`internal`:
       return .keyword(.`internal`)
-    case .`public`: 
+    case .`public`:
       return .keyword(.`public`)
-    case .package: 
+    case .package:
       return .keyword(.package)
-    case .open: 
+    case .open:
       return .keyword(.open)
-    case .__setter_access: 
+    case .__setter_access:
       return .keyword(.__setter_access)
-    case .weak: 
+    case .weak:
       return .keyword(.weak)
-    case .unowned: 
+    case .unowned:
       return .keyword(.unowned)
-    case .`rethrows`: 
+    case .`rethrows`:
       return .keyword(.`rethrows`)
-    case .indirect: 
+    case .indirect:
       return .keyword(.indirect)
-    case .isolated: 
+    case .isolated:
       return .keyword(.isolated)
-    case .async: 
+    case .async:
       return .keyword(.async)
-    case .reasync: 
+    case .reasync:
       return .keyword(.reasync)
-    case .nonisolated: 
+    case .nonisolated:
       return .keyword(.nonisolated)
-    case .distributed: 
+    case .distributed:
       return .keyword(.distributed)
-    case ._const: 
+    case ._const:
       return .keyword(._const)
-    case ._local: 
+    case ._local:
       return .keyword(._local)
     }
   }
diff --git a/Sources/SwiftParser/generated/TypeAttribute.swift b/Sources/SwiftParser/generated/TypeAttribute.swift
index 0fe61b76c8e..fd2ad53f1ec 100644
--- a/Sources/SwiftParser/generated/TypeAttribute.swift
+++ b/Sources/SwiftParser/generated/TypeAttribute.swift
@@ -44,60 +44,60 @@ extension Parser {
     
     init?(lexeme: Lexer.Lexeme) {
       switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(.autoclosure): 
+      case TokenSpec(.autoclosure):
         self = .autoclosure
-      case TokenSpec(.convention): 
+      case TokenSpec(.convention):
         self = .convention
-      case TokenSpec(.noescape): 
+      case TokenSpec(.noescape):
         self = .noescape
-      case TokenSpec(.escaping): 
+      case TokenSpec(.escaping):
         self = .escaping
-      case TokenSpec(.differentiable): 
+      case TokenSpec(.differentiable):
         self = .differentiable
-      case TokenSpec(.noDerivative): 
+      case TokenSpec(.noDerivative):
         self = .noDerivative
-      case TokenSpec(.async): 
+      case TokenSpec(.async):
         self = .async
-      case TokenSpec(.Sendable): 
+      case TokenSpec(.Sendable):
         self = .Sendable
-      case TokenSpec(.unchecked): 
+      case TokenSpec(.unchecked):
         self = .unchecked
-      case TokenSpec(._local): 
+      case TokenSpec(._local):
         self = ._local
-      case TokenSpec(._noMetadata): 
+      case TokenSpec(._noMetadata):
         self = ._noMetadata
-      case TokenSpec(._opaqueReturnTypeOf): 
+      case TokenSpec(._opaqueReturnTypeOf):
         self = ._opaqueReturnTypeOf
-      default: 
+      default:
         return nil
       }
     }
     
     var spec: TokenSpec {
       switch self {
-      case .autoclosure: 
+      case .autoclosure:
         return .keyword(.autoclosure)
-      case .convention: 
+      case .convention:
         return .keyword(.convention)
-      case .noescape: 
+      case .noescape:
         return .keyword(.noescape)
-      case .escaping: 
+      case .escaping:
         return .keyword(.escaping)
-      case .differentiable: 
+      case .differentiable:
         return .keyword(.differentiable)
-      case .noDerivative: 
+      case .noDerivative:
         return .keyword(.noDerivative)
-      case .async: 
+      case .async:
         return .keyword(.async)
-      case .Sendable: 
+      case .Sendable:
         return .keyword(.Sendable)
-      case .unchecked: 
+      case .unchecked:
         return .keyword(.unchecked)
-      case ._local: 
+      case ._local:
         return .keyword(._local)
-      case ._noMetadata: 
+      case ._noMetadata:
         return .keyword(._noMetadata)
-      case ._opaqueReturnTypeOf: 
+      case ._opaqueReturnTypeOf:
         return .keyword(._opaqueReturnTypeOf)
       }
     }
diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift
index 11fa63db2ad..fe883aa9341 100644
--- a/Sources/SwiftSyntax/generated/Keyword.swift
+++ b/Sources/SwiftSyntax/generated/Keyword.swift
@@ -413,503 +413,503 @@ public enum Keyword: UInt8, Hashable {
   
   @_spi(RawSyntax) public init?(_ text: SyntaxText) {
     switch text.count {
-    case 2: 
+    case 2:
       switch text {
-      case "as": 
+      case "as":
         self = .`as`
-      case "do": 
+      case "do":
         self = .`do`
-      case "if": 
+      case "if":
         self = .`if`
-      case "in": 
+      case "in":
         self = .`in`
-      case "is": 
+      case "is":
         self = .`is`
-      case "of": 
+      case "of":
         self = .of
       default: 
         return nil
       }
-    case 3: 
+    case 3:
       switch text {
-      case "any": 
+      case "any":
         self = .any
-      case "Any": 
+      case "Any":
         self = .`Any`
-      case "for": 
+      case "for":
         self = .`for`
-      case "get": 
+      case "get":
         self = .get
-      case "let": 
+      case "let":
         self = .`let`
-      case "nil": 
+      case "nil":
         self = .`nil`
-      case "set": 
+      case "set":
         self = .set
-      case "spi": 
+      case "spi":
         self = .spi
-      case "try": 
+      case "try":
         self = .`try`
-      case "var": 
+      case "var":
         self = .`var`
-      case "wrt": 
+      case "wrt":
         self = .wrt
       default: 
         return nil
       }
-    case 4: 
+    case 4:
       switch text {
-      case "_spi": 
+      case "_spi":
         self = ._spi
-      case "case": 
+      case "case":
         self = .`case`
-      case "each": 
+      case "each":
         self = .each
-      case "else": 
+      case "else":
         self = .`else`
-      case "enum": 
+      case "enum":
         self = .`enum`
-      case "file": 
+      case "file":
         self = .file
-      case "func": 
+      case "func":
         self = .`func`
-      case "init": 
+      case "init":
         self = .`init`
-      case "kind": 
+      case "kind":
         self = .kind
-      case "lazy": 
+      case "lazy":
         self = .lazy
-      case "left": 
+      case "left":
         self = .left
-      case "line": 
+      case "line":
         self = .line
-      case "none": 
+      case "none":
         self = .none
-      case "objc": 
+      case "objc":
         self = .objc
-      case "open": 
+      case "open":
         self = .open
-      case "safe": 
+      case "safe":
         self = .safe
-      case "self": 
+      case "self":
         self = .`self`
-      case "Self": 
+      case "Self":
         self = .`Self`
-      case "some": 
+      case "some":
         self = .some
-      case "true": 
+      case "true":
         self = .`true`
-      case "Type": 
+      case "Type":
         self = .`Type`
-      case "weak": 
+      case "weak":
         self = .weak
       default: 
         return nil
       }
-    case 5: 
+    case 5:
       switch text {
-      case "_move": 
+      case "_move":
         self = ._move
-      case "_read": 
+      case "_read":
         self = ._read
-      case "actor": 
+      case "actor":
         self = .actor
-      case "async": 
+      case "async":
         self = .async
-      case "await": 
+      case "await":
         self = .await
-      case "block": 
+      case "block":
         self = .block
-      case "break": 
+      case "break":
         self = .`break`
-      case "catch": 
+      case "catch":
         self = .`catch`
-      case "class": 
+      case "class":
         self = .`class`
-      case "cType": 
+      case "cType":
         self = .cType
-      case "defer": 
+      case "defer":
         self = .`defer`
-      case "false": 
+      case "false":
         self = .`false`
-      case "final": 
+      case "final":
         self = .final
-      case "guard": 
+      case "guard":
         self = .`guard`
-      case "infix": 
+      case "infix":
         self = .infix
-      case "inout": 
+      case "inout":
         self = .`inout`
-      case "macro": 
+      case "macro":
         self = .macro
-      case "right": 
+      case "right":
         self = .right
-      case "super": 
+      case "super":
         self = .`super`
-      case "swift": 
+      case "swift":
         self = .swift
-      case "throw": 
+      case "throw":
         self = .`throw`
-      case "where": 
+      case "where":
         self = .`where`
-      case "while": 
+      case "while":
         self = .`while`
-      case "yield": 
+      case "yield":
         self = .yield
       default: 
         return nil
       }
-    case 6: 
+    case 6:
       switch text {
-      case "_cdecl": 
+      case "_cdecl":
         self = ._cdecl
-      case "_Class": 
+      case "_Class":
         self = ._Class
-      case "_const": 
+      case "_const":
         self = ._const
-      case "_local": 
+      case "_local":
         self = ._local
-      case "before": 
+      case "before":
         self = .before
-      case "deinit": 
+      case "deinit":
         self = .`deinit`
-      case "didSet": 
+      case "didSet":
         self = .didSet
-      case "import": 
+      case "import":
         self = .`import`
-      case "inline": 
+      case "inline":
         self = .inline
-      case "linear": 
+      case "linear":
         self = .linear
-      case "module": 
+      case "module":
         self = .module
-      case "prefix": 
+      case "prefix":
         self = .prefix
-      case "public": 
+      case "public":
         self = .`public`
-      case "repeat": 
+      case "repeat":
         self = .`repeat`
-      case "return": 
+      case "return":
         self = .`return`
-      case "static": 
+      case "static":
         self = .`static`
-      case "struct": 
+      case "struct":
         self = .`struct`
-      case "switch": 
+      case "switch":
         self = .`switch`
-      case "target": 
+      case "target":
         self = .target
-      case "throws": 
+      case "throws":
         self = .`throws`
-      case "unsafe": 
+      case "unsafe":
         self = .unsafe
       default: 
         return nil
       }
-    case 7: 
+    case 7:
       switch text {
-      case "__owned": 
+      case "__owned":
         self = .__owned
-      case "_borrow": 
+      case "_borrow":
         self = ._borrow
-      case "_expose": 
+      case "_expose":
         self = ._expose
-      case "_linear": 
+      case "_linear":
         self = ._linear
-      case "_modify": 
+      case "_modify":
         self = ._modify
-      case "default": 
+      case "default":
         self = .`default`
-      case "dynamic": 
+      case "dynamic":
         self = .dynamic
-      case "forward": 
+      case "forward":
         self = .forward
-      case "message": 
+      case "message":
         self = .message
-      case "noasync": 
+      case "noasync":
         self = .noasync
-      case "package": 
+      case "package":
         self = .package
-      case "postfix": 
+      case "postfix":
         self = .postfix
-      case "private": 
+      case "private":
         self = .`private`
-      case "reasync": 
+      case "reasync":
         self = .reasync
-      case "renamed": 
+      case "renamed":
         self = .renamed
-      case "reverse": 
+      case "reverse":
         self = .reverse
-      case "unowned": 
+      case "unowned":
         self = .unowned
-      case "willSet": 
+      case "willSet":
         self = .willSet
       default: 
         return nil
       }
-    case 8: 
+    case 8:
       switch text {
-      case "__shared": 
+      case "__shared":
         self = .__shared
-      case "_effects": 
+      case "_effects":
         self = ._effects
-      case "_forward": 
+      case "_forward":
         self = ._forward
-      case "_private": 
+      case "_private":
         self = ._private
-      case "_Trivial": 
+      case "_Trivial":
         self = ._Trivial
-      case "continue": 
+      case "continue":
         self = .`continue`
-      case "escaping": 
+      case "escaping":
         self = .escaping
-      case "exported": 
+      case "exported":
         self = .exported
-      case "indirect": 
+      case "indirect":
         self = .indirect
-      case "internal": 
+      case "internal":
         self = .`internal`
-      case "isolated": 
+      case "isolated":
         self = .isolated
-      case "metadata": 
+      case "metadata":
         self = .metadata
-      case "mutating": 
+      case "mutating":
         self = .mutating
-      case "noescape": 
+      case "noescape":
         self = .noescape
-      case "operator": 
+      case "operator":
         self = .`operator`
-      case "optional": 
+      case "optional":
         self = .optional
-      case "override": 
+      case "override":
         self = .override
-      case "Protocol": 
+      case "Protocol":
         self = .`Protocol`
-      case "protocol": 
+      case "protocol":
         self = .`protocol`
-      case "required": 
+      case "required":
         self = .required
-      case "rethrows": 
+      case "rethrows":
         self = .`rethrows`
-      case "Sendable": 
+      case "Sendable":
         self = .Sendable
       default: 
         return nil
       }
-    case 9: 
+    case 9:
       switch text {
-      case "_optimize": 
+      case "_optimize":
         self = ._optimize
-      case "available": 
+      case "available":
         self = .available
-      case "extension": 
+      case "extension":
         self = .`extension`
-      case "lowerThan": 
+      case "lowerThan":
         self = .lowerThan
-      case "obsoleted": 
+      case "obsoleted":
         self = .obsoleted
-      case "spiModule": 
+      case "spiModule":
         self = .spiModule
-      case "subscript": 
+      case "subscript":
         self = .`subscript`
-      case "transpose": 
+      case "transpose":
         self = .transpose
-      case "typealias": 
+      case "typealias":
         self = .`typealias`
-      case "unchecked": 
+      case "unchecked":
         self = .unchecked
       default: 
         return nil
       }
-    case 10: 
+    case 10:
       switch text {
-      case "_alignment": 
+      case "_alignment":
         self = ._alignment
-      case "_semantics": 
+      case "_semantics":
         self = ._semantics
-      case "assignment": 
+      case "assignment":
         self = .assignment
-      case "convention": 
+      case "convention":
         self = .convention
-      case "deprecated": 
+      case "deprecated":
         self = .deprecated
-      case "derivative": 
+      case "derivative":
         self = .derivative
-      case "higherThan": 
+      case "higherThan":
         self = .higherThan
-      case "introduced": 
+      case "introduced":
         self = .introduced
-      case "sourceFile": 
+      case "sourceFile":
         self = .sourceFile
-      case "visibility": 
+      case "visibility":
         self = .visibility
       default: 
         return nil
       }
-    case 11: 
+    case 11:
       switch text {
-      case "__consuming": 
+      case "__consuming":
         self = .__consuming
-      case "_backDeploy": 
+      case "_backDeploy":
         self = ._backDeploy
-      case "_implements": 
+      case "_implements":
         self = ._implements
-      case "_noMetadata": 
+      case "_noMetadata":
         self = ._noMetadata
-      case "_specialize": 
+      case "_specialize":
         self = ._specialize
-      case "_typeEraser": 
+      case "_typeEraser":
         self = ._typeEraser
-      case "autoclosure": 
+      case "autoclosure":
         self = .autoclosure
-      case "convenience": 
+      case "convenience":
         self = .convenience
-      case "distributed": 
+      case "distributed":
         self = .distributed
-      case "exclusivity": 
+      case "exclusivity":
         self = .exclusivity
-      case "fallthrough": 
+      case "fallthrough":
         self = .`fallthrough`
-      case "fileprivate": 
+      case "fileprivate":
         self = .`fileprivate`
-      case "nonisolated": 
+      case "nonisolated":
         self = .nonisolated
-      case "nonmutating": 
+      case "nonmutating":
         self = .nonmutating
-      case "unavailable": 
+      case "unavailable":
         self = .unavailable
       default: 
         return nil
       }
-    case 12: 
+    case 12:
       switch text {
-      case "_NativeClass": 
+      case "_NativeClass":
         self = ._NativeClass
-      case "_nonSendable": 
+      case "_nonSendable":
         self = ._nonSendable
-      case "_silgen_name": 
+      case "_silgen_name":
         self = ._silgen_name
-      case "availability": 
+      case "availability":
         self = .availability
-      case "backDeployed": 
+      case "backDeployed":
         self = .backDeployed
-      case "noDerivative": 
+      case "noDerivative":
         self = .noDerivative
       default: 
         return nil
       }
-    case 13: 
+    case 13:
       switch text {
-      case "associativity": 
+      case "associativity":
         self = .associativity
-      case "unsafeAddress": 
+      case "unsafeAddress":
         self = .unsafeAddress
       default: 
         return nil
       }
-    case 14: 
+    case 14:
       switch text {
-      case "_documentation": 
+      case "_documentation":
         self = ._documentation
-      case "_spi_available": 
+      case "_spi_available":
         self = ._spi_available
-      case "_TrivialAtMost": 
+      case "_TrivialAtMost":
         self = ._TrivialAtMost
-      case "_UnknownLayout": 
+      case "_UnknownLayout":
         self = ._UnknownLayout
-      case "associatedtype": 
+      case "associatedtype":
         self = .`associatedtype`
-      case "differentiable": 
+      case "differentiable":
         self = .differentiable
-      case "witness_method": 
+      case "witness_method":
         self = .witness_method
       default: 
         return nil
       }
-    case 15: 
+    case 15:
       switch text {
-      case "__setter_access": 
+      case "__setter_access":
         self = .__setter_access
-      case "precedencegroup": 
+      case "precedencegroup":
         self = .`precedencegroup`
       default: 
         return nil
       }
-    case 16: 
+    case 16:
       switch text {
-      case "_objcRuntimeName": 
+      case "_objcRuntimeName":
         self = ._objcRuntimeName
-      case "addressWithOwner": 
+      case "addressWithOwner":
         self = .addressWithOwner
       default: 
         return nil
       }
-    case 17: 
+    case 17:
       switch text {
-      case "_RefCountedObject": 
+      case "_RefCountedObject":
         self = ._RefCountedObject
       default: 
         return nil
       }
-    case 19: 
+    case 19:
       switch text {
-      case "_dynamicReplacement": 
+      case "_dynamicReplacement":
         self = ._dynamicReplacement
-      case "_objcImplementation": 
+      case "_objcImplementation":
         self = ._objcImplementation
-      case "_opaqueReturnTypeOf": 
+      case "_opaqueReturnTypeOf":
         self = ._opaqueReturnTypeOf
-      case "_PackageDescription": 
+      case "_PackageDescription":
         self = ._PackageDescription
       default: 
         return nil
       }
-    case 20: 
+    case 20:
       switch text {
-      case "_compilerInitialized": 
+      case "_compilerInitialized":
         self = ._compilerInitialized
-      case "_originallyDefinedIn": 
+      case "_originallyDefinedIn":
         self = ._originallyDefinedIn
-      case "unsafeMutableAddress": 
+      case "unsafeMutableAddress":
         self = .unsafeMutableAddress
       default: 
         return nil
       }
-    case 21: 
+    case 21:
       switch text {
-      case "_unavailableFromAsync": 
+      case "_unavailableFromAsync":
         self = ._unavailableFromAsync
       default: 
         return nil
       }
-    case 22: 
+    case 22:
       switch text {
-      case "addressWithNativeOwner": 
+      case "addressWithNativeOwner":
         self = .addressWithNativeOwner
       default: 
         return nil
       }
-    case 23: 
+    case 23:
       switch text {
-      case "_NativeRefCountedObject": 
+      case "_NativeRefCountedObject":
         self = ._NativeRefCountedObject
-      case "_projectedValueProperty": 
+      case "_projectedValueProperty":
         self = ._projectedValueProperty
-      case "mutableAddressWithOwner": 
+      case "mutableAddressWithOwner":
         self = .mutableAddressWithOwner
       default: 
         return nil
       }
-    case 29: 
+    case 29:
       switch text {
-      case "mutableAddressWithNativeOwner": 
+      case "mutableAddressWithNativeOwner":
         self = .mutableAddressWithNativeOwner
       default: 
         return nil
       }
-    case 31: 
+    case 31:
       switch text {
-      case "_swift_native_objc_runtime_base": 
+      case "_swift_native_objc_runtime_base":
         self = ._swift_native_objc_runtime_base
       default: 
         return nil
diff --git a/Sources/SwiftSyntax/generated/Misc.swift b/Sources/SwiftSyntax/generated/Misc.swift
index 823cfa6f71a..1e39256a41e 100644
--- a/Sources/SwiftSyntax/generated/Misc.swift
+++ b/Sources/SwiftSyntax/generated/Misc.swift
@@ -286,1054 +286,1054 @@ extension Syntax {
 extension SyntaxKind {
   public var syntaxNodeType: SyntaxProtocol.Type {
     switch self {
-    case .token: 
+    case .token:
       return TokenSyntax.self
-    case .accessPathComponent: 
+    case .accessPathComponent:
       return AccessPathComponentSyntax.self
-    case .accessPath: 
+    case .accessPath:
       return AccessPathSyntax.self
-    case .accessorBlock: 
+    case .accessorBlock:
       return AccessorBlockSyntax.self
-    case .accessorDecl: 
+    case .accessorDecl:
       return AccessorDeclSyntax.self
-    case .accessorList: 
+    case .accessorList:
       return AccessorListSyntax.self
-    case .accessorParameter: 
+    case .accessorParameter:
       return AccessorParameterSyntax.self
-    case .actorDecl: 
+    case .actorDecl:
       return ActorDeclSyntax.self
-    case .arrayElementList: 
+    case .arrayElementList:
       return ArrayElementListSyntax.self
-    case .arrayElement: 
+    case .arrayElement:
       return ArrayElementSyntax.self
-    case .arrayExpr: 
+    case .arrayExpr:
       return ArrayExprSyntax.self
-    case .arrayType: 
+    case .arrayType:
       return ArrayTypeSyntax.self
-    case .arrowExpr: 
+    case .arrowExpr:
       return ArrowExprSyntax.self
-    case .asExpr: 
+    case .asExpr:
       return AsExprSyntax.self
-    case .assignmentExpr: 
+    case .assignmentExpr:
       return AssignmentExprSyntax.self
-    case .associatedtypeDecl: 
+    case .associatedtypeDecl:
       return AssociatedtypeDeclSyntax.self
-    case .attributeList: 
+    case .attributeList:
       return AttributeListSyntax.self
-    case .attribute: 
+    case .attribute:
       return AttributeSyntax.self
-    case .attributedType: 
+    case .attributedType:
       return AttributedTypeSyntax.self
-    case .availabilityArgument: 
+    case .availabilityArgument:
       return AvailabilityArgumentSyntax.self
-    case .availabilityCondition: 
+    case .availabilityCondition:
       return AvailabilityConditionSyntax.self
-    case .availabilityEntry: 
+    case .availabilityEntry:
       return AvailabilityEntrySyntax.self
-    case .availabilityLabeledArgument: 
+    case .availabilityLabeledArgument:
       return AvailabilityLabeledArgumentSyntax.self
-    case .availabilitySpecList: 
+    case .availabilitySpecList:
       return AvailabilitySpecListSyntax.self
-    case .availabilityVersionRestrictionListEntry: 
+    case .availabilityVersionRestrictionListEntry:
       return AvailabilityVersionRestrictionListEntrySyntax.self
-    case .availabilityVersionRestrictionList: 
+    case .availabilityVersionRestrictionList:
       return AvailabilityVersionRestrictionListSyntax.self
-    case .availabilityVersionRestriction: 
+    case .availabilityVersionRestriction:
       return AvailabilityVersionRestrictionSyntax.self
-    case .awaitExpr: 
+    case .awaitExpr:
       return AwaitExprSyntax.self
-    case .backDeployedAttributeSpecList: 
+    case .backDeployedAttributeSpecList:
       return BackDeployedAttributeSpecListSyntax.self
-    case .binaryOperatorExpr: 
+    case .binaryOperatorExpr:
       return BinaryOperatorExprSyntax.self
-    case .booleanLiteralExpr: 
+    case .booleanLiteralExpr:
       return BooleanLiteralExprSyntax.self
-    case .borrowExpr: 
+    case .borrowExpr:
       return BorrowExprSyntax.self
-    case .breakStmt: 
+    case .breakStmt:
       return BreakStmtSyntax.self
-    case .caseItemList: 
+    case .caseItemList:
       return CaseItemListSyntax.self
-    case .caseItem: 
+    case .caseItem:
       return CaseItemSyntax.self
-    case .catchClauseList: 
+    case .catchClauseList:
       return CatchClauseListSyntax.self
-    case .catchClause: 
+    case .catchClause:
       return CatchClauseSyntax.self
-    case .catchItemList: 
+    case .catchItemList:
       return CatchItemListSyntax.self
-    case .catchItem: 
+    case .catchItem:
       return CatchItemSyntax.self
-    case .classDecl: 
+    case .classDecl:
       return ClassDeclSyntax.self
-    case .classRestrictionType: 
+    case .classRestrictionType:
       return ClassRestrictionTypeSyntax.self
-    case .closureCaptureItemList: 
+    case .closureCaptureItemList:
       return ClosureCaptureItemListSyntax.self
-    case .closureCaptureItemSpecifier: 
+    case .closureCaptureItemSpecifier:
       return ClosureCaptureItemSpecifierSyntax.self
-    case .closureCaptureItem: 
+    case .closureCaptureItem:
       return ClosureCaptureItemSyntax.self
-    case .closureCaptureSignature: 
+    case .closureCaptureSignature:
       return ClosureCaptureSignatureSyntax.self
-    case .closureExpr: 
+    case .closureExpr:
       return ClosureExprSyntax.self
-    case .closureParamList: 
+    case .closureParamList:
       return ClosureParamListSyntax.self
-    case .closureParam: 
+    case .closureParam:
       return ClosureParamSyntax.self
-    case .closureSignature: 
+    case .closureSignature:
       return ClosureSignatureSyntax.self
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       return CodeBlockItemListSyntax.self
-    case .codeBlockItem: 
+    case .codeBlockItem:
       return CodeBlockItemSyntax.self
-    case .codeBlock: 
+    case .codeBlock:
       return CodeBlockSyntax.self
-    case .compositionTypeElementList: 
+    case .compositionTypeElementList:
       return CompositionTypeElementListSyntax.self
-    case .compositionTypeElement: 
+    case .compositionTypeElement:
       return CompositionTypeElementSyntax.self
-    case .compositionType: 
+    case .compositionType:
       return CompositionTypeSyntax.self
-    case .conditionElementList: 
+    case .conditionElementList:
       return ConditionElementListSyntax.self
-    case .conditionElement: 
+    case .conditionElement:
       return ConditionElementSyntax.self
-    case .conformanceRequirement: 
+    case .conformanceRequirement:
       return ConformanceRequirementSyntax.self
-    case .constrainedSugarType: 
+    case .constrainedSugarType:
       return ConstrainedSugarTypeSyntax.self
-    case .continueStmt: 
+    case .continueStmt:
       return ContinueStmtSyntax.self
-    case .conventionAttributeArguments: 
+    case .conventionAttributeArguments:
       return ConventionAttributeArgumentsSyntax.self
-    case .conventionWitnessMethodAttributeArguments: 
+    case .conventionWitnessMethodAttributeArguments:
       return ConventionWitnessMethodAttributeArgumentsSyntax.self
-    case .declEffectSpecifiers: 
+    case .declEffectSpecifiers:
       return DeclEffectSpecifiersSyntax.self
-    case .declModifierDetail: 
+    case .declModifierDetail:
       return DeclModifierDetailSyntax.self
-    case .declModifier: 
+    case .declModifier:
       return DeclModifierSyntax.self
-    case .declNameArgumentList: 
+    case .declNameArgumentList:
       return DeclNameArgumentListSyntax.self
-    case .declNameArgument: 
+    case .declNameArgument:
       return DeclNameArgumentSyntax.self
-    case .declNameArguments: 
+    case .declNameArguments:
       return DeclNameArgumentsSyntax.self
-    case .declName: 
+    case .declName:
       return DeclNameSyntax.self
-    case .deferStmt: 
+    case .deferStmt:
       return DeferStmtSyntax.self
-    case .deinitializerDecl: 
+    case .deinitializerDecl:
       return DeinitializerDeclSyntax.self
-    case .derivativeRegistrationAttributeArguments: 
+    case .derivativeRegistrationAttributeArguments:
       return DerivativeRegistrationAttributeArgumentsSyntax.self
-    case .designatedTypeElement: 
+    case .designatedTypeElement:
       return DesignatedTypeElementSyntax.self
-    case .designatedTypeList: 
+    case .designatedTypeList:
       return DesignatedTypeListSyntax.self
-    case .dictionaryElementList: 
+    case .dictionaryElementList:
       return DictionaryElementListSyntax.self
-    case .dictionaryElement: 
+    case .dictionaryElement:
       return DictionaryElementSyntax.self
-    case .dictionaryExpr: 
+    case .dictionaryExpr:
       return DictionaryExprSyntax.self
-    case .dictionaryType: 
+    case .dictionaryType:
       return DictionaryTypeSyntax.self
-    case .differentiabilityParamList: 
+    case .differentiabilityParamList:
       return DifferentiabilityParamListSyntax.self
-    case .differentiabilityParam: 
+    case .differentiabilityParam:
       return DifferentiabilityParamSyntax.self
-    case .differentiabilityParamsClause: 
+    case .differentiabilityParamsClause:
       return DifferentiabilityParamsClauseSyntax.self
-    case .differentiabilityParams: 
+    case .differentiabilityParams:
       return DifferentiabilityParamsSyntax.self
-    case .differentiableAttributeArguments: 
+    case .differentiableAttributeArguments:
       return DifferentiableAttributeArgumentsSyntax.self
-    case .discardAssignmentExpr: 
+    case .discardAssignmentExpr:
       return DiscardAssignmentExprSyntax.self
-    case .doStmt: 
+    case .doStmt:
       return DoStmtSyntax.self
-    case .documentationAttributeArgument: 
+    case .documentationAttributeArgument:
       return DocumentationAttributeArgumentSyntax.self
-    case .documentationAttributeArguments: 
+    case .documentationAttributeArguments:
       return DocumentationAttributeArgumentsSyntax.self
-    case .dynamicReplacementArguments: 
+    case .dynamicReplacementArguments:
       return DynamicReplacementArgumentsSyntax.self
-    case .editorPlaceholderDecl: 
+    case .editorPlaceholderDecl:
       return EditorPlaceholderDeclSyntax.self
-    case .editorPlaceholderExpr: 
+    case .editorPlaceholderExpr:
       return EditorPlaceholderExprSyntax.self
-    case .effectsArguments: 
+    case .effectsArguments:
       return EffectsArgumentsSyntax.self
-    case .enumCaseDecl: 
+    case .enumCaseDecl:
       return EnumCaseDeclSyntax.self
-    case .enumCaseElementList: 
+    case .enumCaseElementList:
       return EnumCaseElementListSyntax.self
-    case .enumCaseElement: 
+    case .enumCaseElement:
       return EnumCaseElementSyntax.self
-    case .enumDecl: 
+    case .enumDecl:
       return EnumDeclSyntax.self
-    case .exposeAttributeArguments: 
+    case .exposeAttributeArguments:
       return ExposeAttributeArgumentsSyntax.self
-    case .exprList: 
+    case .exprList:
       return ExprListSyntax.self
-    case .expressionPattern: 
+    case .expressionPattern:
       return ExpressionPatternSyntax.self
-    case .expressionSegment: 
+    case .expressionSegment:
       return ExpressionSegmentSyntax.self
-    case .expressionStmt: 
+    case .expressionStmt:
       return ExpressionStmtSyntax.self
-    case .extensionDecl: 
+    case .extensionDecl:
       return ExtensionDeclSyntax.self
-    case .fallthroughStmt: 
+    case .fallthroughStmt:
       return FallthroughStmtSyntax.self
-    case .floatLiteralExpr: 
+    case .floatLiteralExpr:
       return FloatLiteralExprSyntax.self
-    case .forInStmt: 
+    case .forInStmt:
       return ForInStmtSyntax.self
-    case .forcedValueExpr: 
+    case .forcedValueExpr:
       return ForcedValueExprSyntax.self
-    case .functionCallExpr: 
+    case .functionCallExpr:
       return FunctionCallExprSyntax.self
-    case .functionDecl: 
+    case .functionDecl:
       return FunctionDeclSyntax.self
-    case .functionParameterList: 
+    case .functionParameterList:
       return FunctionParameterListSyntax.self
-    case .functionParameter: 
+    case .functionParameter:
       return FunctionParameterSyntax.self
-    case .functionSignature: 
+    case .functionSignature:
       return FunctionSignatureSyntax.self
-    case .functionType: 
+    case .functionType:
       return FunctionTypeSyntax.self
-    case .genericArgumentClause: 
+    case .genericArgumentClause:
       return GenericArgumentClauseSyntax.self
-    case .genericArgumentList: 
+    case .genericArgumentList:
       return GenericArgumentListSyntax.self
-    case .genericArgument: 
+    case .genericArgument:
       return GenericArgumentSyntax.self
-    case .genericParameterClause: 
+    case .genericParameterClause:
       return GenericParameterClauseSyntax.self
-    case .genericParameterList: 
+    case .genericParameterList:
       return GenericParameterListSyntax.self
-    case .genericParameter: 
+    case .genericParameter:
       return GenericParameterSyntax.self
-    case .genericRequirementList: 
+    case .genericRequirementList:
       return GenericRequirementListSyntax.self
-    case .genericRequirement: 
+    case .genericRequirement:
       return GenericRequirementSyntax.self
-    case .genericWhereClause: 
+    case .genericWhereClause:
       return GenericWhereClauseSyntax.self
-    case .guardStmt: 
+    case .guardStmt:
       return GuardStmtSyntax.self
-    case .identifierExpr: 
+    case .identifierExpr:
       return IdentifierExprSyntax.self
-    case .identifierPattern: 
+    case .identifierPattern:
       return IdentifierPatternSyntax.self
-    case .ifConfigClauseList: 
+    case .ifConfigClauseList:
       return IfConfigClauseListSyntax.self
-    case .ifConfigClause: 
+    case .ifConfigClause:
       return IfConfigClauseSyntax.self
-    case .ifConfigDecl: 
+    case .ifConfigDecl:
       return IfConfigDeclSyntax.self
-    case .ifExpr: 
+    case .ifExpr:
       return IfExprSyntax.self
-    case .implementsAttributeArguments: 
+    case .implementsAttributeArguments:
       return ImplementsAttributeArgumentsSyntax.self
-    case .implicitlyUnwrappedOptionalType: 
+    case .implicitlyUnwrappedOptionalType:
       return ImplicitlyUnwrappedOptionalTypeSyntax.self
-    case .importDecl: 
+    case .importDecl:
       return ImportDeclSyntax.self
-    case .inOutExpr: 
+    case .inOutExpr:
       return InOutExprSyntax.self
-    case .infixOperatorExpr: 
+    case .infixOperatorExpr:
       return InfixOperatorExprSyntax.self
-    case .inheritedTypeList: 
+    case .inheritedTypeList:
       return InheritedTypeListSyntax.self
-    case .inheritedType: 
+    case .inheritedType:
       return InheritedTypeSyntax.self
-    case .initializerClause: 
+    case .initializerClause:
       return InitializerClauseSyntax.self
-    case .initializerDecl: 
+    case .initializerDecl:
       return InitializerDeclSyntax.self
-    case .integerLiteralExpr: 
+    case .integerLiteralExpr:
       return IntegerLiteralExprSyntax.self
-    case .isExpr: 
+    case .isExpr:
       return IsExprSyntax.self
-    case .isTypePattern: 
+    case .isTypePattern:
       return IsTypePatternSyntax.self
-    case .keyPathComponentList: 
+    case .keyPathComponentList:
       return KeyPathComponentListSyntax.self
-    case .keyPathComponent: 
+    case .keyPathComponent:
       return KeyPathComponentSyntax.self
-    case .keyPathExpr: 
+    case .keyPathExpr:
       return KeyPathExprSyntax.self
-    case .keyPathOptionalComponent: 
+    case .keyPathOptionalComponent:
       return KeyPathOptionalComponentSyntax.self
-    case .keyPathPropertyComponent: 
+    case .keyPathPropertyComponent:
       return KeyPathPropertyComponentSyntax.self
-    case .keyPathSubscriptComponent: 
+    case .keyPathSubscriptComponent:
       return KeyPathSubscriptComponentSyntax.self
-    case .labeledSpecializeEntry: 
+    case .labeledSpecializeEntry:
       return LabeledSpecializeEntrySyntax.self
-    case .labeledStmt: 
+    case .labeledStmt:
       return LabeledStmtSyntax.self
-    case .layoutRequirement: 
+    case .layoutRequirement:
       return LayoutRequirementSyntax.self
-    case .macroDecl: 
+    case .macroDecl:
       return MacroDeclSyntax.self
-    case .macroExpansionDecl: 
+    case .macroExpansionDecl:
       return MacroExpansionDeclSyntax.self
-    case .macroExpansionExpr: 
+    case .macroExpansionExpr:
       return MacroExpansionExprSyntax.self
-    case .matchingPatternCondition: 
+    case .matchingPatternCondition:
       return MatchingPatternConditionSyntax.self
-    case .memberAccessExpr: 
+    case .memberAccessExpr:
       return MemberAccessExprSyntax.self
-    case .memberDeclBlock: 
+    case .memberDeclBlock:
       return MemberDeclBlockSyntax.self
-    case .memberDeclListItem: 
+    case .memberDeclListItem:
       return MemberDeclListItemSyntax.self
-    case .memberDeclList: 
+    case .memberDeclList:
       return MemberDeclListSyntax.self
-    case .memberTypeIdentifier: 
+    case .memberTypeIdentifier:
       return MemberTypeIdentifierSyntax.self
-    case .metatypeType: 
+    case .metatypeType:
       return MetatypeTypeSyntax.self
-    case .missingDecl: 
+    case .missingDecl:
       return MissingDeclSyntax.self
-    case .missingExpr: 
+    case .missingExpr:
       return MissingExprSyntax.self
-    case .missingPattern: 
+    case .missingPattern:
       return MissingPatternSyntax.self
-    case .missingStmt: 
+    case .missingStmt:
       return MissingStmtSyntax.self
-    case .missing: 
+    case .missing:
       return MissingSyntax.self
-    case .missingType: 
+    case .missingType:
       return MissingTypeSyntax.self
-    case .modifierList: 
+    case .modifierList:
       return ModifierListSyntax.self
-    case .moveExpr: 
+    case .moveExpr:
       return MoveExprSyntax.self
-    case .multipleTrailingClosureElementList: 
+    case .multipleTrailingClosureElementList:
       return MultipleTrailingClosureElementListSyntax.self
-    case .multipleTrailingClosureElement: 
+    case .multipleTrailingClosureElement:
       return MultipleTrailingClosureElementSyntax.self
-    case .namedOpaqueReturnType: 
+    case .namedOpaqueReturnType:
       return NamedOpaqueReturnTypeSyntax.self
-    case .nilLiteralExpr: 
+    case .nilLiteralExpr:
       return NilLiteralExprSyntax.self
-    case .objCSelectorPiece: 
+    case .objCSelectorPiece:
       return ObjCSelectorPieceSyntax.self
-    case .objCSelector: 
+    case .objCSelector:
       return ObjCSelectorSyntax.self
-    case .opaqueReturnTypeOfAttributeArguments: 
+    case .opaqueReturnTypeOfAttributeArguments:
       return OpaqueReturnTypeOfAttributeArgumentsSyntax.self
-    case .operatorDecl: 
+    case .operatorDecl:
       return OperatorDeclSyntax.self
-    case .operatorPrecedenceAndTypes: 
+    case .operatorPrecedenceAndTypes:
       return OperatorPrecedenceAndTypesSyntax.self
-    case .optionalBindingCondition: 
+    case .optionalBindingCondition:
       return OptionalBindingConditionSyntax.self
-    case .optionalChainingExpr: 
+    case .optionalChainingExpr:
       return OptionalChainingExprSyntax.self
-    case .optionalType: 
+    case .optionalType:
       return OptionalTypeSyntax.self
-    case .originallyDefinedInArguments: 
+    case .originallyDefinedInArguments:
       return OriginallyDefinedInArgumentsSyntax.self
-    case .packElementExpr: 
+    case .packElementExpr:
       return PackElementExprSyntax.self
-    case .packExpansionExpr: 
+    case .packExpansionExpr:
       return PackExpansionExprSyntax.self
-    case .packExpansionType: 
+    case .packExpansionType:
       return PackExpansionTypeSyntax.self
-    case .packReferenceType: 
+    case .packReferenceType:
       return PackReferenceTypeSyntax.self
-    case .parameterClause: 
+    case .parameterClause:
       return ParameterClauseSyntax.self
-    case .patternBindingList: 
+    case .patternBindingList:
       return PatternBindingListSyntax.self
-    case .patternBinding: 
+    case .patternBinding:
       return PatternBindingSyntax.self
-    case .postfixIfConfigExpr: 
+    case .postfixIfConfigExpr:
       return PostfixIfConfigExprSyntax.self
-    case .postfixUnaryExpr: 
+    case .postfixUnaryExpr:
       return PostfixUnaryExprSyntax.self
-    case .poundSourceLocationArgs: 
+    case .poundSourceLocationArgs:
       return PoundSourceLocationArgsSyntax.self
-    case .poundSourceLocation: 
+    case .poundSourceLocation:
       return PoundSourceLocationSyntax.self
-    case .precedenceGroupAssignment: 
+    case .precedenceGroupAssignment:
       return PrecedenceGroupAssignmentSyntax.self
-    case .precedenceGroupAssociativity: 
+    case .precedenceGroupAssociativity:
       return PrecedenceGroupAssociativitySyntax.self
-    case .precedenceGroupAttributeList: 
+    case .precedenceGroupAttributeList:
       return PrecedenceGroupAttributeListSyntax.self
-    case .precedenceGroupDecl: 
+    case .precedenceGroupDecl:
       return PrecedenceGroupDeclSyntax.self
-    case .precedenceGroupNameElement: 
+    case .precedenceGroupNameElement:
       return PrecedenceGroupNameElementSyntax.self
-    case .precedenceGroupNameList: 
+    case .precedenceGroupNameList:
       return PrecedenceGroupNameListSyntax.self
-    case .precedenceGroupRelation: 
+    case .precedenceGroupRelation:
       return PrecedenceGroupRelationSyntax.self
-    case .prefixOperatorExpr: 
+    case .prefixOperatorExpr:
       return PrefixOperatorExprSyntax.self
-    case .primaryAssociatedTypeClause: 
+    case .primaryAssociatedTypeClause:
       return PrimaryAssociatedTypeClauseSyntax.self
-    case .primaryAssociatedTypeList: 
+    case .primaryAssociatedTypeList:
       return PrimaryAssociatedTypeListSyntax.self
-    case .primaryAssociatedType: 
+    case .primaryAssociatedType:
       return PrimaryAssociatedTypeSyntax.self
-    case .protocolDecl: 
+    case .protocolDecl:
       return ProtocolDeclSyntax.self
-    case .qualifiedDeclName: 
+    case .qualifiedDeclName:
       return QualifiedDeclNameSyntax.self
-    case .regexLiteralExpr: 
+    case .regexLiteralExpr:
       return RegexLiteralExprSyntax.self
-    case .repeatWhileStmt: 
+    case .repeatWhileStmt:
       return RepeatWhileStmtSyntax.self
-    case .returnClause: 
+    case .returnClause:
       return ReturnClauseSyntax.self
-    case .returnStmt: 
+    case .returnStmt:
       return ReturnStmtSyntax.self
-    case .sameTypeRequirement: 
+    case .sameTypeRequirement:
       return SameTypeRequirementSyntax.self
-    case .sequenceExpr: 
+    case .sequenceExpr:
       return SequenceExprSyntax.self
-    case .simpleTypeIdentifier: 
+    case .simpleTypeIdentifier:
       return SimpleTypeIdentifierSyntax.self
-    case .sourceFile: 
+    case .sourceFile:
       return SourceFileSyntax.self
-    case .specializeAttributeSpecList: 
+    case .specializeAttributeSpecList:
       return SpecializeAttributeSpecListSyntax.self
-    case .specializeExpr: 
+    case .specializeExpr:
       return SpecializeExprSyntax.self
-    case .stringLiteralExpr: 
+    case .stringLiteralExpr:
       return StringLiteralExprSyntax.self
-    case .stringLiteralSegments: 
+    case .stringLiteralSegments:
       return StringLiteralSegmentsSyntax.self
-    case .stringSegment: 
+    case .stringSegment:
       return StringSegmentSyntax.self
-    case .structDecl: 
+    case .structDecl:
       return StructDeclSyntax.self
-    case .subscriptDecl: 
+    case .subscriptDecl:
       return SubscriptDeclSyntax.self
-    case .subscriptExpr: 
+    case .subscriptExpr:
       return SubscriptExprSyntax.self
-    case .superRefExpr: 
+    case .superRefExpr:
       return SuperRefExprSyntax.self
-    case .switchCaseLabel: 
+    case .switchCaseLabel:
       return SwitchCaseLabelSyntax.self
-    case .switchCaseList: 
+    case .switchCaseList:
       return SwitchCaseListSyntax.self
-    case .switchCase: 
+    case .switchCase:
       return SwitchCaseSyntax.self
-    case .switchDefaultLabel: 
+    case .switchDefaultLabel:
       return SwitchDefaultLabelSyntax.self
-    case .switchExpr: 
+    case .switchExpr:
       return SwitchExprSyntax.self
-    case .targetFunctionEntry: 
+    case .targetFunctionEntry:
       return TargetFunctionEntrySyntax.self
-    case .ternaryExpr: 
+    case .ternaryExpr:
       return TernaryExprSyntax.self
-    case .throwStmt: 
+    case .throwStmt:
       return ThrowStmtSyntax.self
-    case .tryExpr: 
+    case .tryExpr:
       return TryExprSyntax.self
-    case .tupleExprElementList: 
+    case .tupleExprElementList:
       return TupleExprElementListSyntax.self
-    case .tupleExprElement: 
+    case .tupleExprElement:
       return TupleExprElementSyntax.self
-    case .tupleExpr: 
+    case .tupleExpr:
       return TupleExprSyntax.self
-    case .tuplePatternElementList: 
+    case .tuplePatternElementList:
       return TuplePatternElementListSyntax.self
-    case .tuplePatternElement: 
+    case .tuplePatternElement:
       return TuplePatternElementSyntax.self
-    case .tuplePattern: 
+    case .tuplePattern:
       return TuplePatternSyntax.self
-    case .tupleTypeElementList: 
+    case .tupleTypeElementList:
       return TupleTypeElementListSyntax.self
-    case .tupleTypeElement: 
+    case .tupleTypeElement:
       return TupleTypeElementSyntax.self
-    case .tupleType: 
+    case .tupleType:
       return TupleTypeSyntax.self
-    case .typeAnnotation: 
+    case .typeAnnotation:
       return TypeAnnotationSyntax.self
-    case .typeEffectSpecifiers: 
+    case .typeEffectSpecifiers:
       return TypeEffectSpecifiersSyntax.self
-    case .typeExpr: 
+    case .typeExpr:
       return TypeExprSyntax.self
-    case .typeInheritanceClause: 
+    case .typeInheritanceClause:
       return TypeInheritanceClauseSyntax.self
-    case .typeInitializerClause: 
+    case .typeInitializerClause:
       return TypeInitializerClauseSyntax.self
-    case .typealiasDecl: 
+    case .typealiasDecl:
       return TypealiasDeclSyntax.self
-    case .unavailableFromAsyncArguments: 
+    case .unavailableFromAsyncArguments:
       return UnavailableFromAsyncArgumentsSyntax.self
-    case .underscorePrivateAttributeArguments: 
+    case .underscorePrivateAttributeArguments:
       return UnderscorePrivateAttributeArgumentsSyntax.self
-    case .unexpectedNodes: 
+    case .unexpectedNodes:
       return UnexpectedNodesSyntax.self
-    case .unresolvedAsExpr: 
+    case .unresolvedAsExpr:
       return UnresolvedAsExprSyntax.self
-    case .unresolvedIsExpr: 
+    case .unresolvedIsExpr:
       return UnresolvedIsExprSyntax.self
-    case .unresolvedPatternExpr: 
+    case .unresolvedPatternExpr:
       return UnresolvedPatternExprSyntax.self
-    case .unresolvedTernaryExpr: 
+    case .unresolvedTernaryExpr:
       return UnresolvedTernaryExprSyntax.self
-    case .valueBindingPattern: 
+    case .valueBindingPattern:
       return ValueBindingPatternSyntax.self
-    case .variableDecl: 
+    case .variableDecl:
       return VariableDeclSyntax.self
-    case .versionTuple: 
+    case .versionTuple:
       return VersionTupleSyntax.self
-    case .whereClause: 
+    case .whereClause:
       return WhereClauseSyntax.self
-    case .whileStmt: 
+    case .whileStmt:
       return WhileStmtSyntax.self
-    case .wildcardPattern: 
+    case .wildcardPattern:
       return WildcardPatternSyntax.self
-    case .yieldExprListElement: 
+    case .yieldExprListElement:
       return YieldExprListElementSyntax.self
-    case .yieldExprList: 
+    case .yieldExprList:
       return YieldExprListSyntax.self
-    case .yieldList: 
+    case .yieldList:
       return YieldListSyntax.self
-    case .yieldStmt: 
+    case .yieldStmt:
       return YieldStmtSyntax.self
     }
   }
   
   public var nameForDiagnostics: String? {
     switch self {
-    case .token: 
+    case .token:
       return "token"
-    case .accessPathComponent: 
+    case .accessPathComponent:
       return nil
-    case .accessPath: 
+    case .accessPath:
       return nil
-    case .accessorBlock: 
+    case .accessorBlock:
       return nil
-    case .accessorDecl: 
+    case .accessorDecl:
       return "accessor"
-    case .accessorList: 
+    case .accessorList:
       return nil
-    case .accessorParameter: 
+    case .accessorParameter:
       return nil
-    case .actorDecl: 
+    case .actorDecl:
       return "actor"
-    case .arrayElementList: 
+    case .arrayElementList:
       return nil
-    case .arrayElement: 
+    case .arrayElement:
       return "array element"
-    case .arrayExpr: 
+    case .arrayExpr:
       return "array"
-    case .arrayType: 
+    case .arrayType:
       return "array type"
-    case .arrowExpr: 
+    case .arrowExpr:
       return nil
-    case .asExpr: 
+    case .asExpr:
       return "'as'"
-    case .assignmentExpr: 
+    case .assignmentExpr:
       return nil
-    case .associatedtypeDecl: 
+    case .associatedtypeDecl:
       return "associatedtype declaration"
-    case .attributeList: 
+    case .attributeList:
       return "attributes"
-    case .attribute: 
+    case .attribute:
       return "attribute"
-    case .attributedType: 
+    case .attributedType:
       return "type"
-    case .availabilityArgument: 
+    case .availabilityArgument:
       return "availability argument"
-    case .availabilityCondition: 
+    case .availabilityCondition:
       return "availability condition"
-    case .availabilityEntry: 
+    case .availabilityEntry:
       return "availability entry"
-    case .availabilityLabeledArgument: 
+    case .availabilityLabeledArgument:
       return "availability argument"
-    case .availabilitySpecList: 
+    case .availabilitySpecList:
       return "'@availability' arguments"
-    case .availabilityVersionRestrictionListEntry: 
+    case .availabilityVersionRestrictionListEntry:
       return "version"
-    case .availabilityVersionRestrictionList: 
+    case .availabilityVersionRestrictionList:
       return "version list"
-    case .availabilityVersionRestriction: 
+    case .availabilityVersionRestriction:
       return "version restriction"
-    case .awaitExpr: 
+    case .awaitExpr:
       return "'await' expression"
-    case .backDeployedAttributeSpecList: 
+    case .backDeployedAttributeSpecList:
       return "'@backDeployed' arguments"
-    case .binaryOperatorExpr: 
+    case .binaryOperatorExpr:
       return "operator"
-    case .booleanLiteralExpr: 
+    case .booleanLiteralExpr:
       return "bool literal"
-    case .borrowExpr: 
+    case .borrowExpr:
       return "'_borrow' expression"
-    case .breakStmt: 
+    case .breakStmt:
       return "'break' statement"
-    case .caseItemList: 
+    case .caseItemList:
       return nil
-    case .caseItem: 
+    case .caseItem:
       return nil
-    case .catchClauseList: 
+    case .catchClauseList:
       return "'catch' clause"
-    case .catchClause: 
+    case .catchClause:
       return "'catch' clause"
-    case .catchItemList: 
+    case .catchItemList:
       return nil
-    case .catchItem: 
+    case .catchItem:
       return nil
-    case .classDecl: 
+    case .classDecl:
       return "class"
-    case .classRestrictionType: 
+    case .classRestrictionType:
       return nil
-    case .closureCaptureItemList: 
+    case .closureCaptureItemList:
       return nil
-    case .closureCaptureItemSpecifier: 
+    case .closureCaptureItemSpecifier:
       return "closure capture specifier"
-    case .closureCaptureItem: 
+    case .closureCaptureItem:
       return "closure capture item"
-    case .closureCaptureSignature: 
+    case .closureCaptureSignature:
       return "closure capture signature"
-    case .closureExpr: 
+    case .closureExpr:
       return "closure"
-    case .closureParamList: 
+    case .closureParamList:
       return nil
-    case .closureParam: 
+    case .closureParam:
       return "closure parameter"
-    case .closureSignature: 
+    case .closureSignature:
       return "closure signature"
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       return nil
-    case .codeBlockItem: 
+    case .codeBlockItem:
       return nil
-    case .codeBlock: 
+    case .codeBlock:
       return "code block"
-    case .compositionTypeElementList: 
+    case .compositionTypeElementList:
       return nil
-    case .compositionTypeElement: 
+    case .compositionTypeElement:
       return nil
-    case .compositionType: 
+    case .compositionType:
       return "type composition"
-    case .conditionElementList: 
+    case .conditionElementList:
       return nil
-    case .conditionElement: 
+    case .conditionElement:
       return nil
-    case .conformanceRequirement: 
+    case .conformanceRequirement:
       return "conformance requirement"
-    case .constrainedSugarType: 
+    case .constrainedSugarType:
       return "type"
-    case .continueStmt: 
+    case .continueStmt:
       return "'continue' statement"
-    case .conventionAttributeArguments: 
+    case .conventionAttributeArguments:
       return "@convention(...) arguments"
-    case .conventionWitnessMethodAttributeArguments: 
+    case .conventionWitnessMethodAttributeArguments:
       return "@convention(...) arguments for witness methods"
-    case .declEffectSpecifiers: 
+    case .declEffectSpecifiers:
       return "effect specifiers"
-    case .declModifierDetail: 
+    case .declModifierDetail:
       return nil
-    case .declModifier: 
+    case .declModifier:
       return "modifier"
-    case .declNameArgumentList: 
+    case .declNameArgumentList:
       return nil
-    case .declNameArgument: 
+    case .declNameArgument:
       return nil
-    case .declNameArguments: 
+    case .declNameArguments:
       return nil
-    case .declName: 
+    case .declName:
       return "declaration name"
-    case .deferStmt: 
+    case .deferStmt:
       return "'defer' statement"
-    case .deinitializerDecl: 
+    case .deinitializerDecl:
       return "deinitializer"
-    case .derivativeRegistrationAttributeArguments: 
+    case .derivativeRegistrationAttributeArguments:
       return "attribute arguments"
-    case .designatedTypeElement: 
+    case .designatedTypeElement:
       return nil
-    case .designatedTypeList: 
+    case .designatedTypeList:
       return nil
-    case .dictionaryElementList: 
+    case .dictionaryElementList:
       return nil
-    case .dictionaryElement: 
+    case .dictionaryElement:
       return "dictionary element"
-    case .dictionaryExpr: 
+    case .dictionaryExpr:
       return "dictionary"
-    case .dictionaryType: 
+    case .dictionaryType:
       return "dictionary type"
-    case .differentiabilityParamList: 
+    case .differentiabilityParamList:
       return "differentiability parameters"
-    case .differentiabilityParam: 
+    case .differentiabilityParam:
       return "differentiability parameter"
-    case .differentiabilityParamsClause: 
+    case .differentiabilityParamsClause:
       return "'@differentiable' argument"
-    case .differentiabilityParams: 
+    case .differentiabilityParams:
       return "differentiability parameters"
-    case .differentiableAttributeArguments: 
+    case .differentiableAttributeArguments:
       return "'@differentiable' arguments"
-    case .discardAssignmentExpr: 
+    case .discardAssignmentExpr:
       return nil
-    case .doStmt: 
+    case .doStmt:
       return "'do' statement"
-    case .documentationAttributeArgument: 
+    case .documentationAttributeArgument:
       return "@_documentation argument"
-    case .documentationAttributeArguments: 
+    case .documentationAttributeArguments:
       return "@_documentation arguments"
-    case .dynamicReplacementArguments: 
+    case .dynamicReplacementArguments:
       return "@_dynamicReplacement argument"
-    case .editorPlaceholderDecl: 
+    case .editorPlaceholderDecl:
       return "editor placeholder"
-    case .editorPlaceholderExpr: 
+    case .editorPlaceholderExpr:
       return "editor placeholder"
-    case .effectsArguments: 
+    case .effectsArguments:
       return "@_effects arguments"
-    case .enumCaseDecl: 
+    case .enumCaseDecl:
       return "enum case"
-    case .enumCaseElementList: 
+    case .enumCaseElementList:
       return nil
-    case .enumCaseElement: 
+    case .enumCaseElement:
       return nil
-    case .enumDecl: 
+    case .enumDecl:
       return "enum"
-    case .exposeAttributeArguments: 
+    case .exposeAttributeArguments:
       return "@_expose arguments"
-    case .exprList: 
+    case .exprList:
       return nil
-    case .expressionPattern: 
+    case .expressionPattern:
       return "pattern"
-    case .expressionSegment: 
+    case .expressionSegment:
       return nil
-    case .expressionStmt: 
+    case .expressionStmt:
       return "expression"
-    case .extensionDecl: 
+    case .extensionDecl:
       return "extension"
-    case .fallthroughStmt: 
+    case .fallthroughStmt:
       return "'fallthrough' statement"
-    case .floatLiteralExpr: 
+    case .floatLiteralExpr:
       return "floating literal"
-    case .forInStmt: 
+    case .forInStmt:
       return "'for' statement"
-    case .forcedValueExpr: 
+    case .forcedValueExpr:
       return "force unwrap"
-    case .functionCallExpr: 
+    case .functionCallExpr:
       return "function call"
-    case .functionDecl: 
+    case .functionDecl:
       return "function"
-    case .functionParameterList: 
+    case .functionParameterList:
       return "parameter list"
-    case .functionParameter: 
+    case .functionParameter:
       return "parameter"
-    case .functionSignature: 
+    case .functionSignature:
       return "function signature"
-    case .functionType: 
+    case .functionType:
       return "function type"
-    case .genericArgumentClause: 
+    case .genericArgumentClause:
       return "generic argument clause"
-    case .genericArgumentList: 
+    case .genericArgumentList:
       return nil
-    case .genericArgument: 
+    case .genericArgument:
       return "generic argument"
-    case .genericParameterClause: 
+    case .genericParameterClause:
       return "generic parameter clause"
-    case .genericParameterList: 
+    case .genericParameterList:
       return nil
-    case .genericParameter: 
+    case .genericParameter:
       return "generic parameter"
-    case .genericRequirementList: 
+    case .genericRequirementList:
       return nil
-    case .genericRequirement: 
+    case .genericRequirement:
       return nil
-    case .genericWhereClause: 
+    case .genericWhereClause:
       return "'where' clause"
-    case .guardStmt: 
+    case .guardStmt:
       return "'guard' statement"
-    case .identifierExpr: 
+    case .identifierExpr:
       return nil
-    case .identifierPattern: 
+    case .identifierPattern:
       return "pattern"
-    case .ifConfigClauseList: 
+    case .ifConfigClauseList:
       return nil
-    case .ifConfigClause: 
+    case .ifConfigClause:
       return "conditional compilation clause"
-    case .ifConfigDecl: 
+    case .ifConfigDecl:
       return "conditional compilation block"
-    case .ifExpr: 
+    case .ifExpr:
       return "'if' statement"
-    case .implementsAttributeArguments: 
+    case .implementsAttributeArguments:
       return "@_implements arguemnts"
-    case .implicitlyUnwrappedOptionalType: 
+    case .implicitlyUnwrappedOptionalType:
       return "implicitly unwrapped optional type"
-    case .importDecl: 
+    case .importDecl:
       return "import"
-    case .inOutExpr: 
+    case .inOutExpr:
       return "inout expression"
-    case .infixOperatorExpr: 
+    case .infixOperatorExpr:
       return nil
-    case .inheritedTypeList: 
+    case .inheritedTypeList:
       return nil
-    case .inheritedType: 
+    case .inheritedType:
       return "inherited type"
-    case .initializerClause: 
+    case .initializerClause:
       return nil
-    case .initializerDecl: 
+    case .initializerDecl:
       return "initializer"
-    case .integerLiteralExpr: 
+    case .integerLiteralExpr:
       return "integer literal"
-    case .isExpr: 
+    case .isExpr:
       return "'is'"
-    case .isTypePattern: 
+    case .isTypePattern:
       return "'is' pattern"
-    case .keyPathComponentList: 
+    case .keyPathComponentList:
       return nil
-    case .keyPathComponent: 
+    case .keyPathComponent:
       return "key path component"
-    case .keyPathExpr: 
+    case .keyPathExpr:
       return "key path"
-    case .keyPathOptionalComponent: 
+    case .keyPathOptionalComponent:
       return "key path optional component"
-    case .keyPathPropertyComponent: 
+    case .keyPathPropertyComponent:
       return "key path property component"
-    case .keyPathSubscriptComponent: 
+    case .keyPathSubscriptComponent:
       return "key path subscript component"
-    case .labeledSpecializeEntry: 
+    case .labeledSpecializeEntry:
       return "attribute argument"
-    case .labeledStmt: 
+    case .labeledStmt:
       return "labeled statement"
-    case .layoutRequirement: 
+    case .layoutRequirement:
       return "layout requirement"
-    case .macroDecl: 
+    case .macroDecl:
       return "macro"
-    case .macroExpansionDecl: 
+    case .macroExpansionDecl:
       return "macro expansion"
-    case .macroExpansionExpr: 
+    case .macroExpansionExpr:
       return "macro expansion"
-    case .matchingPatternCondition: 
+    case .matchingPatternCondition:
       return "pattern matching"
-    case .memberAccessExpr: 
+    case .memberAccessExpr:
       return "member access"
-    case .memberDeclBlock: 
+    case .memberDeclBlock:
       return "member block"
-    case .memberDeclListItem: 
+    case .memberDeclListItem:
       return nil
-    case .memberDeclList: 
+    case .memberDeclList:
       return nil
-    case .memberTypeIdentifier: 
+    case .memberTypeIdentifier:
       return "member type"
-    case .metatypeType: 
+    case .metatypeType:
       return "metatype"
-    case .missingDecl: 
+    case .missingDecl:
       return "declaration"
-    case .missingExpr: 
+    case .missingExpr:
       return "expression"
-    case .missingPattern: 
+    case .missingPattern:
       return "pattern"
-    case .missingStmt: 
+    case .missingStmt:
       return "statement"
-    case .missing: 
+    case .missing:
       return nil
-    case .missingType: 
+    case .missingType:
       return "type"
-    case .modifierList: 
+    case .modifierList:
       return nil
-    case .moveExpr: 
+    case .moveExpr:
       return "'_move' expression"
-    case .multipleTrailingClosureElementList: 
+    case .multipleTrailingClosureElementList:
       return nil
-    case .multipleTrailingClosureElement: 
+    case .multipleTrailingClosureElement:
       return "trailing closure"
-    case .namedOpaqueReturnType: 
+    case .namedOpaqueReturnType:
       return "named opaque return type"
-    case .nilLiteralExpr: 
+    case .nilLiteralExpr:
       return nil
-    case .objCSelectorPiece: 
+    case .objCSelectorPiece:
       return "Objective-C selector piece"
-    case .objCSelector: 
+    case .objCSelector:
       return "Objective-C selector"
-    case .opaqueReturnTypeOfAttributeArguments: 
+    case .opaqueReturnTypeOfAttributeArguments:
       return "opaque return type arguments"
-    case .operatorDecl: 
+    case .operatorDecl:
       return "operator declaration"
-    case .operatorPrecedenceAndTypes: 
+    case .operatorPrecedenceAndTypes:
       return nil
-    case .optionalBindingCondition: 
+    case .optionalBindingCondition:
       return "optional binding"
-    case .optionalChainingExpr: 
+    case .optionalChainingExpr:
       return "optional chaining"
-    case .optionalType: 
+    case .optionalType:
       return "optional type"
-    case .originallyDefinedInArguments: 
+    case .originallyDefinedInArguments:
       return "@_originallyDefinedIn arguments"
-    case .packElementExpr: 
+    case .packElementExpr:
       return nil
-    case .packExpansionExpr: 
+    case .packExpansionExpr:
       return nil
-    case .packExpansionType: 
+    case .packExpansionType:
       return "variadic expansion"
-    case .packReferenceType: 
+    case .packReferenceType:
       return "pack reference"
-    case .parameterClause: 
+    case .parameterClause:
       return "parameter clause"
-    case .patternBindingList: 
+    case .patternBindingList:
       return nil
-    case .patternBinding: 
+    case .patternBinding:
       return nil
-    case .postfixIfConfigExpr: 
+    case .postfixIfConfigExpr:
       return nil
-    case .postfixUnaryExpr: 
+    case .postfixUnaryExpr:
       return "postfix expression"
-    case .poundSourceLocationArgs: 
+    case .poundSourceLocationArgs:
       return "'#sourceLocation' arguments"
-    case .poundSourceLocation: 
+    case .poundSourceLocation:
       return "'#sourceLocation' directive"
-    case .precedenceGroupAssignment: 
+    case .precedenceGroupAssignment:
       return "'assignment' property of precedencegroup"
-    case .precedenceGroupAssociativity: 
+    case .precedenceGroupAssociativity:
       return "'associativity' property of precedencegroup"
-    case .precedenceGroupAttributeList: 
+    case .precedenceGroupAttributeList:
       return nil
-    case .precedenceGroupDecl: 
+    case .precedenceGroupDecl:
       return "precedencegroup"
-    case .precedenceGroupNameElement: 
+    case .precedenceGroupNameElement:
       return nil
-    case .precedenceGroupNameList: 
+    case .precedenceGroupNameList:
       return nil
-    case .precedenceGroupRelation: 
+    case .precedenceGroupRelation:
       return "'relation' property of precedencegroup"
-    case .prefixOperatorExpr: 
+    case .prefixOperatorExpr:
       return "operator"
-    case .primaryAssociatedTypeClause: 
+    case .primaryAssociatedTypeClause:
       return "primary associated type clause"
-    case .primaryAssociatedTypeList: 
+    case .primaryAssociatedTypeList:
       return nil
-    case .primaryAssociatedType: 
+    case .primaryAssociatedType:
       return nil
-    case .protocolDecl: 
+    case .protocolDecl:
       return "protocol"
-    case .qualifiedDeclName: 
+    case .qualifiedDeclName:
       return "declaration name"
-    case .regexLiteralExpr: 
+    case .regexLiteralExpr:
       return "regex literal"
-    case .repeatWhileStmt: 
+    case .repeatWhileStmt:
       return "'repeat' statement"
-    case .returnClause: 
+    case .returnClause:
       return nil
-    case .returnStmt: 
+    case .returnStmt:
       return "'return' statement"
-    case .sameTypeRequirement: 
+    case .sameTypeRequirement:
       return "same type requirement"
-    case .sequenceExpr: 
+    case .sequenceExpr:
       return nil
-    case .simpleTypeIdentifier: 
+    case .simpleTypeIdentifier:
       return "type"
-    case .sourceFile: 
+    case .sourceFile:
       return "source file"
-    case .specializeAttributeSpecList: 
+    case .specializeAttributeSpecList:
       return "argument to '@_specialize"
-    case .specializeExpr: 
+    case .specializeExpr:
       return nil
-    case .stringLiteralExpr: 
+    case .stringLiteralExpr:
       return "string literal"
-    case .stringLiteralSegments: 
+    case .stringLiteralSegments:
       return nil
-    case .stringSegment: 
+    case .stringSegment:
       return nil
-    case .structDecl: 
+    case .structDecl:
       return "struct"
-    case .subscriptDecl: 
+    case .subscriptDecl:
       return "subscript"
-    case .subscriptExpr: 
+    case .subscriptExpr:
       return "subscript"
-    case .superRefExpr: 
+    case .superRefExpr:
       return nil
-    case .switchCaseLabel: 
+    case .switchCaseLabel:
       return nil
-    case .switchCaseList: 
+    case .switchCaseList:
       return nil
-    case .switchCase: 
+    case .switchCase:
       return "switch case"
-    case .switchDefaultLabel: 
+    case .switchDefaultLabel:
       return nil
-    case .switchExpr: 
+    case .switchExpr:
       return "'switch' statement"
-    case .targetFunctionEntry: 
+    case .targetFunctionEntry:
       return "attribute argument"
-    case .ternaryExpr: 
+    case .ternaryExpr:
       return "ternay expression"
-    case .throwStmt: 
+    case .throwStmt:
       return "'throw' statement"
-    case .tryExpr: 
+    case .tryExpr:
       return "'try' expression"
-    case .tupleExprElementList: 
+    case .tupleExprElementList:
       return nil
-    case .tupleExprElement: 
+    case .tupleExprElement:
       return nil
-    case .tupleExpr: 
+    case .tupleExpr:
       return "tuple"
-    case .tuplePatternElementList: 
+    case .tuplePatternElementList:
       return nil
-    case .tuplePatternElement: 
+    case .tuplePatternElement:
       return nil
-    case .tuplePattern: 
+    case .tuplePattern:
       return "tuple pattern"
-    case .tupleTypeElementList: 
+    case .tupleTypeElementList:
       return nil
-    case .tupleTypeElement: 
+    case .tupleTypeElement:
       return nil
-    case .tupleType: 
+    case .tupleType:
       return "tuple type"
-    case .typeAnnotation: 
+    case .typeAnnotation:
       return "type annotation"
-    case .typeEffectSpecifiers: 
+    case .typeEffectSpecifiers:
       return "effect specifiers"
-    case .typeExpr: 
+    case .typeExpr:
       return nil
-    case .typeInheritanceClause: 
+    case .typeInheritanceClause:
       return "inheritance clause"
-    case .typeInitializerClause: 
+    case .typeInitializerClause:
       return nil
-    case .typealiasDecl: 
+    case .typealiasDecl:
       return "typealias declaration"
-    case .unavailableFromAsyncArguments: 
+    case .unavailableFromAsyncArguments:
       return "@_unavailableFromAsync argument"
-    case .underscorePrivateAttributeArguments: 
+    case .underscorePrivateAttributeArguments:
       return "@_private argument"
-    case .unexpectedNodes: 
+    case .unexpectedNodes:
       return nil
-    case .unresolvedAsExpr: 
+    case .unresolvedAsExpr:
       return "'as'"
-    case .unresolvedIsExpr: 
+    case .unresolvedIsExpr:
       return "'is'"
-    case .unresolvedPatternExpr: 
+    case .unresolvedPatternExpr:
       return nil
-    case .unresolvedTernaryExpr: 
+    case .unresolvedTernaryExpr:
       return "ternary operator"
-    case .valueBindingPattern: 
+    case .valueBindingPattern:
       return "value binding pattern"
-    case .variableDecl: 
+    case .variableDecl:
       return "variable"
-    case .versionTuple: 
+    case .versionTuple:
       return "version tuple"
-    case .whereClause: 
+    case .whereClause:
       return "'where' clause"
-    case .whileStmt: 
+    case .whileStmt:
       return "'while' statement"
-    case .wildcardPattern: 
+    case .wildcardPattern:
       return "wildcard pattern"
-    case .yieldExprListElement: 
+    case .yieldExprListElement:
       return nil
-    case .yieldExprList: 
+    case .yieldExprList:
       return "yield list"
-    case .yieldList: 
+    case .yieldList:
       return nil
-    case .yieldStmt: 
+    case .yieldStmt:
       return "'yield' statement"
     }
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
index 20e5e55f366..45c52b863b5 100644
--- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
@@ -73,9 +73,9 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .accessorDecl, .actorDecl, .associatedtypeDecl, .classDecl, .deinitializerDecl, .editorPlaceholderDecl, .enumCaseDecl, .enumDecl, .extensionDecl, .functionDecl, .ifConfigDecl, .importDecl, .initializerDecl, .macroDecl, .macroExpansionDecl, .missingDecl, .operatorDecl, .poundSourceLocation, .precedenceGroupDecl, .protocolDecl, .structDecl, .subscriptDecl, .typealiasDecl, .variableDecl: 
+    case .accessorDecl, .actorDecl, .associatedtypeDecl, .classDecl, .deinitializerDecl, .editorPlaceholderDecl, .enumCaseDecl, .enumDecl, .extensionDecl, .functionDecl, .ifConfigDecl, .importDecl, .initializerDecl, .macroDecl, .macroExpansionDecl, .missingDecl, .operatorDecl, .poundSourceLocation, .precedenceGroupDecl, .protocolDecl, .structDecl, .subscriptDecl, .typealiasDecl, .variableDecl:
       self._syntaxNode = node._syntaxNode
-    default: 
+    default:
       return nil
     }
   }
@@ -86,9 +86,9 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   internal init(_ data: SyntaxData) {
     #if DEBUG
     switch data.raw.kind {
-    case .accessorDecl, .actorDecl, .associatedtypeDecl, .classDecl, .deinitializerDecl, .editorPlaceholderDecl, .enumCaseDecl, .enumDecl, .extensionDecl, .functionDecl, .ifConfigDecl, .importDecl, .initializerDecl, .macroDecl, .macroExpansionDecl, .missingDecl, .operatorDecl, .poundSourceLocation, .precedenceGroupDecl, .protocolDecl, .structDecl, .subscriptDecl, .typealiasDecl, .variableDecl: 
-      break 
-    default: 
+    case .accessorDecl, .actorDecl, .associatedtypeDecl, .classDecl, .deinitializerDecl, .editorPlaceholderDecl, .enumCaseDecl, .enumDecl, .extensionDecl, .functionDecl, .ifConfigDecl, .importDecl, .initializerDecl, .macroDecl, .macroExpansionDecl, .missingDecl, .operatorDecl, .poundSourceLocation, .precedenceGroupDecl, .protocolDecl, .structDecl, .subscriptDecl, .typealiasDecl, .variableDecl:
+      break
+    default:
       fatalError("Unable to create DeclSyntax from \(data.raw.kind)")
     }#endif 
     self._syntaxNode = Syntax(data)
@@ -221,9 +221,9 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: 
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr:
       self._syntaxNode = node._syntaxNode
-    default: 
+    default:
       return nil
     }
   }
@@ -234,9 +234,9 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   internal init(_ data: SyntaxData) {
     #if DEBUG
     switch data.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: 
-      break 
-    default: 
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr:
+      break
+    default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")
     }#endif 
     self._syntaxNode = Syntax(data)
@@ -393,9 +393,9 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .expressionPattern, .identifierPattern, .isTypePattern, .missingPattern, .tuplePattern, .valueBindingPattern, .wildcardPattern: 
+    case .expressionPattern, .identifierPattern, .isTypePattern, .missingPattern, .tuplePattern, .valueBindingPattern, .wildcardPattern:
       self._syntaxNode = node._syntaxNode
-    default: 
+    default:
       return nil
     }
   }
@@ -406,9 +406,9 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   internal init(_ data: SyntaxData) {
     #if DEBUG
     switch data.raw.kind {
-    case .expressionPattern, .identifierPattern, .isTypePattern, .missingPattern, .tuplePattern, .valueBindingPattern, .wildcardPattern: 
-      break 
-    default: 
+    case .expressionPattern, .identifierPattern, .isTypePattern, .missingPattern, .tuplePattern, .valueBindingPattern, .wildcardPattern:
+      break
+    default:
       fatalError("Unable to create PatternSyntax from \(data.raw.kind)")
     }#endif 
     self._syntaxNode = Syntax(data)
@@ -524,9 +524,9 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: 
+    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
       self._syntaxNode = node._syntaxNode
-    default: 
+    default:
       return nil
     }
   }
@@ -537,9 +537,9 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   internal init(_ data: SyntaxData) {
     #if DEBUG
     switch data.raw.kind {
-    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: 
-      break 
-    default: 
+    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
+      break
+    default:
       fatalError("Unable to create StmtSyntax from \(data.raw.kind)")
     }#endif 
     self._syntaxNode = Syntax(data)
@@ -663,9 +663,9 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType: 
+    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType:
       self._syntaxNode = node._syntaxNode
-    default: 
+    default:
       return nil
     }
   }
@@ -676,9 +676,9 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   internal init(_ data: SyntaxData) {
     #if DEBUG
     switch data.raw.kind {
-    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType: 
-      break 
-    default: 
+    case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType:
+      break
+    default:
       fatalError("Unable to create TypeSyntax from \(data.raw.kind)")
     }#endif 
     self._syntaxNode = Syntax(data)
diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift
index 1870f109bb7..154b34659a1 100644
--- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift
@@ -685,9 +685,9 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .attribute(let node): 
+      case .attribute(let node):
         return node._syntaxNode
-      case .ifConfigDecl(let node): 
+      case .ifConfigDecl(let node):
         return node._syntaxNode
       }
     }
@@ -7384,11 +7384,11 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .precedenceGroupRelation(let node): 
+      case .precedenceGroupRelation(let node):
         return node._syntaxNode
-      case .precedenceGroupAssignment(let node): 
+      case .precedenceGroupAssignment(let node):
         return node._syntaxNode
-      case .precedenceGroupAssociativity(let node): 
+      case .precedenceGroupAssociativity(let node):
         return node._syntaxNode
       }
     }
@@ -8085,13 +8085,13 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .labeledSpecializeEntry(let node): 
+      case .labeledSpecializeEntry(let node):
         return node._syntaxNode
-      case .availabilityEntry(let node): 
+      case .availabilityEntry(let node):
         return node._syntaxNode
-      case .targetFunctionEntry(let node): 
+      case .targetFunctionEntry(let node):
         return node._syntaxNode
-      case .genericWhereClause(let node): 
+      case .genericWhereClause(let node):
         return node._syntaxNode
       }
     }
@@ -8367,9 +8367,9 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .stringSegment(let node): 
+      case .stringSegment(let node):
         return node._syntaxNode
-      case .expressionSegment(let node): 
+      case .expressionSegment(let node):
         return node._syntaxNode
       }
     }
@@ -8626,9 +8626,9 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .switchCase(let node): 
+      case .switchCase(let node):
         return node._syntaxNode
-      case .ifConfigDecl(let node): 
+      case .ifConfigDecl(let node):
         return node._syntaxNode
       }
     }
diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
index c2e888cf09a..e1f3088ea7e 100644
--- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
@@ -544,527 +544,527 @@ public extension Syntax {
   /// Get an enum that can be used to exhaustively switch over all syntax nodes.
   func `as`(_: SyntaxEnum.Type) -> SyntaxEnum {
     switch raw.kind {
-    case .token: 
+    case .token:
       return .token(TokenSyntax(self)!)
-    case .accessPathComponent: 
+    case .accessPathComponent:
       return .accessPathComponent(AccessPathComponentSyntax(self)!)
-    case .accessPath: 
+    case .accessPath:
       return .accessPath(AccessPathSyntax(self)!)
-    case .accessorBlock: 
+    case .accessorBlock:
       return .accessorBlock(AccessorBlockSyntax(self)!)
-    case .accessorDecl: 
+    case .accessorDecl:
       return .accessorDecl(AccessorDeclSyntax(self)!)
-    case .accessorList: 
+    case .accessorList:
       return .accessorList(AccessorListSyntax(self)!)
-    case .accessorParameter: 
+    case .accessorParameter:
       return .accessorParameter(AccessorParameterSyntax(self)!)
-    case .actorDecl: 
+    case .actorDecl:
       return .actorDecl(ActorDeclSyntax(self)!)
-    case .arrayElementList: 
+    case .arrayElementList:
       return .arrayElementList(ArrayElementListSyntax(self)!)
-    case .arrayElement: 
+    case .arrayElement:
       return .arrayElement(ArrayElementSyntax(self)!)
-    case .arrayExpr: 
+    case .arrayExpr:
       return .arrayExpr(ArrayExprSyntax(self)!)
-    case .arrayType: 
+    case .arrayType:
       return .arrayType(ArrayTypeSyntax(self)!)
-    case .arrowExpr: 
+    case .arrowExpr:
       return .arrowExpr(ArrowExprSyntax(self)!)
-    case .asExpr: 
+    case .asExpr:
       return .asExpr(AsExprSyntax(self)!)
-    case .assignmentExpr: 
+    case .assignmentExpr:
       return .assignmentExpr(AssignmentExprSyntax(self)!)
-    case .associatedtypeDecl: 
+    case .associatedtypeDecl:
       return .associatedtypeDecl(AssociatedtypeDeclSyntax(self)!)
-    case .attributeList: 
+    case .attributeList:
       return .attributeList(AttributeListSyntax(self)!)
-    case .attribute: 
+    case .attribute:
       return .attribute(AttributeSyntax(self)!)
-    case .attributedType: 
+    case .attributedType:
       return .attributedType(AttributedTypeSyntax(self)!)
-    case .availabilityArgument: 
+    case .availabilityArgument:
       return .availabilityArgument(AvailabilityArgumentSyntax(self)!)
-    case .availabilityCondition: 
+    case .availabilityCondition:
       return .availabilityCondition(AvailabilityConditionSyntax(self)!)
-    case .availabilityEntry: 
+    case .availabilityEntry:
       return .availabilityEntry(AvailabilityEntrySyntax(self)!)
-    case .availabilityLabeledArgument: 
+    case .availabilityLabeledArgument:
       return .availabilityLabeledArgument(AvailabilityLabeledArgumentSyntax(self)!)
-    case .availabilitySpecList: 
+    case .availabilitySpecList:
       return .availabilitySpecList(AvailabilitySpecListSyntax(self)!)
-    case .availabilityVersionRestrictionListEntry: 
+    case .availabilityVersionRestrictionListEntry:
       return .availabilityVersionRestrictionListEntry(AvailabilityVersionRestrictionListEntrySyntax(self)!)
-    case .availabilityVersionRestrictionList: 
+    case .availabilityVersionRestrictionList:
       return .availabilityVersionRestrictionList(AvailabilityVersionRestrictionListSyntax(self)!)
-    case .availabilityVersionRestriction: 
+    case .availabilityVersionRestriction:
       return .availabilityVersionRestriction(AvailabilityVersionRestrictionSyntax(self)!)
-    case .awaitExpr: 
+    case .awaitExpr:
       return .awaitExpr(AwaitExprSyntax(self)!)
-    case .backDeployedAttributeSpecList: 
+    case .backDeployedAttributeSpecList:
       return .backDeployedAttributeSpecList(BackDeployedAttributeSpecListSyntax(self)!)
-    case .binaryOperatorExpr: 
+    case .binaryOperatorExpr:
       return .binaryOperatorExpr(BinaryOperatorExprSyntax(self)!)
-    case .booleanLiteralExpr: 
+    case .booleanLiteralExpr:
       return .booleanLiteralExpr(BooleanLiteralExprSyntax(self)!)
-    case .borrowExpr: 
+    case .borrowExpr:
       return .borrowExpr(BorrowExprSyntax(self)!)
-    case .breakStmt: 
+    case .breakStmt:
       return .breakStmt(BreakStmtSyntax(self)!)
-    case .caseItemList: 
+    case .caseItemList:
       return .caseItemList(CaseItemListSyntax(self)!)
-    case .caseItem: 
+    case .caseItem:
       return .caseItem(CaseItemSyntax(self)!)
-    case .catchClauseList: 
+    case .catchClauseList:
       return .catchClauseList(CatchClauseListSyntax(self)!)
-    case .catchClause: 
+    case .catchClause:
       return .catchClause(CatchClauseSyntax(self)!)
-    case .catchItemList: 
+    case .catchItemList:
       return .catchItemList(CatchItemListSyntax(self)!)
-    case .catchItem: 
+    case .catchItem:
       return .catchItem(CatchItemSyntax(self)!)
-    case .classDecl: 
+    case .classDecl:
       return .classDecl(ClassDeclSyntax(self)!)
-    case .classRestrictionType: 
+    case .classRestrictionType:
       return .classRestrictionType(ClassRestrictionTypeSyntax(self)!)
-    case .closureCaptureItemList: 
+    case .closureCaptureItemList:
       return .closureCaptureItemList(ClosureCaptureItemListSyntax(self)!)
-    case .closureCaptureItemSpecifier: 
+    case .closureCaptureItemSpecifier:
       return .closureCaptureItemSpecifier(ClosureCaptureItemSpecifierSyntax(self)!)
-    case .closureCaptureItem: 
+    case .closureCaptureItem:
       return .closureCaptureItem(ClosureCaptureItemSyntax(self)!)
-    case .closureCaptureSignature: 
+    case .closureCaptureSignature:
       return .closureCaptureSignature(ClosureCaptureSignatureSyntax(self)!)
-    case .closureExpr: 
+    case .closureExpr:
       return .closureExpr(ClosureExprSyntax(self)!)
-    case .closureParamList: 
+    case .closureParamList:
       return .closureParamList(ClosureParamListSyntax(self)!)
-    case .closureParam: 
+    case .closureParam:
       return .closureParam(ClosureParamSyntax(self)!)
-    case .closureSignature: 
+    case .closureSignature:
       return .closureSignature(ClosureSignatureSyntax(self)!)
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       return .codeBlockItemList(CodeBlockItemListSyntax(self)!)
-    case .codeBlockItem: 
+    case .codeBlockItem:
       return .codeBlockItem(CodeBlockItemSyntax(self)!)
-    case .codeBlock: 
+    case .codeBlock:
       return .codeBlock(CodeBlockSyntax(self)!)
-    case .compositionTypeElementList: 
+    case .compositionTypeElementList:
       return .compositionTypeElementList(CompositionTypeElementListSyntax(self)!)
-    case .compositionTypeElement: 
+    case .compositionTypeElement:
       return .compositionTypeElement(CompositionTypeElementSyntax(self)!)
-    case .compositionType: 
+    case .compositionType:
       return .compositionType(CompositionTypeSyntax(self)!)
-    case .conditionElementList: 
+    case .conditionElementList:
       return .conditionElementList(ConditionElementListSyntax(self)!)
-    case .conditionElement: 
+    case .conditionElement:
       return .conditionElement(ConditionElementSyntax(self)!)
-    case .conformanceRequirement: 
+    case .conformanceRequirement:
       return .conformanceRequirement(ConformanceRequirementSyntax(self)!)
-    case .constrainedSugarType: 
+    case .constrainedSugarType:
       return .constrainedSugarType(ConstrainedSugarTypeSyntax(self)!)
-    case .continueStmt: 
+    case .continueStmt:
       return .continueStmt(ContinueStmtSyntax(self)!)
-    case .conventionAttributeArguments: 
+    case .conventionAttributeArguments:
       return .conventionAttributeArguments(ConventionAttributeArgumentsSyntax(self)!)
-    case .conventionWitnessMethodAttributeArguments: 
+    case .conventionWitnessMethodAttributeArguments:
       return .conventionWitnessMethodAttributeArguments(ConventionWitnessMethodAttributeArgumentsSyntax(self)!)
-    case .declEffectSpecifiers: 
+    case .declEffectSpecifiers:
       return .declEffectSpecifiers(DeclEffectSpecifiersSyntax(self)!)
-    case .declModifierDetail: 
+    case .declModifierDetail:
       return .declModifierDetail(DeclModifierDetailSyntax(self)!)
-    case .declModifier: 
+    case .declModifier:
       return .declModifier(DeclModifierSyntax(self)!)
-    case .declNameArgumentList: 
+    case .declNameArgumentList:
       return .declNameArgumentList(DeclNameArgumentListSyntax(self)!)
-    case .declNameArgument: 
+    case .declNameArgument:
       return .declNameArgument(DeclNameArgumentSyntax(self)!)
-    case .declNameArguments: 
+    case .declNameArguments:
       return .declNameArguments(DeclNameArgumentsSyntax(self)!)
-    case .declName: 
+    case .declName:
       return .declName(DeclNameSyntax(self)!)
-    case .deferStmt: 
+    case .deferStmt:
       return .deferStmt(DeferStmtSyntax(self)!)
-    case .deinitializerDecl: 
+    case .deinitializerDecl:
       return .deinitializerDecl(DeinitializerDeclSyntax(self)!)
-    case .derivativeRegistrationAttributeArguments: 
+    case .derivativeRegistrationAttributeArguments:
       return .derivativeRegistrationAttributeArguments(DerivativeRegistrationAttributeArgumentsSyntax(self)!)
-    case .designatedTypeElement: 
+    case .designatedTypeElement:
       return .designatedTypeElement(DesignatedTypeElementSyntax(self)!)
-    case .designatedTypeList: 
+    case .designatedTypeList:
       return .designatedTypeList(DesignatedTypeListSyntax(self)!)
-    case .dictionaryElementList: 
+    case .dictionaryElementList:
       return .dictionaryElementList(DictionaryElementListSyntax(self)!)
-    case .dictionaryElement: 
+    case .dictionaryElement:
       return .dictionaryElement(DictionaryElementSyntax(self)!)
-    case .dictionaryExpr: 
+    case .dictionaryExpr:
       return .dictionaryExpr(DictionaryExprSyntax(self)!)
-    case .dictionaryType: 
+    case .dictionaryType:
       return .dictionaryType(DictionaryTypeSyntax(self)!)
-    case .differentiabilityParamList: 
+    case .differentiabilityParamList:
       return .differentiabilityParamList(DifferentiabilityParamListSyntax(self)!)
-    case .differentiabilityParam: 
+    case .differentiabilityParam:
       return .differentiabilityParam(DifferentiabilityParamSyntax(self)!)
-    case .differentiabilityParamsClause: 
+    case .differentiabilityParamsClause:
       return .differentiabilityParamsClause(DifferentiabilityParamsClauseSyntax(self)!)
-    case .differentiabilityParams: 
+    case .differentiabilityParams:
       return .differentiabilityParams(DifferentiabilityParamsSyntax(self)!)
-    case .differentiableAttributeArguments: 
+    case .differentiableAttributeArguments:
       return .differentiableAttributeArguments(DifferentiableAttributeArgumentsSyntax(self)!)
-    case .discardAssignmentExpr: 
+    case .discardAssignmentExpr:
       return .discardAssignmentExpr(DiscardAssignmentExprSyntax(self)!)
-    case .doStmt: 
+    case .doStmt:
       return .doStmt(DoStmtSyntax(self)!)
-    case .documentationAttributeArgument: 
+    case .documentationAttributeArgument:
       return .documentationAttributeArgument(DocumentationAttributeArgumentSyntax(self)!)
-    case .documentationAttributeArguments: 
+    case .documentationAttributeArguments:
       return .documentationAttributeArguments(DocumentationAttributeArgumentsSyntax(self)!)
-    case .dynamicReplacementArguments: 
+    case .dynamicReplacementArguments:
       return .dynamicReplacementArguments(DynamicReplacementArgumentsSyntax(self)!)
-    case .editorPlaceholderDecl: 
+    case .editorPlaceholderDecl:
       return .editorPlaceholderDecl(EditorPlaceholderDeclSyntax(self)!)
-    case .editorPlaceholderExpr: 
+    case .editorPlaceholderExpr:
       return .editorPlaceholderExpr(EditorPlaceholderExprSyntax(self)!)
-    case .effectsArguments: 
+    case .effectsArguments:
       return .effectsArguments(EffectsArgumentsSyntax(self)!)
-    case .enumCaseDecl: 
+    case .enumCaseDecl:
       return .enumCaseDecl(EnumCaseDeclSyntax(self)!)
-    case .enumCaseElementList: 
+    case .enumCaseElementList:
       return .enumCaseElementList(EnumCaseElementListSyntax(self)!)
-    case .enumCaseElement: 
+    case .enumCaseElement:
       return .enumCaseElement(EnumCaseElementSyntax(self)!)
-    case .enumDecl: 
+    case .enumDecl:
       return .enumDecl(EnumDeclSyntax(self)!)
-    case .exposeAttributeArguments: 
+    case .exposeAttributeArguments:
       return .exposeAttributeArguments(ExposeAttributeArgumentsSyntax(self)!)
-    case .exprList: 
+    case .exprList:
       return .exprList(ExprListSyntax(self)!)
-    case .expressionPattern: 
+    case .expressionPattern:
       return .expressionPattern(ExpressionPatternSyntax(self)!)
-    case .expressionSegment: 
+    case .expressionSegment:
       return .expressionSegment(ExpressionSegmentSyntax(self)!)
-    case .expressionStmt: 
+    case .expressionStmt:
       return .expressionStmt(ExpressionStmtSyntax(self)!)
-    case .extensionDecl: 
+    case .extensionDecl:
       return .extensionDecl(ExtensionDeclSyntax(self)!)
-    case .fallthroughStmt: 
+    case .fallthroughStmt:
       return .fallthroughStmt(FallthroughStmtSyntax(self)!)
-    case .floatLiteralExpr: 
+    case .floatLiteralExpr:
       return .floatLiteralExpr(FloatLiteralExprSyntax(self)!)
-    case .forInStmt: 
+    case .forInStmt:
       return .forInStmt(ForInStmtSyntax(self)!)
-    case .forcedValueExpr: 
+    case .forcedValueExpr:
       return .forcedValueExpr(ForcedValueExprSyntax(self)!)
-    case .functionCallExpr: 
+    case .functionCallExpr:
       return .functionCallExpr(FunctionCallExprSyntax(self)!)
-    case .functionDecl: 
+    case .functionDecl:
       return .functionDecl(FunctionDeclSyntax(self)!)
-    case .functionParameterList: 
+    case .functionParameterList:
       return .functionParameterList(FunctionParameterListSyntax(self)!)
-    case .functionParameter: 
+    case .functionParameter:
       return .functionParameter(FunctionParameterSyntax(self)!)
-    case .functionSignature: 
+    case .functionSignature:
       return .functionSignature(FunctionSignatureSyntax(self)!)
-    case .functionType: 
+    case .functionType:
       return .functionType(FunctionTypeSyntax(self)!)
-    case .genericArgumentClause: 
+    case .genericArgumentClause:
       return .genericArgumentClause(GenericArgumentClauseSyntax(self)!)
-    case .genericArgumentList: 
+    case .genericArgumentList:
       return .genericArgumentList(GenericArgumentListSyntax(self)!)
-    case .genericArgument: 
+    case .genericArgument:
       return .genericArgument(GenericArgumentSyntax(self)!)
-    case .genericParameterClause: 
+    case .genericParameterClause:
       return .genericParameterClause(GenericParameterClauseSyntax(self)!)
-    case .genericParameterList: 
+    case .genericParameterList:
       return .genericParameterList(GenericParameterListSyntax(self)!)
-    case .genericParameter: 
+    case .genericParameter:
       return .genericParameter(GenericParameterSyntax(self)!)
-    case .genericRequirementList: 
+    case .genericRequirementList:
       return .genericRequirementList(GenericRequirementListSyntax(self)!)
-    case .genericRequirement: 
+    case .genericRequirement:
       return .genericRequirement(GenericRequirementSyntax(self)!)
-    case .genericWhereClause: 
+    case .genericWhereClause:
       return .genericWhereClause(GenericWhereClauseSyntax(self)!)
-    case .guardStmt: 
+    case .guardStmt:
       return .guardStmt(GuardStmtSyntax(self)!)
-    case .identifierExpr: 
+    case .identifierExpr:
       return .identifierExpr(IdentifierExprSyntax(self)!)
-    case .identifierPattern: 
+    case .identifierPattern:
       return .identifierPattern(IdentifierPatternSyntax(self)!)
-    case .ifConfigClauseList: 
+    case .ifConfigClauseList:
       return .ifConfigClauseList(IfConfigClauseListSyntax(self)!)
-    case .ifConfigClause: 
+    case .ifConfigClause:
       return .ifConfigClause(IfConfigClauseSyntax(self)!)
-    case .ifConfigDecl: 
+    case .ifConfigDecl:
       return .ifConfigDecl(IfConfigDeclSyntax(self)!)
-    case .ifExpr: 
+    case .ifExpr:
       return .ifExpr(IfExprSyntax(self)!)
-    case .implementsAttributeArguments: 
+    case .implementsAttributeArguments:
       return .implementsAttributeArguments(ImplementsAttributeArgumentsSyntax(self)!)
-    case .implicitlyUnwrappedOptionalType: 
+    case .implicitlyUnwrappedOptionalType:
       return .implicitlyUnwrappedOptionalType(ImplicitlyUnwrappedOptionalTypeSyntax(self)!)
-    case .importDecl: 
+    case .importDecl:
       return .importDecl(ImportDeclSyntax(self)!)
-    case .inOutExpr: 
+    case .inOutExpr:
       return .inOutExpr(InOutExprSyntax(self)!)
-    case .infixOperatorExpr: 
+    case .infixOperatorExpr:
       return .infixOperatorExpr(InfixOperatorExprSyntax(self)!)
-    case .inheritedTypeList: 
+    case .inheritedTypeList:
       return .inheritedTypeList(InheritedTypeListSyntax(self)!)
-    case .inheritedType: 
+    case .inheritedType:
       return .inheritedType(InheritedTypeSyntax(self)!)
-    case .initializerClause: 
+    case .initializerClause:
       return .initializerClause(InitializerClauseSyntax(self)!)
-    case .initializerDecl: 
+    case .initializerDecl:
       return .initializerDecl(InitializerDeclSyntax(self)!)
-    case .integerLiteralExpr: 
+    case .integerLiteralExpr:
       return .integerLiteralExpr(IntegerLiteralExprSyntax(self)!)
-    case .isExpr: 
+    case .isExpr:
       return .isExpr(IsExprSyntax(self)!)
-    case .isTypePattern: 
+    case .isTypePattern:
       return .isTypePattern(IsTypePatternSyntax(self)!)
-    case .keyPathComponentList: 
+    case .keyPathComponentList:
       return .keyPathComponentList(KeyPathComponentListSyntax(self)!)
-    case .keyPathComponent: 
+    case .keyPathComponent:
       return .keyPathComponent(KeyPathComponentSyntax(self)!)
-    case .keyPathExpr: 
+    case .keyPathExpr:
       return .keyPathExpr(KeyPathExprSyntax(self)!)
-    case .keyPathOptionalComponent: 
+    case .keyPathOptionalComponent:
       return .keyPathOptionalComponent(KeyPathOptionalComponentSyntax(self)!)
-    case .keyPathPropertyComponent: 
+    case .keyPathPropertyComponent:
       return .keyPathPropertyComponent(KeyPathPropertyComponentSyntax(self)!)
-    case .keyPathSubscriptComponent: 
+    case .keyPathSubscriptComponent:
       return .keyPathSubscriptComponent(KeyPathSubscriptComponentSyntax(self)!)
-    case .labeledSpecializeEntry: 
+    case .labeledSpecializeEntry:
       return .labeledSpecializeEntry(LabeledSpecializeEntrySyntax(self)!)
-    case .labeledStmt: 
+    case .labeledStmt:
       return .labeledStmt(LabeledStmtSyntax(self)!)
-    case .layoutRequirement: 
+    case .layoutRequirement:
       return .layoutRequirement(LayoutRequirementSyntax(self)!)
-    case .macroDecl: 
+    case .macroDecl:
       return .macroDecl(MacroDeclSyntax(self)!)
-    case .macroExpansionDecl: 
+    case .macroExpansionDecl:
       return .macroExpansionDecl(MacroExpansionDeclSyntax(self)!)
-    case .macroExpansionExpr: 
+    case .macroExpansionExpr:
       return .macroExpansionExpr(MacroExpansionExprSyntax(self)!)
-    case .matchingPatternCondition: 
+    case .matchingPatternCondition:
       return .matchingPatternCondition(MatchingPatternConditionSyntax(self)!)
-    case .memberAccessExpr: 
+    case .memberAccessExpr:
       return .memberAccessExpr(MemberAccessExprSyntax(self)!)
-    case .memberDeclBlock: 
+    case .memberDeclBlock:
       return .memberDeclBlock(MemberDeclBlockSyntax(self)!)
-    case .memberDeclListItem: 
+    case .memberDeclListItem:
       return .memberDeclListItem(MemberDeclListItemSyntax(self)!)
-    case .memberDeclList: 
+    case .memberDeclList:
       return .memberDeclList(MemberDeclListSyntax(self)!)
-    case .memberTypeIdentifier: 
+    case .memberTypeIdentifier:
       return .memberTypeIdentifier(MemberTypeIdentifierSyntax(self)!)
-    case .metatypeType: 
+    case .metatypeType:
       return .metatypeType(MetatypeTypeSyntax(self)!)
-    case .missingDecl: 
+    case .missingDecl:
       return .missingDecl(MissingDeclSyntax(self)!)
-    case .missingExpr: 
+    case .missingExpr:
       return .missingExpr(MissingExprSyntax(self)!)
-    case .missingPattern: 
+    case .missingPattern:
       return .missingPattern(MissingPatternSyntax(self)!)
-    case .missingStmt: 
+    case .missingStmt:
       return .missingStmt(MissingStmtSyntax(self)!)
-    case .missing: 
+    case .missing:
       return .missing(MissingSyntax(self)!)
-    case .missingType: 
+    case .missingType:
       return .missingType(MissingTypeSyntax(self)!)
-    case .modifierList: 
+    case .modifierList:
       return .modifierList(ModifierListSyntax(self)!)
-    case .moveExpr: 
+    case .moveExpr:
       return .moveExpr(MoveExprSyntax(self)!)
-    case .multipleTrailingClosureElementList: 
+    case .multipleTrailingClosureElementList:
       return .multipleTrailingClosureElementList(MultipleTrailingClosureElementListSyntax(self)!)
-    case .multipleTrailingClosureElement: 
+    case .multipleTrailingClosureElement:
       return .multipleTrailingClosureElement(MultipleTrailingClosureElementSyntax(self)!)
-    case .namedOpaqueReturnType: 
+    case .namedOpaqueReturnType:
       return .namedOpaqueReturnType(NamedOpaqueReturnTypeSyntax(self)!)
-    case .nilLiteralExpr: 
+    case .nilLiteralExpr:
       return .nilLiteralExpr(NilLiteralExprSyntax(self)!)
-    case .objCSelectorPiece: 
+    case .objCSelectorPiece:
       return .objCSelectorPiece(ObjCSelectorPieceSyntax(self)!)
-    case .objCSelector: 
+    case .objCSelector:
       return .objCSelector(ObjCSelectorSyntax(self)!)
-    case .opaqueReturnTypeOfAttributeArguments: 
+    case .opaqueReturnTypeOfAttributeArguments:
       return .opaqueReturnTypeOfAttributeArguments(OpaqueReturnTypeOfAttributeArgumentsSyntax(self)!)
-    case .operatorDecl: 
+    case .operatorDecl:
       return .operatorDecl(OperatorDeclSyntax(self)!)
-    case .operatorPrecedenceAndTypes: 
+    case .operatorPrecedenceAndTypes:
       return .operatorPrecedenceAndTypes(OperatorPrecedenceAndTypesSyntax(self)!)
-    case .optionalBindingCondition: 
+    case .optionalBindingCondition:
       return .optionalBindingCondition(OptionalBindingConditionSyntax(self)!)
-    case .optionalChainingExpr: 
+    case .optionalChainingExpr:
       return .optionalChainingExpr(OptionalChainingExprSyntax(self)!)
-    case .optionalType: 
+    case .optionalType:
       return .optionalType(OptionalTypeSyntax(self)!)
-    case .originallyDefinedInArguments: 
+    case .originallyDefinedInArguments:
       return .originallyDefinedInArguments(OriginallyDefinedInArgumentsSyntax(self)!)
-    case .packElementExpr: 
+    case .packElementExpr:
       return .packElementExpr(PackElementExprSyntax(self)!)
-    case .packExpansionExpr: 
+    case .packExpansionExpr:
       return .packExpansionExpr(PackExpansionExprSyntax(self)!)
-    case .packExpansionType: 
+    case .packExpansionType:
       return .packExpansionType(PackExpansionTypeSyntax(self)!)
-    case .packReferenceType: 
+    case .packReferenceType:
       return .packReferenceType(PackReferenceTypeSyntax(self)!)
-    case .parameterClause: 
+    case .parameterClause:
       return .parameterClause(ParameterClauseSyntax(self)!)
-    case .patternBindingList: 
+    case .patternBindingList:
       return .patternBindingList(PatternBindingListSyntax(self)!)
-    case .patternBinding: 
+    case .patternBinding:
       return .patternBinding(PatternBindingSyntax(self)!)
-    case .postfixIfConfigExpr: 
+    case .postfixIfConfigExpr:
       return .postfixIfConfigExpr(PostfixIfConfigExprSyntax(self)!)
-    case .postfixUnaryExpr: 
+    case .postfixUnaryExpr:
       return .postfixUnaryExpr(PostfixUnaryExprSyntax(self)!)
-    case .poundSourceLocationArgs: 
+    case .poundSourceLocationArgs:
       return .poundSourceLocationArgs(PoundSourceLocationArgsSyntax(self)!)
-    case .poundSourceLocation: 
+    case .poundSourceLocation:
       return .poundSourceLocation(PoundSourceLocationSyntax(self)!)
-    case .precedenceGroupAssignment: 
+    case .precedenceGroupAssignment:
       return .precedenceGroupAssignment(PrecedenceGroupAssignmentSyntax(self)!)
-    case .precedenceGroupAssociativity: 
+    case .precedenceGroupAssociativity:
       return .precedenceGroupAssociativity(PrecedenceGroupAssociativitySyntax(self)!)
-    case .precedenceGroupAttributeList: 
+    case .precedenceGroupAttributeList:
       return .precedenceGroupAttributeList(PrecedenceGroupAttributeListSyntax(self)!)
-    case .precedenceGroupDecl: 
+    case .precedenceGroupDecl:
       return .precedenceGroupDecl(PrecedenceGroupDeclSyntax(self)!)
-    case .precedenceGroupNameElement: 
+    case .precedenceGroupNameElement:
       return .precedenceGroupNameElement(PrecedenceGroupNameElementSyntax(self)!)
-    case .precedenceGroupNameList: 
+    case .precedenceGroupNameList:
       return .precedenceGroupNameList(PrecedenceGroupNameListSyntax(self)!)
-    case .precedenceGroupRelation: 
+    case .precedenceGroupRelation:
       return .precedenceGroupRelation(PrecedenceGroupRelationSyntax(self)!)
-    case .prefixOperatorExpr: 
+    case .prefixOperatorExpr:
       return .prefixOperatorExpr(PrefixOperatorExprSyntax(self)!)
-    case .primaryAssociatedTypeClause: 
+    case .primaryAssociatedTypeClause:
       return .primaryAssociatedTypeClause(PrimaryAssociatedTypeClauseSyntax(self)!)
-    case .primaryAssociatedTypeList: 
+    case .primaryAssociatedTypeList:
       return .primaryAssociatedTypeList(PrimaryAssociatedTypeListSyntax(self)!)
-    case .primaryAssociatedType: 
+    case .primaryAssociatedType:
       return .primaryAssociatedType(PrimaryAssociatedTypeSyntax(self)!)
-    case .protocolDecl: 
+    case .protocolDecl:
       return .protocolDecl(ProtocolDeclSyntax(self)!)
-    case .qualifiedDeclName: 
+    case .qualifiedDeclName:
       return .qualifiedDeclName(QualifiedDeclNameSyntax(self)!)
-    case .regexLiteralExpr: 
+    case .regexLiteralExpr:
       return .regexLiteralExpr(RegexLiteralExprSyntax(self)!)
-    case .repeatWhileStmt: 
+    case .repeatWhileStmt:
       return .repeatWhileStmt(RepeatWhileStmtSyntax(self)!)
-    case .returnClause: 
+    case .returnClause:
       return .returnClause(ReturnClauseSyntax(self)!)
-    case .returnStmt: 
+    case .returnStmt:
       return .returnStmt(ReturnStmtSyntax(self)!)
-    case .sameTypeRequirement: 
+    case .sameTypeRequirement:
       return .sameTypeRequirement(SameTypeRequirementSyntax(self)!)
-    case .sequenceExpr: 
+    case .sequenceExpr:
       return .sequenceExpr(SequenceExprSyntax(self)!)
-    case .simpleTypeIdentifier: 
+    case .simpleTypeIdentifier:
       return .simpleTypeIdentifier(SimpleTypeIdentifierSyntax(self)!)
-    case .sourceFile: 
+    case .sourceFile:
       return .sourceFile(SourceFileSyntax(self)!)
-    case .specializeAttributeSpecList: 
+    case .specializeAttributeSpecList:
       return .specializeAttributeSpecList(SpecializeAttributeSpecListSyntax(self)!)
-    case .specializeExpr: 
+    case .specializeExpr:
       return .specializeExpr(SpecializeExprSyntax(self)!)
-    case .stringLiteralExpr: 
+    case .stringLiteralExpr:
       return .stringLiteralExpr(StringLiteralExprSyntax(self)!)
-    case .stringLiteralSegments: 
+    case .stringLiteralSegments:
       return .stringLiteralSegments(StringLiteralSegmentsSyntax(self)!)
-    case .stringSegment: 
+    case .stringSegment:
       return .stringSegment(StringSegmentSyntax(self)!)
-    case .structDecl: 
+    case .structDecl:
       return .structDecl(StructDeclSyntax(self)!)
-    case .subscriptDecl: 
+    case .subscriptDecl:
       return .subscriptDecl(SubscriptDeclSyntax(self)!)
-    case .subscriptExpr: 
+    case .subscriptExpr:
       return .subscriptExpr(SubscriptExprSyntax(self)!)
-    case .superRefExpr: 
+    case .superRefExpr:
       return .superRefExpr(SuperRefExprSyntax(self)!)
-    case .switchCaseLabel: 
+    case .switchCaseLabel:
       return .switchCaseLabel(SwitchCaseLabelSyntax(self)!)
-    case .switchCaseList: 
+    case .switchCaseList:
       return .switchCaseList(SwitchCaseListSyntax(self)!)
-    case .switchCase: 
+    case .switchCase:
       return .switchCase(SwitchCaseSyntax(self)!)
-    case .switchDefaultLabel: 
+    case .switchDefaultLabel:
       return .switchDefaultLabel(SwitchDefaultLabelSyntax(self)!)
-    case .switchExpr: 
+    case .switchExpr:
       return .switchExpr(SwitchExprSyntax(self)!)
-    case .targetFunctionEntry: 
+    case .targetFunctionEntry:
       return .targetFunctionEntry(TargetFunctionEntrySyntax(self)!)
-    case .ternaryExpr: 
+    case .ternaryExpr:
       return .ternaryExpr(TernaryExprSyntax(self)!)
-    case .throwStmt: 
+    case .throwStmt:
       return .throwStmt(ThrowStmtSyntax(self)!)
-    case .tryExpr: 
+    case .tryExpr:
       return .tryExpr(TryExprSyntax(self)!)
-    case .tupleExprElementList: 
+    case .tupleExprElementList:
       return .tupleExprElementList(TupleExprElementListSyntax(self)!)
-    case .tupleExprElement: 
+    case .tupleExprElement:
       return .tupleExprElement(TupleExprElementSyntax(self)!)
-    case .tupleExpr: 
+    case .tupleExpr:
       return .tupleExpr(TupleExprSyntax(self)!)
-    case .tuplePatternElementList: 
+    case .tuplePatternElementList:
       return .tuplePatternElementList(TuplePatternElementListSyntax(self)!)
-    case .tuplePatternElement: 
+    case .tuplePatternElement:
       return .tuplePatternElement(TuplePatternElementSyntax(self)!)
-    case .tuplePattern: 
+    case .tuplePattern:
       return .tuplePattern(TuplePatternSyntax(self)!)
-    case .tupleTypeElementList: 
+    case .tupleTypeElementList:
       return .tupleTypeElementList(TupleTypeElementListSyntax(self)!)
-    case .tupleTypeElement: 
+    case .tupleTypeElement:
       return .tupleTypeElement(TupleTypeElementSyntax(self)!)
-    case .tupleType: 
+    case .tupleType:
       return .tupleType(TupleTypeSyntax(self)!)
-    case .typeAnnotation: 
+    case .typeAnnotation:
       return .typeAnnotation(TypeAnnotationSyntax(self)!)
-    case .typeEffectSpecifiers: 
+    case .typeEffectSpecifiers:
       return .typeEffectSpecifiers(TypeEffectSpecifiersSyntax(self)!)
-    case .typeExpr: 
+    case .typeExpr:
       return .typeExpr(TypeExprSyntax(self)!)
-    case .typeInheritanceClause: 
+    case .typeInheritanceClause:
       return .typeInheritanceClause(TypeInheritanceClauseSyntax(self)!)
-    case .typeInitializerClause: 
+    case .typeInitializerClause:
       return .typeInitializerClause(TypeInitializerClauseSyntax(self)!)
-    case .typealiasDecl: 
+    case .typealiasDecl:
       return .typealiasDecl(TypealiasDeclSyntax(self)!)
-    case .unavailableFromAsyncArguments: 
+    case .unavailableFromAsyncArguments:
       return .unavailableFromAsyncArguments(UnavailableFromAsyncArgumentsSyntax(self)!)
-    case .underscorePrivateAttributeArguments: 
+    case .underscorePrivateAttributeArguments:
       return .underscorePrivateAttributeArguments(UnderscorePrivateAttributeArgumentsSyntax(self)!)
-    case .unexpectedNodes: 
+    case .unexpectedNodes:
       return .unexpectedNodes(UnexpectedNodesSyntax(self)!)
-    case .unresolvedAsExpr: 
+    case .unresolvedAsExpr:
       return .unresolvedAsExpr(UnresolvedAsExprSyntax(self)!)
-    case .unresolvedIsExpr: 
+    case .unresolvedIsExpr:
       return .unresolvedIsExpr(UnresolvedIsExprSyntax(self)!)
-    case .unresolvedPatternExpr: 
+    case .unresolvedPatternExpr:
       return .unresolvedPatternExpr(UnresolvedPatternExprSyntax(self)!)
-    case .unresolvedTernaryExpr: 
+    case .unresolvedTernaryExpr:
       return .unresolvedTernaryExpr(UnresolvedTernaryExprSyntax(self)!)
-    case .valueBindingPattern: 
+    case .valueBindingPattern:
       return .valueBindingPattern(ValueBindingPatternSyntax(self)!)
-    case .variableDecl: 
+    case .variableDecl:
       return .variableDecl(VariableDeclSyntax(self)!)
-    case .versionTuple: 
+    case .versionTuple:
       return .versionTuple(VersionTupleSyntax(self)!)
-    case .whereClause: 
+    case .whereClause:
       return .whereClause(WhereClauseSyntax(self)!)
-    case .whileStmt: 
+    case .whileStmt:
       return .whileStmt(WhileStmtSyntax(self)!)
-    case .wildcardPattern: 
+    case .wildcardPattern:
       return .wildcardPattern(WildcardPatternSyntax(self)!)
-    case .yieldExprListElement: 
+    case .yieldExprListElement:
       return .yieldExprListElement(YieldExprListElementSyntax(self)!)
-    case .yieldExprList: 
+    case .yieldExprList:
       return .yieldExprList(YieldExprListSyntax(self)!)
-    case .yieldList: 
+    case .yieldList:
       return .yieldList(YieldListSyntax(self)!)
-    case .yieldStmt: 
+    case .yieldStmt:
       return .yieldStmt(YieldStmtSyntax(self)!)
     }
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift
index 1cccea46909..9bd133b1872 100644
--- a/Sources/SwiftSyntax/generated/SyntaxKind.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift
@@ -541,114 +541,114 @@ public enum SyntaxKind {
   
   public var isSyntaxCollection: Bool {
     switch self {
-    case .accessPath: 
+    case .accessPath:
       return true
-    case .accessorList: 
+    case .accessorList:
       return true
-    case .arrayElementList: 
+    case .arrayElementList:
       return true
-    case .attributeList: 
+    case .attributeList:
       return true
-    case .availabilitySpecList: 
+    case .availabilitySpecList:
       return true
-    case .availabilityVersionRestrictionList: 
+    case .availabilityVersionRestrictionList:
       return true
-    case .caseItemList: 
+    case .caseItemList:
       return true
-    case .catchClauseList: 
+    case .catchClauseList:
       return true
-    case .catchItemList: 
+    case .catchItemList:
       return true
-    case .closureCaptureItemList: 
+    case .closureCaptureItemList:
       return true
-    case .closureParamList: 
+    case .closureParamList:
       return true
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       return true
-    case .compositionTypeElementList: 
+    case .compositionTypeElementList:
       return true
-    case .conditionElementList: 
+    case .conditionElementList:
       return true
-    case .declNameArgumentList: 
+    case .declNameArgumentList:
       return true
-    case .designatedTypeList: 
+    case .designatedTypeList:
       return true
-    case .dictionaryElementList: 
+    case .dictionaryElementList:
       return true
-    case .differentiabilityParamList: 
+    case .differentiabilityParamList:
       return true
-    case .documentationAttributeArguments: 
+    case .documentationAttributeArguments:
       return true
-    case .effectsArguments: 
+    case .effectsArguments:
       return true
-    case .enumCaseElementList: 
+    case .enumCaseElementList:
       return true
-    case .exprList: 
+    case .exprList:
       return true
-    case .functionParameterList: 
+    case .functionParameterList:
       return true
-    case .genericArgumentList: 
+    case .genericArgumentList:
       return true
-    case .genericParameterList: 
+    case .genericParameterList:
       return true
-    case .genericRequirementList: 
+    case .genericRequirementList:
       return true
-    case .ifConfigClauseList: 
+    case .ifConfigClauseList:
       return true
-    case .inheritedTypeList: 
+    case .inheritedTypeList:
       return true
-    case .keyPathComponentList: 
+    case .keyPathComponentList:
       return true
-    case .memberDeclList: 
+    case .memberDeclList:
       return true
-    case .modifierList: 
+    case .modifierList:
       return true
-    case .multipleTrailingClosureElementList: 
+    case .multipleTrailingClosureElementList:
       return true
-    case .objCSelector: 
+    case .objCSelector:
       return true
-    case .patternBindingList: 
+    case .patternBindingList:
       return true
-    case .precedenceGroupAttributeList: 
+    case .precedenceGroupAttributeList:
       return true
-    case .precedenceGroupNameList: 
+    case .precedenceGroupNameList:
       return true
-    case .primaryAssociatedTypeList: 
+    case .primaryAssociatedTypeList:
       return true
-    case .specializeAttributeSpecList: 
+    case .specializeAttributeSpecList:
       return true
-    case .stringLiteralSegments: 
+    case .stringLiteralSegments:
       return true
-    case .switchCaseList: 
+    case .switchCaseList:
       return true
-    case .tupleExprElementList: 
+    case .tupleExprElementList:
       return true
-    case .tuplePatternElementList: 
+    case .tuplePatternElementList:
       return true
-    case .tupleTypeElementList: 
+    case .tupleTypeElementList:
       return true
-    case .unexpectedNodes: 
+    case .unexpectedNodes:
       return true
-    case .yieldExprList: 
+    case .yieldExprList:
       return true
-    default: 
+    default:
       return false
     }
   }
   
   public var isMissing: Bool {
     switch self {
-    case .missingDecl: 
+    case .missingDecl:
       return true
-    case .missingExpr: 
+    case .missingExpr:
       return true
-    case .missingPattern: 
+    case .missingPattern:
       return true
-    case .missingStmt: 
+    case .missingStmt:
       return true
-    case .missingType: 
+    case .missingType:
       return true
-    default: 
+    default:
       return false
     }
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
index c19bea43e99..497aa49416e 100644
--- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -5601,527 +5601,527 @@ open class SyntaxRewriter {
   /// space transient instead of having it linger in the call stack.
   private func visitationFunc(for data: SyntaxData) -> ((SyntaxData) -> Syntax) {
     switch data.raw.kind {
-    case .token: 
+    case .token:
       return visitImplTokenSyntax
-    case .accessPathComponent: 
+    case .accessPathComponent:
       return visitImplAccessPathComponentSyntax
-    case .accessPath: 
+    case .accessPath:
       return visitImplAccessPathSyntax
-    case .accessorBlock: 
+    case .accessorBlock:
       return visitImplAccessorBlockSyntax
-    case .accessorDecl: 
+    case .accessorDecl:
       return visitImplAccessorDeclSyntax
-    case .accessorList: 
+    case .accessorList:
       return visitImplAccessorListSyntax
-    case .accessorParameter: 
+    case .accessorParameter:
       return visitImplAccessorParameterSyntax
-    case .actorDecl: 
+    case .actorDecl:
       return visitImplActorDeclSyntax
-    case .arrayElementList: 
+    case .arrayElementList:
       return visitImplArrayElementListSyntax
-    case .arrayElement: 
+    case .arrayElement:
       return visitImplArrayElementSyntax
-    case .arrayExpr: 
+    case .arrayExpr:
       return visitImplArrayExprSyntax
-    case .arrayType: 
+    case .arrayType:
       return visitImplArrayTypeSyntax
-    case .arrowExpr: 
+    case .arrowExpr:
       return visitImplArrowExprSyntax
-    case .asExpr: 
+    case .asExpr:
       return visitImplAsExprSyntax
-    case .assignmentExpr: 
+    case .assignmentExpr:
       return visitImplAssignmentExprSyntax
-    case .associatedtypeDecl: 
+    case .associatedtypeDecl:
       return visitImplAssociatedtypeDeclSyntax
-    case .attributeList: 
+    case .attributeList:
       return visitImplAttributeListSyntax
-    case .attribute: 
+    case .attribute:
       return visitImplAttributeSyntax
-    case .attributedType: 
+    case .attributedType:
       return visitImplAttributedTypeSyntax
-    case .availabilityArgument: 
+    case .availabilityArgument:
       return visitImplAvailabilityArgumentSyntax
-    case .availabilityCondition: 
+    case .availabilityCondition:
       return visitImplAvailabilityConditionSyntax
-    case .availabilityEntry: 
+    case .availabilityEntry:
       return visitImplAvailabilityEntrySyntax
-    case .availabilityLabeledArgument: 
+    case .availabilityLabeledArgument:
       return visitImplAvailabilityLabeledArgumentSyntax
-    case .availabilitySpecList: 
+    case .availabilitySpecList:
       return visitImplAvailabilitySpecListSyntax
-    case .availabilityVersionRestrictionListEntry: 
+    case .availabilityVersionRestrictionListEntry:
       return visitImplAvailabilityVersionRestrictionListEntrySyntax
-    case .availabilityVersionRestrictionList: 
+    case .availabilityVersionRestrictionList:
       return visitImplAvailabilityVersionRestrictionListSyntax
-    case .availabilityVersionRestriction: 
+    case .availabilityVersionRestriction:
       return visitImplAvailabilityVersionRestrictionSyntax
-    case .awaitExpr: 
+    case .awaitExpr:
       return visitImplAwaitExprSyntax
-    case .backDeployedAttributeSpecList: 
+    case .backDeployedAttributeSpecList:
       return visitImplBackDeployedAttributeSpecListSyntax
-    case .binaryOperatorExpr: 
+    case .binaryOperatorExpr:
       return visitImplBinaryOperatorExprSyntax
-    case .booleanLiteralExpr: 
+    case .booleanLiteralExpr:
       return visitImplBooleanLiteralExprSyntax
-    case .borrowExpr: 
+    case .borrowExpr:
       return visitImplBorrowExprSyntax
-    case .breakStmt: 
+    case .breakStmt:
       return visitImplBreakStmtSyntax
-    case .caseItemList: 
+    case .caseItemList:
       return visitImplCaseItemListSyntax
-    case .caseItem: 
+    case .caseItem:
       return visitImplCaseItemSyntax
-    case .catchClauseList: 
+    case .catchClauseList:
       return visitImplCatchClauseListSyntax
-    case .catchClause: 
+    case .catchClause:
       return visitImplCatchClauseSyntax
-    case .catchItemList: 
+    case .catchItemList:
       return visitImplCatchItemListSyntax
-    case .catchItem: 
+    case .catchItem:
       return visitImplCatchItemSyntax
-    case .classDecl: 
+    case .classDecl:
       return visitImplClassDeclSyntax
-    case .classRestrictionType: 
+    case .classRestrictionType:
       return visitImplClassRestrictionTypeSyntax
-    case .closureCaptureItemList: 
+    case .closureCaptureItemList:
       return visitImplClosureCaptureItemListSyntax
-    case .closureCaptureItemSpecifier: 
+    case .closureCaptureItemSpecifier:
       return visitImplClosureCaptureItemSpecifierSyntax
-    case .closureCaptureItem: 
+    case .closureCaptureItem:
       return visitImplClosureCaptureItemSyntax
-    case .closureCaptureSignature: 
+    case .closureCaptureSignature:
       return visitImplClosureCaptureSignatureSyntax
-    case .closureExpr: 
+    case .closureExpr:
       return visitImplClosureExprSyntax
-    case .closureParamList: 
+    case .closureParamList:
       return visitImplClosureParamListSyntax
-    case .closureParam: 
+    case .closureParam:
       return visitImplClosureParamSyntax
-    case .closureSignature: 
+    case .closureSignature:
       return visitImplClosureSignatureSyntax
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       return visitImplCodeBlockItemListSyntax
-    case .codeBlockItem: 
+    case .codeBlockItem:
       return visitImplCodeBlockItemSyntax
-    case .codeBlock: 
+    case .codeBlock:
       return visitImplCodeBlockSyntax
-    case .compositionTypeElementList: 
+    case .compositionTypeElementList:
       return visitImplCompositionTypeElementListSyntax
-    case .compositionTypeElement: 
+    case .compositionTypeElement:
       return visitImplCompositionTypeElementSyntax
-    case .compositionType: 
+    case .compositionType:
       return visitImplCompositionTypeSyntax
-    case .conditionElementList: 
+    case .conditionElementList:
       return visitImplConditionElementListSyntax
-    case .conditionElement: 
+    case .conditionElement:
       return visitImplConditionElementSyntax
-    case .conformanceRequirement: 
+    case .conformanceRequirement:
       return visitImplConformanceRequirementSyntax
-    case .constrainedSugarType: 
+    case .constrainedSugarType:
       return visitImplConstrainedSugarTypeSyntax
-    case .continueStmt: 
+    case .continueStmt:
       return visitImplContinueStmtSyntax
-    case .conventionAttributeArguments: 
+    case .conventionAttributeArguments:
       return visitImplConventionAttributeArgumentsSyntax
-    case .conventionWitnessMethodAttributeArguments: 
+    case .conventionWitnessMethodAttributeArguments:
       return visitImplConventionWitnessMethodAttributeArgumentsSyntax
-    case .declEffectSpecifiers: 
+    case .declEffectSpecifiers:
       return visitImplDeclEffectSpecifiersSyntax
-    case .declModifierDetail: 
+    case .declModifierDetail:
       return visitImplDeclModifierDetailSyntax
-    case .declModifier: 
+    case .declModifier:
       return visitImplDeclModifierSyntax
-    case .declNameArgumentList: 
+    case .declNameArgumentList:
       return visitImplDeclNameArgumentListSyntax
-    case .declNameArgument: 
+    case .declNameArgument:
       return visitImplDeclNameArgumentSyntax
-    case .declNameArguments: 
+    case .declNameArguments:
       return visitImplDeclNameArgumentsSyntax
-    case .declName: 
+    case .declName:
       return visitImplDeclNameSyntax
-    case .deferStmt: 
+    case .deferStmt:
       return visitImplDeferStmtSyntax
-    case .deinitializerDecl: 
+    case .deinitializerDecl:
       return visitImplDeinitializerDeclSyntax
-    case .derivativeRegistrationAttributeArguments: 
+    case .derivativeRegistrationAttributeArguments:
       return visitImplDerivativeRegistrationAttributeArgumentsSyntax
-    case .designatedTypeElement: 
+    case .designatedTypeElement:
       return visitImplDesignatedTypeElementSyntax
-    case .designatedTypeList: 
+    case .designatedTypeList:
       return visitImplDesignatedTypeListSyntax
-    case .dictionaryElementList: 
+    case .dictionaryElementList:
       return visitImplDictionaryElementListSyntax
-    case .dictionaryElement: 
+    case .dictionaryElement:
       return visitImplDictionaryElementSyntax
-    case .dictionaryExpr: 
+    case .dictionaryExpr:
       return visitImplDictionaryExprSyntax
-    case .dictionaryType: 
+    case .dictionaryType:
       return visitImplDictionaryTypeSyntax
-    case .differentiabilityParamList: 
+    case .differentiabilityParamList:
       return visitImplDifferentiabilityParamListSyntax
-    case .differentiabilityParam: 
+    case .differentiabilityParam:
       return visitImplDifferentiabilityParamSyntax
-    case .differentiabilityParamsClause: 
+    case .differentiabilityParamsClause:
       return visitImplDifferentiabilityParamsClauseSyntax
-    case .differentiabilityParams: 
+    case .differentiabilityParams:
       return visitImplDifferentiabilityParamsSyntax
-    case .differentiableAttributeArguments: 
+    case .differentiableAttributeArguments:
       return visitImplDifferentiableAttributeArgumentsSyntax
-    case .discardAssignmentExpr: 
+    case .discardAssignmentExpr:
       return visitImplDiscardAssignmentExprSyntax
-    case .doStmt: 
+    case .doStmt:
       return visitImplDoStmtSyntax
-    case .documentationAttributeArgument: 
+    case .documentationAttributeArgument:
       return visitImplDocumentationAttributeArgumentSyntax
-    case .documentationAttributeArguments: 
+    case .documentationAttributeArguments:
       return visitImplDocumentationAttributeArgumentsSyntax
-    case .dynamicReplacementArguments: 
+    case .dynamicReplacementArguments:
       return visitImplDynamicReplacementArgumentsSyntax
-    case .editorPlaceholderDecl: 
+    case .editorPlaceholderDecl:
       return visitImplEditorPlaceholderDeclSyntax
-    case .editorPlaceholderExpr: 
+    case .editorPlaceholderExpr:
       return visitImplEditorPlaceholderExprSyntax
-    case .effectsArguments: 
+    case .effectsArguments:
       return visitImplEffectsArgumentsSyntax
-    case .enumCaseDecl: 
+    case .enumCaseDecl:
       return visitImplEnumCaseDeclSyntax
-    case .enumCaseElementList: 
+    case .enumCaseElementList:
       return visitImplEnumCaseElementListSyntax
-    case .enumCaseElement: 
+    case .enumCaseElement:
       return visitImplEnumCaseElementSyntax
-    case .enumDecl: 
+    case .enumDecl:
       return visitImplEnumDeclSyntax
-    case .exposeAttributeArguments: 
+    case .exposeAttributeArguments:
       return visitImplExposeAttributeArgumentsSyntax
-    case .exprList: 
+    case .exprList:
       return visitImplExprListSyntax
-    case .expressionPattern: 
+    case .expressionPattern:
       return visitImplExpressionPatternSyntax
-    case .expressionSegment: 
+    case .expressionSegment:
       return visitImplExpressionSegmentSyntax
-    case .expressionStmt: 
+    case .expressionStmt:
       return visitImplExpressionStmtSyntax
-    case .extensionDecl: 
+    case .extensionDecl:
       return visitImplExtensionDeclSyntax
-    case .fallthroughStmt: 
+    case .fallthroughStmt:
       return visitImplFallthroughStmtSyntax
-    case .floatLiteralExpr: 
+    case .floatLiteralExpr:
       return visitImplFloatLiteralExprSyntax
-    case .forInStmt: 
+    case .forInStmt:
       return visitImplForInStmtSyntax
-    case .forcedValueExpr: 
+    case .forcedValueExpr:
       return visitImplForcedValueExprSyntax
-    case .functionCallExpr: 
+    case .functionCallExpr:
       return visitImplFunctionCallExprSyntax
-    case .functionDecl: 
+    case .functionDecl:
       return visitImplFunctionDeclSyntax
-    case .functionParameterList: 
+    case .functionParameterList:
       return visitImplFunctionParameterListSyntax
-    case .functionParameter: 
+    case .functionParameter:
       return visitImplFunctionParameterSyntax
-    case .functionSignature: 
+    case .functionSignature:
       return visitImplFunctionSignatureSyntax
-    case .functionType: 
+    case .functionType:
       return visitImplFunctionTypeSyntax
-    case .genericArgumentClause: 
+    case .genericArgumentClause:
       return visitImplGenericArgumentClauseSyntax
-    case .genericArgumentList: 
+    case .genericArgumentList:
       return visitImplGenericArgumentListSyntax
-    case .genericArgument: 
+    case .genericArgument:
       return visitImplGenericArgumentSyntax
-    case .genericParameterClause: 
+    case .genericParameterClause:
       return visitImplGenericParameterClauseSyntax
-    case .genericParameterList: 
+    case .genericParameterList:
       return visitImplGenericParameterListSyntax
-    case .genericParameter: 
+    case .genericParameter:
       return visitImplGenericParameterSyntax
-    case .genericRequirementList: 
+    case .genericRequirementList:
       return visitImplGenericRequirementListSyntax
-    case .genericRequirement: 
+    case .genericRequirement:
       return visitImplGenericRequirementSyntax
-    case .genericWhereClause: 
+    case .genericWhereClause:
       return visitImplGenericWhereClauseSyntax
-    case .guardStmt: 
+    case .guardStmt:
       return visitImplGuardStmtSyntax
-    case .identifierExpr: 
+    case .identifierExpr:
       return visitImplIdentifierExprSyntax
-    case .identifierPattern: 
+    case .identifierPattern:
       return visitImplIdentifierPatternSyntax
-    case .ifConfigClauseList: 
+    case .ifConfigClauseList:
       return visitImplIfConfigClauseListSyntax
-    case .ifConfigClause: 
+    case .ifConfigClause:
       return visitImplIfConfigClauseSyntax
-    case .ifConfigDecl: 
+    case .ifConfigDecl:
       return visitImplIfConfigDeclSyntax
-    case .ifExpr: 
+    case .ifExpr:
       return visitImplIfExprSyntax
-    case .implementsAttributeArguments: 
+    case .implementsAttributeArguments:
       return visitImplImplementsAttributeArgumentsSyntax
-    case .implicitlyUnwrappedOptionalType: 
+    case .implicitlyUnwrappedOptionalType:
       return visitImplImplicitlyUnwrappedOptionalTypeSyntax
-    case .importDecl: 
+    case .importDecl:
       return visitImplImportDeclSyntax
-    case .inOutExpr: 
+    case .inOutExpr:
       return visitImplInOutExprSyntax
-    case .infixOperatorExpr: 
+    case .infixOperatorExpr:
       return visitImplInfixOperatorExprSyntax
-    case .inheritedTypeList: 
+    case .inheritedTypeList:
       return visitImplInheritedTypeListSyntax
-    case .inheritedType: 
+    case .inheritedType:
       return visitImplInheritedTypeSyntax
-    case .initializerClause: 
+    case .initializerClause:
       return visitImplInitializerClauseSyntax
-    case .initializerDecl: 
+    case .initializerDecl:
       return visitImplInitializerDeclSyntax
-    case .integerLiteralExpr: 
+    case .integerLiteralExpr:
       return visitImplIntegerLiteralExprSyntax
-    case .isExpr: 
+    case .isExpr:
       return visitImplIsExprSyntax
-    case .isTypePattern: 
+    case .isTypePattern:
       return visitImplIsTypePatternSyntax
-    case .keyPathComponentList: 
+    case .keyPathComponentList:
       return visitImplKeyPathComponentListSyntax
-    case .keyPathComponent: 
+    case .keyPathComponent:
       return visitImplKeyPathComponentSyntax
-    case .keyPathExpr: 
+    case .keyPathExpr:
       return visitImplKeyPathExprSyntax
-    case .keyPathOptionalComponent: 
+    case .keyPathOptionalComponent:
       return visitImplKeyPathOptionalComponentSyntax
-    case .keyPathPropertyComponent: 
+    case .keyPathPropertyComponent:
       return visitImplKeyPathPropertyComponentSyntax
-    case .keyPathSubscriptComponent: 
+    case .keyPathSubscriptComponent:
       return visitImplKeyPathSubscriptComponentSyntax
-    case .labeledSpecializeEntry: 
+    case .labeledSpecializeEntry:
       return visitImplLabeledSpecializeEntrySyntax
-    case .labeledStmt: 
+    case .labeledStmt:
       return visitImplLabeledStmtSyntax
-    case .layoutRequirement: 
+    case .layoutRequirement:
       return visitImplLayoutRequirementSyntax
-    case .macroDecl: 
+    case .macroDecl:
       return visitImplMacroDeclSyntax
-    case .macroExpansionDecl: 
+    case .macroExpansionDecl:
       return visitImplMacroExpansionDeclSyntax
-    case .macroExpansionExpr: 
+    case .macroExpansionExpr:
       return visitImplMacroExpansionExprSyntax
-    case .matchingPatternCondition: 
+    case .matchingPatternCondition:
       return visitImplMatchingPatternConditionSyntax
-    case .memberAccessExpr: 
+    case .memberAccessExpr:
       return visitImplMemberAccessExprSyntax
-    case .memberDeclBlock: 
+    case .memberDeclBlock:
       return visitImplMemberDeclBlockSyntax
-    case .memberDeclListItem: 
+    case .memberDeclListItem:
       return visitImplMemberDeclListItemSyntax
-    case .memberDeclList: 
+    case .memberDeclList:
       return visitImplMemberDeclListSyntax
-    case .memberTypeIdentifier: 
+    case .memberTypeIdentifier:
       return visitImplMemberTypeIdentifierSyntax
-    case .metatypeType: 
+    case .metatypeType:
       return visitImplMetatypeTypeSyntax
-    case .missingDecl: 
+    case .missingDecl:
       return visitImplMissingDeclSyntax
-    case .missingExpr: 
+    case .missingExpr:
       return visitImplMissingExprSyntax
-    case .missingPattern: 
+    case .missingPattern:
       return visitImplMissingPatternSyntax
-    case .missingStmt: 
+    case .missingStmt:
       return visitImplMissingStmtSyntax
-    case .missing: 
+    case .missing:
       return visitImplMissingSyntax
-    case .missingType: 
+    case .missingType:
       return visitImplMissingTypeSyntax
-    case .modifierList: 
+    case .modifierList:
       return visitImplModifierListSyntax
-    case .moveExpr: 
+    case .moveExpr:
       return visitImplMoveExprSyntax
-    case .multipleTrailingClosureElementList: 
+    case .multipleTrailingClosureElementList:
       return visitImplMultipleTrailingClosureElementListSyntax
-    case .multipleTrailingClosureElement: 
+    case .multipleTrailingClosureElement:
       return visitImplMultipleTrailingClosureElementSyntax
-    case .namedOpaqueReturnType: 
+    case .namedOpaqueReturnType:
       return visitImplNamedOpaqueReturnTypeSyntax
-    case .nilLiteralExpr: 
+    case .nilLiteralExpr:
       return visitImplNilLiteralExprSyntax
-    case .objCSelectorPiece: 
+    case .objCSelectorPiece:
       return visitImplObjCSelectorPieceSyntax
-    case .objCSelector: 
+    case .objCSelector:
       return visitImplObjCSelectorSyntax
-    case .opaqueReturnTypeOfAttributeArguments: 
+    case .opaqueReturnTypeOfAttributeArguments:
       return visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax
-    case .operatorDecl: 
+    case .operatorDecl:
       return visitImplOperatorDeclSyntax
-    case .operatorPrecedenceAndTypes: 
+    case .operatorPrecedenceAndTypes:
       return visitImplOperatorPrecedenceAndTypesSyntax
-    case .optionalBindingCondition: 
+    case .optionalBindingCondition:
       return visitImplOptionalBindingConditionSyntax
-    case .optionalChainingExpr: 
+    case .optionalChainingExpr:
       return visitImplOptionalChainingExprSyntax
-    case .optionalType: 
+    case .optionalType:
       return visitImplOptionalTypeSyntax
-    case .originallyDefinedInArguments: 
+    case .originallyDefinedInArguments:
       return visitImplOriginallyDefinedInArgumentsSyntax
-    case .packElementExpr: 
+    case .packElementExpr:
       return visitImplPackElementExprSyntax
-    case .packExpansionExpr: 
+    case .packExpansionExpr:
       return visitImplPackExpansionExprSyntax
-    case .packExpansionType: 
+    case .packExpansionType:
       return visitImplPackExpansionTypeSyntax
-    case .packReferenceType: 
+    case .packReferenceType:
       return visitImplPackReferenceTypeSyntax
-    case .parameterClause: 
+    case .parameterClause:
       return visitImplParameterClauseSyntax
-    case .patternBindingList: 
+    case .patternBindingList:
       return visitImplPatternBindingListSyntax
-    case .patternBinding: 
+    case .patternBinding:
       return visitImplPatternBindingSyntax
-    case .postfixIfConfigExpr: 
+    case .postfixIfConfigExpr:
       return visitImplPostfixIfConfigExprSyntax
-    case .postfixUnaryExpr: 
+    case .postfixUnaryExpr:
       return visitImplPostfixUnaryExprSyntax
-    case .poundSourceLocationArgs: 
+    case .poundSourceLocationArgs:
       return visitImplPoundSourceLocationArgsSyntax
-    case .poundSourceLocation: 
+    case .poundSourceLocation:
       return visitImplPoundSourceLocationSyntax
-    case .precedenceGroupAssignment: 
+    case .precedenceGroupAssignment:
       return visitImplPrecedenceGroupAssignmentSyntax
-    case .precedenceGroupAssociativity: 
+    case .precedenceGroupAssociativity:
       return visitImplPrecedenceGroupAssociativitySyntax
-    case .precedenceGroupAttributeList: 
+    case .precedenceGroupAttributeList:
       return visitImplPrecedenceGroupAttributeListSyntax
-    case .precedenceGroupDecl: 
+    case .precedenceGroupDecl:
       return visitImplPrecedenceGroupDeclSyntax
-    case .precedenceGroupNameElement: 
+    case .precedenceGroupNameElement:
       return visitImplPrecedenceGroupNameElementSyntax
-    case .precedenceGroupNameList: 
+    case .precedenceGroupNameList:
       return visitImplPrecedenceGroupNameListSyntax
-    case .precedenceGroupRelation: 
+    case .precedenceGroupRelation:
       return visitImplPrecedenceGroupRelationSyntax
-    case .prefixOperatorExpr: 
+    case .prefixOperatorExpr:
       return visitImplPrefixOperatorExprSyntax
-    case .primaryAssociatedTypeClause: 
+    case .primaryAssociatedTypeClause:
       return visitImplPrimaryAssociatedTypeClauseSyntax
-    case .primaryAssociatedTypeList: 
+    case .primaryAssociatedTypeList:
       return visitImplPrimaryAssociatedTypeListSyntax
-    case .primaryAssociatedType: 
+    case .primaryAssociatedType:
       return visitImplPrimaryAssociatedTypeSyntax
-    case .protocolDecl: 
+    case .protocolDecl:
       return visitImplProtocolDeclSyntax
-    case .qualifiedDeclName: 
+    case .qualifiedDeclName:
       return visitImplQualifiedDeclNameSyntax
-    case .regexLiteralExpr: 
+    case .regexLiteralExpr:
       return visitImplRegexLiteralExprSyntax
-    case .repeatWhileStmt: 
+    case .repeatWhileStmt:
       return visitImplRepeatWhileStmtSyntax
-    case .returnClause: 
+    case .returnClause:
       return visitImplReturnClauseSyntax
-    case .returnStmt: 
+    case .returnStmt:
       return visitImplReturnStmtSyntax
-    case .sameTypeRequirement: 
+    case .sameTypeRequirement:
       return visitImplSameTypeRequirementSyntax
-    case .sequenceExpr: 
+    case .sequenceExpr:
       return visitImplSequenceExprSyntax
-    case .simpleTypeIdentifier: 
+    case .simpleTypeIdentifier:
       return visitImplSimpleTypeIdentifierSyntax
-    case .sourceFile: 
+    case .sourceFile:
       return visitImplSourceFileSyntax
-    case .specializeAttributeSpecList: 
+    case .specializeAttributeSpecList:
       return visitImplSpecializeAttributeSpecListSyntax
-    case .specializeExpr: 
+    case .specializeExpr:
       return visitImplSpecializeExprSyntax
-    case .stringLiteralExpr: 
+    case .stringLiteralExpr:
       return visitImplStringLiteralExprSyntax
-    case .stringLiteralSegments: 
+    case .stringLiteralSegments:
       return visitImplStringLiteralSegmentsSyntax
-    case .stringSegment: 
+    case .stringSegment:
       return visitImplStringSegmentSyntax
-    case .structDecl: 
+    case .structDecl:
       return visitImplStructDeclSyntax
-    case .subscriptDecl: 
+    case .subscriptDecl:
       return visitImplSubscriptDeclSyntax
-    case .subscriptExpr: 
+    case .subscriptExpr:
       return visitImplSubscriptExprSyntax
-    case .superRefExpr: 
+    case .superRefExpr:
       return visitImplSuperRefExprSyntax
-    case .switchCaseLabel: 
+    case .switchCaseLabel:
       return visitImplSwitchCaseLabelSyntax
-    case .switchCaseList: 
+    case .switchCaseList:
       return visitImplSwitchCaseListSyntax
-    case .switchCase: 
+    case .switchCase:
       return visitImplSwitchCaseSyntax
-    case .switchDefaultLabel: 
+    case .switchDefaultLabel:
       return visitImplSwitchDefaultLabelSyntax
-    case .switchExpr: 
+    case .switchExpr:
       return visitImplSwitchExprSyntax
-    case .targetFunctionEntry: 
+    case .targetFunctionEntry:
       return visitImplTargetFunctionEntrySyntax
-    case .ternaryExpr: 
+    case .ternaryExpr:
       return visitImplTernaryExprSyntax
-    case .throwStmt: 
+    case .throwStmt:
       return visitImplThrowStmtSyntax
-    case .tryExpr: 
+    case .tryExpr:
       return visitImplTryExprSyntax
-    case .tupleExprElementList: 
+    case .tupleExprElementList:
       return visitImplTupleExprElementListSyntax
-    case .tupleExprElement: 
+    case .tupleExprElement:
       return visitImplTupleExprElementSyntax
-    case .tupleExpr: 
+    case .tupleExpr:
       return visitImplTupleExprSyntax
-    case .tuplePatternElementList: 
+    case .tuplePatternElementList:
       return visitImplTuplePatternElementListSyntax
-    case .tuplePatternElement: 
+    case .tuplePatternElement:
       return visitImplTuplePatternElementSyntax
-    case .tuplePattern: 
+    case .tuplePattern:
       return visitImplTuplePatternSyntax
-    case .tupleTypeElementList: 
+    case .tupleTypeElementList:
       return visitImplTupleTypeElementListSyntax
-    case .tupleTypeElement: 
+    case .tupleTypeElement:
       return visitImplTupleTypeElementSyntax
-    case .tupleType: 
+    case .tupleType:
       return visitImplTupleTypeSyntax
-    case .typeAnnotation: 
+    case .typeAnnotation:
       return visitImplTypeAnnotationSyntax
-    case .typeEffectSpecifiers: 
+    case .typeEffectSpecifiers:
       return visitImplTypeEffectSpecifiersSyntax
-    case .typeExpr: 
+    case .typeExpr:
       return visitImplTypeExprSyntax
-    case .typeInheritanceClause: 
+    case .typeInheritanceClause:
       return visitImplTypeInheritanceClauseSyntax
-    case .typeInitializerClause: 
+    case .typeInitializerClause:
       return visitImplTypeInitializerClauseSyntax
-    case .typealiasDecl: 
+    case .typealiasDecl:
       return visitImplTypealiasDeclSyntax
-    case .unavailableFromAsyncArguments: 
+    case .unavailableFromAsyncArguments:
       return visitImplUnavailableFromAsyncArgumentsSyntax
-    case .underscorePrivateAttributeArguments: 
+    case .underscorePrivateAttributeArguments:
       return visitImplUnderscorePrivateAttributeArgumentsSyntax
-    case .unexpectedNodes: 
+    case .unexpectedNodes:
       return visitImplUnexpectedNodesSyntax
-    case .unresolvedAsExpr: 
+    case .unresolvedAsExpr:
       return visitImplUnresolvedAsExprSyntax
-    case .unresolvedIsExpr: 
+    case .unresolvedIsExpr:
       return visitImplUnresolvedIsExprSyntax
-    case .unresolvedPatternExpr: 
+    case .unresolvedPatternExpr:
       return visitImplUnresolvedPatternExprSyntax
-    case .unresolvedTernaryExpr: 
+    case .unresolvedTernaryExpr:
       return visitImplUnresolvedTernaryExprSyntax
-    case .valueBindingPattern: 
+    case .valueBindingPattern:
       return visitImplValueBindingPatternSyntax
-    case .variableDecl: 
+    case .variableDecl:
       return visitImplVariableDeclSyntax
-    case .versionTuple: 
+    case .versionTuple:
       return visitImplVersionTupleSyntax
-    case .whereClause: 
+    case .whereClause:
       return visitImplWhereClauseSyntax
-    case .whileStmt: 
+    case .whileStmt:
       return visitImplWhileStmtSyntax
-    case .wildcardPattern: 
+    case .wildcardPattern:
       return visitImplWildcardPatternSyntax
-    case .yieldExprListElement: 
+    case .yieldExprListElement:
       return visitImplYieldExprListElementSyntax
-    case .yieldExprList: 
+    case .yieldExprList:
       return visitImplYieldExprListSyntax
-    case .yieldList: 
+    case .yieldList:
       return visitImplYieldListSyntax
-    case .yieldStmt: 
+    case .yieldStmt:
       return visitImplYieldStmtSyntax
     }
   }
@@ -6131,527 +6131,527 @@ open class SyntaxRewriter {
   #else 
   private func visit(_ data: SyntaxData) -> Syntax {
     switch data.raw.kind {
-    case .token: 
+    case .token:
       return visitImplTokenSyntax(data)
-    case .accessPathComponent: 
+    case .accessPathComponent:
       return visitImplAccessPathComponentSyntax(data)
-    case .accessPath: 
+    case .accessPath:
       return visitImplAccessPathSyntax(data)
-    case .accessorBlock: 
+    case .accessorBlock:
       return visitImplAccessorBlockSyntax(data)
-    case .accessorDecl: 
+    case .accessorDecl:
       return visitImplAccessorDeclSyntax(data)
-    case .accessorList: 
+    case .accessorList:
       return visitImplAccessorListSyntax(data)
-    case .accessorParameter: 
+    case .accessorParameter:
       return visitImplAccessorParameterSyntax(data)
-    case .actorDecl: 
+    case .actorDecl:
       return visitImplActorDeclSyntax(data)
-    case .arrayElementList: 
+    case .arrayElementList:
       return visitImplArrayElementListSyntax(data)
-    case .arrayElement: 
+    case .arrayElement:
       return visitImplArrayElementSyntax(data)
-    case .arrayExpr: 
+    case .arrayExpr:
       return visitImplArrayExprSyntax(data)
-    case .arrayType: 
+    case .arrayType:
       return visitImplArrayTypeSyntax(data)
-    case .arrowExpr: 
+    case .arrowExpr:
       return visitImplArrowExprSyntax(data)
-    case .asExpr: 
+    case .asExpr:
       return visitImplAsExprSyntax(data)
-    case .assignmentExpr: 
+    case .assignmentExpr:
       return visitImplAssignmentExprSyntax(data)
-    case .associatedtypeDecl: 
+    case .associatedtypeDecl:
       return visitImplAssociatedtypeDeclSyntax(data)
-    case .attributeList: 
+    case .attributeList:
       return visitImplAttributeListSyntax(data)
-    case .attribute: 
+    case .attribute:
       return visitImplAttributeSyntax(data)
-    case .attributedType: 
+    case .attributedType:
       return visitImplAttributedTypeSyntax(data)
-    case .availabilityArgument: 
+    case .availabilityArgument:
       return visitImplAvailabilityArgumentSyntax(data)
-    case .availabilityCondition: 
+    case .availabilityCondition:
       return visitImplAvailabilityConditionSyntax(data)
-    case .availabilityEntry: 
+    case .availabilityEntry:
       return visitImplAvailabilityEntrySyntax(data)
-    case .availabilityLabeledArgument: 
+    case .availabilityLabeledArgument:
       return visitImplAvailabilityLabeledArgumentSyntax(data)
-    case .availabilitySpecList: 
+    case .availabilitySpecList:
       return visitImplAvailabilitySpecListSyntax(data)
-    case .availabilityVersionRestrictionListEntry: 
+    case .availabilityVersionRestrictionListEntry:
       return visitImplAvailabilityVersionRestrictionListEntrySyntax(data)
-    case .availabilityVersionRestrictionList: 
+    case .availabilityVersionRestrictionList:
       return visitImplAvailabilityVersionRestrictionListSyntax(data)
-    case .availabilityVersionRestriction: 
+    case .availabilityVersionRestriction:
       return visitImplAvailabilityVersionRestrictionSyntax(data)
-    case .awaitExpr: 
+    case .awaitExpr:
       return visitImplAwaitExprSyntax(data)
-    case .backDeployedAttributeSpecList: 
+    case .backDeployedAttributeSpecList:
       return visitImplBackDeployedAttributeSpecListSyntax(data)
-    case .binaryOperatorExpr: 
+    case .binaryOperatorExpr:
       return visitImplBinaryOperatorExprSyntax(data)
-    case .booleanLiteralExpr: 
+    case .booleanLiteralExpr:
       return visitImplBooleanLiteralExprSyntax(data)
-    case .borrowExpr: 
+    case .borrowExpr:
       return visitImplBorrowExprSyntax(data)
-    case .breakStmt: 
+    case .breakStmt:
       return visitImplBreakStmtSyntax(data)
-    case .caseItemList: 
+    case .caseItemList:
       return visitImplCaseItemListSyntax(data)
-    case .caseItem: 
+    case .caseItem:
       return visitImplCaseItemSyntax(data)
-    case .catchClauseList: 
+    case .catchClauseList:
       return visitImplCatchClauseListSyntax(data)
-    case .catchClause: 
+    case .catchClause:
       return visitImplCatchClauseSyntax(data)
-    case .catchItemList: 
+    case .catchItemList:
       return visitImplCatchItemListSyntax(data)
-    case .catchItem: 
+    case .catchItem:
       return visitImplCatchItemSyntax(data)
-    case .classDecl: 
+    case .classDecl:
       return visitImplClassDeclSyntax(data)
-    case .classRestrictionType: 
+    case .classRestrictionType:
       return visitImplClassRestrictionTypeSyntax(data)
-    case .closureCaptureItemList: 
+    case .closureCaptureItemList:
       return visitImplClosureCaptureItemListSyntax(data)
-    case .closureCaptureItemSpecifier: 
+    case .closureCaptureItemSpecifier:
       return visitImplClosureCaptureItemSpecifierSyntax(data)
-    case .closureCaptureItem: 
+    case .closureCaptureItem:
       return visitImplClosureCaptureItemSyntax(data)
-    case .closureCaptureSignature: 
+    case .closureCaptureSignature:
       return visitImplClosureCaptureSignatureSyntax(data)
-    case .closureExpr: 
+    case .closureExpr:
       return visitImplClosureExprSyntax(data)
-    case .closureParamList: 
+    case .closureParamList:
       return visitImplClosureParamListSyntax(data)
-    case .closureParam: 
+    case .closureParam:
       return visitImplClosureParamSyntax(data)
-    case .closureSignature: 
+    case .closureSignature:
       return visitImplClosureSignatureSyntax(data)
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       return visitImplCodeBlockItemListSyntax(data)
-    case .codeBlockItem: 
+    case .codeBlockItem:
       return visitImplCodeBlockItemSyntax(data)
-    case .codeBlock: 
+    case .codeBlock:
       return visitImplCodeBlockSyntax(data)
-    case .compositionTypeElementList: 
+    case .compositionTypeElementList:
       return visitImplCompositionTypeElementListSyntax(data)
-    case .compositionTypeElement: 
+    case .compositionTypeElement:
       return visitImplCompositionTypeElementSyntax(data)
-    case .compositionType: 
+    case .compositionType:
       return visitImplCompositionTypeSyntax(data)
-    case .conditionElementList: 
+    case .conditionElementList:
       return visitImplConditionElementListSyntax(data)
-    case .conditionElement: 
+    case .conditionElement:
       return visitImplConditionElementSyntax(data)
-    case .conformanceRequirement: 
+    case .conformanceRequirement:
       return visitImplConformanceRequirementSyntax(data)
-    case .constrainedSugarType: 
+    case .constrainedSugarType:
       return visitImplConstrainedSugarTypeSyntax(data)
-    case .continueStmt: 
+    case .continueStmt:
       return visitImplContinueStmtSyntax(data)
-    case .conventionAttributeArguments: 
+    case .conventionAttributeArguments:
       return visitImplConventionAttributeArgumentsSyntax(data)
-    case .conventionWitnessMethodAttributeArguments: 
+    case .conventionWitnessMethodAttributeArguments:
       return visitImplConventionWitnessMethodAttributeArgumentsSyntax(data)
-    case .declEffectSpecifiers: 
+    case .declEffectSpecifiers:
       return visitImplDeclEffectSpecifiersSyntax(data)
-    case .declModifierDetail: 
+    case .declModifierDetail:
       return visitImplDeclModifierDetailSyntax(data)
-    case .declModifier: 
+    case .declModifier:
       return visitImplDeclModifierSyntax(data)
-    case .declNameArgumentList: 
+    case .declNameArgumentList:
       return visitImplDeclNameArgumentListSyntax(data)
-    case .declNameArgument: 
+    case .declNameArgument:
       return visitImplDeclNameArgumentSyntax(data)
-    case .declNameArguments: 
+    case .declNameArguments:
       return visitImplDeclNameArgumentsSyntax(data)
-    case .declName: 
+    case .declName:
       return visitImplDeclNameSyntax(data)
-    case .deferStmt: 
+    case .deferStmt:
       return visitImplDeferStmtSyntax(data)
-    case .deinitializerDecl: 
+    case .deinitializerDecl:
       return visitImplDeinitializerDeclSyntax(data)
-    case .derivativeRegistrationAttributeArguments: 
+    case .derivativeRegistrationAttributeArguments:
       return visitImplDerivativeRegistrationAttributeArgumentsSyntax(data)
-    case .designatedTypeElement: 
+    case .designatedTypeElement:
       return visitImplDesignatedTypeElementSyntax(data)
-    case .designatedTypeList: 
+    case .designatedTypeList:
       return visitImplDesignatedTypeListSyntax(data)
-    case .dictionaryElementList: 
+    case .dictionaryElementList:
       return visitImplDictionaryElementListSyntax(data)
-    case .dictionaryElement: 
+    case .dictionaryElement:
       return visitImplDictionaryElementSyntax(data)
-    case .dictionaryExpr: 
+    case .dictionaryExpr:
       return visitImplDictionaryExprSyntax(data)
-    case .dictionaryType: 
+    case .dictionaryType:
       return visitImplDictionaryTypeSyntax(data)
-    case .differentiabilityParamList: 
+    case .differentiabilityParamList:
       return visitImplDifferentiabilityParamListSyntax(data)
-    case .differentiabilityParam: 
+    case .differentiabilityParam:
       return visitImplDifferentiabilityParamSyntax(data)
-    case .differentiabilityParamsClause: 
+    case .differentiabilityParamsClause:
       return visitImplDifferentiabilityParamsClauseSyntax(data)
-    case .differentiabilityParams: 
+    case .differentiabilityParams:
       return visitImplDifferentiabilityParamsSyntax(data)
-    case .differentiableAttributeArguments: 
+    case .differentiableAttributeArguments:
       return visitImplDifferentiableAttributeArgumentsSyntax(data)
-    case .discardAssignmentExpr: 
+    case .discardAssignmentExpr:
       return visitImplDiscardAssignmentExprSyntax(data)
-    case .doStmt: 
+    case .doStmt:
       return visitImplDoStmtSyntax(data)
-    case .documentationAttributeArgument: 
+    case .documentationAttributeArgument:
       return visitImplDocumentationAttributeArgumentSyntax(data)
-    case .documentationAttributeArguments: 
+    case .documentationAttributeArguments:
       return visitImplDocumentationAttributeArgumentsSyntax(data)
-    case .dynamicReplacementArguments: 
+    case .dynamicReplacementArguments:
       return visitImplDynamicReplacementArgumentsSyntax(data)
-    case .editorPlaceholderDecl: 
+    case .editorPlaceholderDecl:
       return visitImplEditorPlaceholderDeclSyntax(data)
-    case .editorPlaceholderExpr: 
+    case .editorPlaceholderExpr:
       return visitImplEditorPlaceholderExprSyntax(data)
-    case .effectsArguments: 
+    case .effectsArguments:
       return visitImplEffectsArgumentsSyntax(data)
-    case .enumCaseDecl: 
+    case .enumCaseDecl:
       return visitImplEnumCaseDeclSyntax(data)
-    case .enumCaseElementList: 
+    case .enumCaseElementList:
       return visitImplEnumCaseElementListSyntax(data)
-    case .enumCaseElement: 
+    case .enumCaseElement:
       return visitImplEnumCaseElementSyntax(data)
-    case .enumDecl: 
+    case .enumDecl:
       return visitImplEnumDeclSyntax(data)
-    case .exposeAttributeArguments: 
+    case .exposeAttributeArguments:
       return visitImplExposeAttributeArgumentsSyntax(data)
-    case .exprList: 
+    case .exprList:
       return visitImplExprListSyntax(data)
-    case .expressionPattern: 
+    case .expressionPattern:
       return visitImplExpressionPatternSyntax(data)
-    case .expressionSegment: 
+    case .expressionSegment:
       return visitImplExpressionSegmentSyntax(data)
-    case .expressionStmt: 
+    case .expressionStmt:
       return visitImplExpressionStmtSyntax(data)
-    case .extensionDecl: 
+    case .extensionDecl:
       return visitImplExtensionDeclSyntax(data)
-    case .fallthroughStmt: 
+    case .fallthroughStmt:
       return visitImplFallthroughStmtSyntax(data)
-    case .floatLiteralExpr: 
+    case .floatLiteralExpr:
       return visitImplFloatLiteralExprSyntax(data)
-    case .forInStmt: 
+    case .forInStmt:
       return visitImplForInStmtSyntax(data)
-    case .forcedValueExpr: 
+    case .forcedValueExpr:
       return visitImplForcedValueExprSyntax(data)
-    case .functionCallExpr: 
+    case .functionCallExpr:
       return visitImplFunctionCallExprSyntax(data)
-    case .functionDecl: 
+    case .functionDecl:
       return visitImplFunctionDeclSyntax(data)
-    case .functionParameterList: 
+    case .functionParameterList:
       return visitImplFunctionParameterListSyntax(data)
-    case .functionParameter: 
+    case .functionParameter:
       return visitImplFunctionParameterSyntax(data)
-    case .functionSignature: 
+    case .functionSignature:
       return visitImplFunctionSignatureSyntax(data)
-    case .functionType: 
+    case .functionType:
       return visitImplFunctionTypeSyntax(data)
-    case .genericArgumentClause: 
+    case .genericArgumentClause:
       return visitImplGenericArgumentClauseSyntax(data)
-    case .genericArgumentList: 
+    case .genericArgumentList:
       return visitImplGenericArgumentListSyntax(data)
-    case .genericArgument: 
+    case .genericArgument:
       return visitImplGenericArgumentSyntax(data)
-    case .genericParameterClause: 
+    case .genericParameterClause:
       return visitImplGenericParameterClauseSyntax(data)
-    case .genericParameterList: 
+    case .genericParameterList:
       return visitImplGenericParameterListSyntax(data)
-    case .genericParameter: 
+    case .genericParameter:
       return visitImplGenericParameterSyntax(data)
-    case .genericRequirementList: 
+    case .genericRequirementList:
       return visitImplGenericRequirementListSyntax(data)
-    case .genericRequirement: 
+    case .genericRequirement:
       return visitImplGenericRequirementSyntax(data)
-    case .genericWhereClause: 
+    case .genericWhereClause:
       return visitImplGenericWhereClauseSyntax(data)
-    case .guardStmt: 
+    case .guardStmt:
       return visitImplGuardStmtSyntax(data)
-    case .identifierExpr: 
+    case .identifierExpr:
       return visitImplIdentifierExprSyntax(data)
-    case .identifierPattern: 
+    case .identifierPattern:
       return visitImplIdentifierPatternSyntax(data)
-    case .ifConfigClauseList: 
+    case .ifConfigClauseList:
       return visitImplIfConfigClauseListSyntax(data)
-    case .ifConfigClause: 
+    case .ifConfigClause:
       return visitImplIfConfigClauseSyntax(data)
-    case .ifConfigDecl: 
+    case .ifConfigDecl:
       return visitImplIfConfigDeclSyntax(data)
-    case .ifExpr: 
+    case .ifExpr:
       return visitImplIfExprSyntax(data)
-    case .implementsAttributeArguments: 
+    case .implementsAttributeArguments:
       return visitImplImplementsAttributeArgumentsSyntax(data)
-    case .implicitlyUnwrappedOptionalType: 
+    case .implicitlyUnwrappedOptionalType:
       return visitImplImplicitlyUnwrappedOptionalTypeSyntax(data)
-    case .importDecl: 
+    case .importDecl:
       return visitImplImportDeclSyntax(data)
-    case .inOutExpr: 
+    case .inOutExpr:
       return visitImplInOutExprSyntax(data)
-    case .infixOperatorExpr: 
+    case .infixOperatorExpr:
       return visitImplInfixOperatorExprSyntax(data)
-    case .inheritedTypeList: 
+    case .inheritedTypeList:
       return visitImplInheritedTypeListSyntax(data)
-    case .inheritedType: 
+    case .inheritedType:
       return visitImplInheritedTypeSyntax(data)
-    case .initializerClause: 
+    case .initializerClause:
       return visitImplInitializerClauseSyntax(data)
-    case .initializerDecl: 
+    case .initializerDecl:
       return visitImplInitializerDeclSyntax(data)
-    case .integerLiteralExpr: 
+    case .integerLiteralExpr:
       return visitImplIntegerLiteralExprSyntax(data)
-    case .isExpr: 
+    case .isExpr:
       return visitImplIsExprSyntax(data)
-    case .isTypePattern: 
+    case .isTypePattern:
       return visitImplIsTypePatternSyntax(data)
-    case .keyPathComponentList: 
+    case .keyPathComponentList:
       return visitImplKeyPathComponentListSyntax(data)
-    case .keyPathComponent: 
+    case .keyPathComponent:
       return visitImplKeyPathComponentSyntax(data)
-    case .keyPathExpr: 
+    case .keyPathExpr:
       return visitImplKeyPathExprSyntax(data)
-    case .keyPathOptionalComponent: 
+    case .keyPathOptionalComponent:
       return visitImplKeyPathOptionalComponentSyntax(data)
-    case .keyPathPropertyComponent: 
+    case .keyPathPropertyComponent:
       return visitImplKeyPathPropertyComponentSyntax(data)
-    case .keyPathSubscriptComponent: 
+    case .keyPathSubscriptComponent:
       return visitImplKeyPathSubscriptComponentSyntax(data)
-    case .labeledSpecializeEntry: 
+    case .labeledSpecializeEntry:
       return visitImplLabeledSpecializeEntrySyntax(data)
-    case .labeledStmt: 
+    case .labeledStmt:
       return visitImplLabeledStmtSyntax(data)
-    case .layoutRequirement: 
+    case .layoutRequirement:
       return visitImplLayoutRequirementSyntax(data)
-    case .macroDecl: 
+    case .macroDecl:
       return visitImplMacroDeclSyntax(data)
-    case .macroExpansionDecl: 
+    case .macroExpansionDecl:
       return visitImplMacroExpansionDeclSyntax(data)
-    case .macroExpansionExpr: 
+    case .macroExpansionExpr:
       return visitImplMacroExpansionExprSyntax(data)
-    case .matchingPatternCondition: 
+    case .matchingPatternCondition:
       return visitImplMatchingPatternConditionSyntax(data)
-    case .memberAccessExpr: 
+    case .memberAccessExpr:
       return visitImplMemberAccessExprSyntax(data)
-    case .memberDeclBlock: 
+    case .memberDeclBlock:
       return visitImplMemberDeclBlockSyntax(data)
-    case .memberDeclListItem: 
+    case .memberDeclListItem:
       return visitImplMemberDeclListItemSyntax(data)
-    case .memberDeclList: 
+    case .memberDeclList:
       return visitImplMemberDeclListSyntax(data)
-    case .memberTypeIdentifier: 
+    case .memberTypeIdentifier:
       return visitImplMemberTypeIdentifierSyntax(data)
-    case .metatypeType: 
+    case .metatypeType:
       return visitImplMetatypeTypeSyntax(data)
-    case .missingDecl: 
+    case .missingDecl:
       return visitImplMissingDeclSyntax(data)
-    case .missingExpr: 
+    case .missingExpr:
       return visitImplMissingExprSyntax(data)
-    case .missingPattern: 
+    case .missingPattern:
       return visitImplMissingPatternSyntax(data)
-    case .missingStmt: 
+    case .missingStmt:
       return visitImplMissingStmtSyntax(data)
-    case .missing: 
+    case .missing:
       return visitImplMissingSyntax(data)
-    case .missingType: 
+    case .missingType:
       return visitImplMissingTypeSyntax(data)
-    case .modifierList: 
+    case .modifierList:
       return visitImplModifierListSyntax(data)
-    case .moveExpr: 
+    case .moveExpr:
       return visitImplMoveExprSyntax(data)
-    case .multipleTrailingClosureElementList: 
+    case .multipleTrailingClosureElementList:
       return visitImplMultipleTrailingClosureElementListSyntax(data)
-    case .multipleTrailingClosureElement: 
+    case .multipleTrailingClosureElement:
       return visitImplMultipleTrailingClosureElementSyntax(data)
-    case .namedOpaqueReturnType: 
+    case .namedOpaqueReturnType:
       return visitImplNamedOpaqueReturnTypeSyntax(data)
-    case .nilLiteralExpr: 
+    case .nilLiteralExpr:
       return visitImplNilLiteralExprSyntax(data)
-    case .objCSelectorPiece: 
+    case .objCSelectorPiece:
       return visitImplObjCSelectorPieceSyntax(data)
-    case .objCSelector: 
+    case .objCSelector:
       return visitImplObjCSelectorSyntax(data)
-    case .opaqueReturnTypeOfAttributeArguments: 
+    case .opaqueReturnTypeOfAttributeArguments:
       return visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax(data)
-    case .operatorDecl: 
+    case .operatorDecl:
       return visitImplOperatorDeclSyntax(data)
-    case .operatorPrecedenceAndTypes: 
+    case .operatorPrecedenceAndTypes:
       return visitImplOperatorPrecedenceAndTypesSyntax(data)
-    case .optionalBindingCondition: 
+    case .optionalBindingCondition:
       return visitImplOptionalBindingConditionSyntax(data)
-    case .optionalChainingExpr: 
+    case .optionalChainingExpr:
       return visitImplOptionalChainingExprSyntax(data)
-    case .optionalType: 
+    case .optionalType:
       return visitImplOptionalTypeSyntax(data)
-    case .originallyDefinedInArguments: 
+    case .originallyDefinedInArguments:
       return visitImplOriginallyDefinedInArgumentsSyntax(data)
-    case .packElementExpr: 
+    case .packElementExpr:
       return visitImplPackElementExprSyntax(data)
-    case .packExpansionExpr: 
+    case .packExpansionExpr:
       return visitImplPackExpansionExprSyntax(data)
-    case .packExpansionType: 
+    case .packExpansionType:
       return visitImplPackExpansionTypeSyntax(data)
-    case .packReferenceType: 
+    case .packReferenceType:
       return visitImplPackReferenceTypeSyntax(data)
-    case .parameterClause: 
+    case .parameterClause:
       return visitImplParameterClauseSyntax(data)
-    case .patternBindingList: 
+    case .patternBindingList:
       return visitImplPatternBindingListSyntax(data)
-    case .patternBinding: 
+    case .patternBinding:
       return visitImplPatternBindingSyntax(data)
-    case .postfixIfConfigExpr: 
+    case .postfixIfConfigExpr:
       return visitImplPostfixIfConfigExprSyntax(data)
-    case .postfixUnaryExpr: 
+    case .postfixUnaryExpr:
       return visitImplPostfixUnaryExprSyntax(data)
-    case .poundSourceLocationArgs: 
+    case .poundSourceLocationArgs:
       return visitImplPoundSourceLocationArgsSyntax(data)
-    case .poundSourceLocation: 
+    case .poundSourceLocation:
       return visitImplPoundSourceLocationSyntax(data)
-    case .precedenceGroupAssignment: 
+    case .precedenceGroupAssignment:
       return visitImplPrecedenceGroupAssignmentSyntax(data)
-    case .precedenceGroupAssociativity: 
+    case .precedenceGroupAssociativity:
       return visitImplPrecedenceGroupAssociativitySyntax(data)
-    case .precedenceGroupAttributeList: 
+    case .precedenceGroupAttributeList:
       return visitImplPrecedenceGroupAttributeListSyntax(data)
-    case .precedenceGroupDecl: 
+    case .precedenceGroupDecl:
       return visitImplPrecedenceGroupDeclSyntax(data)
-    case .precedenceGroupNameElement: 
+    case .precedenceGroupNameElement:
       return visitImplPrecedenceGroupNameElementSyntax(data)
-    case .precedenceGroupNameList: 
+    case .precedenceGroupNameList:
       return visitImplPrecedenceGroupNameListSyntax(data)
-    case .precedenceGroupRelation: 
+    case .precedenceGroupRelation:
       return visitImplPrecedenceGroupRelationSyntax(data)
-    case .prefixOperatorExpr: 
+    case .prefixOperatorExpr:
       return visitImplPrefixOperatorExprSyntax(data)
-    case .primaryAssociatedTypeClause: 
+    case .primaryAssociatedTypeClause:
       return visitImplPrimaryAssociatedTypeClauseSyntax(data)
-    case .primaryAssociatedTypeList: 
+    case .primaryAssociatedTypeList:
       return visitImplPrimaryAssociatedTypeListSyntax(data)
-    case .primaryAssociatedType: 
+    case .primaryAssociatedType:
       return visitImplPrimaryAssociatedTypeSyntax(data)
-    case .protocolDecl: 
+    case .protocolDecl:
       return visitImplProtocolDeclSyntax(data)
-    case .qualifiedDeclName: 
+    case .qualifiedDeclName:
       return visitImplQualifiedDeclNameSyntax(data)
-    case .regexLiteralExpr: 
+    case .regexLiteralExpr:
       return visitImplRegexLiteralExprSyntax(data)
-    case .repeatWhileStmt: 
+    case .repeatWhileStmt:
       return visitImplRepeatWhileStmtSyntax(data)
-    case .returnClause: 
+    case .returnClause:
       return visitImplReturnClauseSyntax(data)
-    case .returnStmt: 
+    case .returnStmt:
       return visitImplReturnStmtSyntax(data)
-    case .sameTypeRequirement: 
+    case .sameTypeRequirement:
       return visitImplSameTypeRequirementSyntax(data)
-    case .sequenceExpr: 
+    case .sequenceExpr:
       return visitImplSequenceExprSyntax(data)
-    case .simpleTypeIdentifier: 
+    case .simpleTypeIdentifier:
       return visitImplSimpleTypeIdentifierSyntax(data)
-    case .sourceFile: 
+    case .sourceFile:
       return visitImplSourceFileSyntax(data)
-    case .specializeAttributeSpecList: 
+    case .specializeAttributeSpecList:
       return visitImplSpecializeAttributeSpecListSyntax(data)
-    case .specializeExpr: 
+    case .specializeExpr:
       return visitImplSpecializeExprSyntax(data)
-    case .stringLiteralExpr: 
+    case .stringLiteralExpr:
       return visitImplStringLiteralExprSyntax(data)
-    case .stringLiteralSegments: 
+    case .stringLiteralSegments:
       return visitImplStringLiteralSegmentsSyntax(data)
-    case .stringSegment: 
+    case .stringSegment:
       return visitImplStringSegmentSyntax(data)
-    case .structDecl: 
+    case .structDecl:
       return visitImplStructDeclSyntax(data)
-    case .subscriptDecl: 
+    case .subscriptDecl:
       return visitImplSubscriptDeclSyntax(data)
-    case .subscriptExpr: 
+    case .subscriptExpr:
       return visitImplSubscriptExprSyntax(data)
-    case .superRefExpr: 
+    case .superRefExpr:
       return visitImplSuperRefExprSyntax(data)
-    case .switchCaseLabel: 
+    case .switchCaseLabel:
       return visitImplSwitchCaseLabelSyntax(data)
-    case .switchCaseList: 
+    case .switchCaseList:
       return visitImplSwitchCaseListSyntax(data)
-    case .switchCase: 
+    case .switchCase:
       return visitImplSwitchCaseSyntax(data)
-    case .switchDefaultLabel: 
+    case .switchDefaultLabel:
       return visitImplSwitchDefaultLabelSyntax(data)
-    case .switchExpr: 
+    case .switchExpr:
       return visitImplSwitchExprSyntax(data)
-    case .targetFunctionEntry: 
+    case .targetFunctionEntry:
       return visitImplTargetFunctionEntrySyntax(data)
-    case .ternaryExpr: 
+    case .ternaryExpr:
       return visitImplTernaryExprSyntax(data)
-    case .throwStmt: 
+    case .throwStmt:
       return visitImplThrowStmtSyntax(data)
-    case .tryExpr: 
+    case .tryExpr:
       return visitImplTryExprSyntax(data)
-    case .tupleExprElementList: 
+    case .tupleExprElementList:
       return visitImplTupleExprElementListSyntax(data)
-    case .tupleExprElement: 
+    case .tupleExprElement:
       return visitImplTupleExprElementSyntax(data)
-    case .tupleExpr: 
+    case .tupleExpr:
       return visitImplTupleExprSyntax(data)
-    case .tuplePatternElementList: 
+    case .tuplePatternElementList:
       return visitImplTuplePatternElementListSyntax(data)
-    case .tuplePatternElement: 
+    case .tuplePatternElement:
       return visitImplTuplePatternElementSyntax(data)
-    case .tuplePattern: 
+    case .tuplePattern:
       return visitImplTuplePatternSyntax(data)
-    case .tupleTypeElementList: 
+    case .tupleTypeElementList:
       return visitImplTupleTypeElementListSyntax(data)
-    case .tupleTypeElement: 
+    case .tupleTypeElement:
       return visitImplTupleTypeElementSyntax(data)
-    case .tupleType: 
+    case .tupleType:
       return visitImplTupleTypeSyntax(data)
-    case .typeAnnotation: 
+    case .typeAnnotation:
       return visitImplTypeAnnotationSyntax(data)
-    case .typeEffectSpecifiers: 
+    case .typeEffectSpecifiers:
       return visitImplTypeEffectSpecifiersSyntax(data)
-    case .typeExpr: 
+    case .typeExpr:
       return visitImplTypeExprSyntax(data)
-    case .typeInheritanceClause: 
+    case .typeInheritanceClause:
       return visitImplTypeInheritanceClauseSyntax(data)
-    case .typeInitializerClause: 
+    case .typeInitializerClause:
       return visitImplTypeInitializerClauseSyntax(data)
-    case .typealiasDecl: 
+    case .typealiasDecl:
       return visitImplTypealiasDeclSyntax(data)
-    case .unavailableFromAsyncArguments: 
+    case .unavailableFromAsyncArguments:
       return visitImplUnavailableFromAsyncArgumentsSyntax(data)
-    case .underscorePrivateAttributeArguments: 
+    case .underscorePrivateAttributeArguments:
       return visitImplUnderscorePrivateAttributeArgumentsSyntax(data)
-    case .unexpectedNodes: 
+    case .unexpectedNodes:
       return visitImplUnexpectedNodesSyntax(data)
-    case .unresolvedAsExpr: 
+    case .unresolvedAsExpr:
       return visitImplUnresolvedAsExprSyntax(data)
-    case .unresolvedIsExpr: 
+    case .unresolvedIsExpr:
       return visitImplUnresolvedIsExprSyntax(data)
-    case .unresolvedPatternExpr: 
+    case .unresolvedPatternExpr:
       return visitImplUnresolvedPatternExprSyntax(data)
-    case .unresolvedTernaryExpr: 
+    case .unresolvedTernaryExpr:
       return visitImplUnresolvedTernaryExprSyntax(data)
-    case .valueBindingPattern: 
+    case .valueBindingPattern:
       return visitImplValueBindingPatternSyntax(data)
-    case .variableDecl: 
+    case .variableDecl:
       return visitImplVariableDeclSyntax(data)
-    case .versionTuple: 
+    case .versionTuple:
       return visitImplVersionTupleSyntax(data)
-    case .whereClause: 
+    case .whereClause:
       return visitImplWhereClauseSyntax(data)
-    case .whileStmt: 
+    case .whileStmt:
       return visitImplWhileStmtSyntax(data)
-    case .wildcardPattern: 
+    case .wildcardPattern:
       return visitImplWildcardPatternSyntax(data)
-    case .yieldExprListElement: 
+    case .yieldExprListElement:
       return visitImplYieldExprListElementSyntax(data)
-    case .yieldExprList: 
+    case .yieldExprList:
       return visitImplYieldExprListSyntax(data)
-    case .yieldList: 
+    case .yieldList:
       return visitImplYieldListSyntax(data)
-    case .yieldStmt: 
+    case .yieldStmt:
       return visitImplYieldStmtSyntax(data)
     }
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift
index b956e57bab1..5d33eddb874 100644
--- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift
@@ -3149,527 +3149,527 @@ extension SyntaxTransformVisitor {
   
   public func visit(_ node: Syntax) -> ResultType {
     switch node.as(SyntaxEnum.self) {
-    case .token(let node): 
+    case .token(let node):
       return visit(node)
-    case .accessPathComponent(let derived): 
+    case .accessPathComponent(let derived):
       return visit(derived)
-    case .accessPath(let derived): 
+    case .accessPath(let derived):
       return visit(derived)
-    case .accessorBlock(let derived): 
+    case .accessorBlock(let derived):
       return visit(derived)
-    case .accessorDecl(let derived): 
+    case .accessorDecl(let derived):
       return visit(derived)
-    case .accessorList(let derived): 
+    case .accessorList(let derived):
       return visit(derived)
-    case .accessorParameter(let derived): 
+    case .accessorParameter(let derived):
       return visit(derived)
-    case .actorDecl(let derived): 
+    case .actorDecl(let derived):
       return visit(derived)
-    case .arrayElementList(let derived): 
+    case .arrayElementList(let derived):
       return visit(derived)
-    case .arrayElement(let derived): 
+    case .arrayElement(let derived):
       return visit(derived)
-    case .arrayExpr(let derived): 
+    case .arrayExpr(let derived):
       return visit(derived)
-    case .arrayType(let derived): 
+    case .arrayType(let derived):
       return visit(derived)
-    case .arrowExpr(let derived): 
+    case .arrowExpr(let derived):
       return visit(derived)
-    case .asExpr(let derived): 
+    case .asExpr(let derived):
       return visit(derived)
-    case .assignmentExpr(let derived): 
+    case .assignmentExpr(let derived):
       return visit(derived)
-    case .associatedtypeDecl(let derived): 
+    case .associatedtypeDecl(let derived):
       return visit(derived)
-    case .attributeList(let derived): 
+    case .attributeList(let derived):
       return visit(derived)
-    case .attribute(let derived): 
+    case .attribute(let derived):
       return visit(derived)
-    case .attributedType(let derived): 
+    case .attributedType(let derived):
       return visit(derived)
-    case .availabilityArgument(let derived): 
+    case .availabilityArgument(let derived):
       return visit(derived)
-    case .availabilityCondition(let derived): 
+    case .availabilityCondition(let derived):
       return visit(derived)
-    case .availabilityEntry(let derived): 
+    case .availabilityEntry(let derived):
       return visit(derived)
-    case .availabilityLabeledArgument(let derived): 
+    case .availabilityLabeledArgument(let derived):
       return visit(derived)
-    case .availabilitySpecList(let derived): 
+    case .availabilitySpecList(let derived):
       return visit(derived)
-    case .availabilityVersionRestrictionListEntry(let derived): 
+    case .availabilityVersionRestrictionListEntry(let derived):
       return visit(derived)
-    case .availabilityVersionRestrictionList(let derived): 
+    case .availabilityVersionRestrictionList(let derived):
       return visit(derived)
-    case .availabilityVersionRestriction(let derived): 
+    case .availabilityVersionRestriction(let derived):
       return visit(derived)
-    case .awaitExpr(let derived): 
+    case .awaitExpr(let derived):
       return visit(derived)
-    case .backDeployedAttributeSpecList(let derived): 
+    case .backDeployedAttributeSpecList(let derived):
       return visit(derived)
-    case .binaryOperatorExpr(let derived): 
+    case .binaryOperatorExpr(let derived):
       return visit(derived)
-    case .booleanLiteralExpr(let derived): 
+    case .booleanLiteralExpr(let derived):
       return visit(derived)
-    case .borrowExpr(let derived): 
+    case .borrowExpr(let derived):
       return visit(derived)
-    case .breakStmt(let derived): 
+    case .breakStmt(let derived):
       return visit(derived)
-    case .caseItemList(let derived): 
+    case .caseItemList(let derived):
       return visit(derived)
-    case .caseItem(let derived): 
+    case .caseItem(let derived):
       return visit(derived)
-    case .catchClauseList(let derived): 
+    case .catchClauseList(let derived):
       return visit(derived)
-    case .catchClause(let derived): 
+    case .catchClause(let derived):
       return visit(derived)
-    case .catchItemList(let derived): 
+    case .catchItemList(let derived):
       return visit(derived)
-    case .catchItem(let derived): 
+    case .catchItem(let derived):
       return visit(derived)
-    case .classDecl(let derived): 
+    case .classDecl(let derived):
       return visit(derived)
-    case .classRestrictionType(let derived): 
+    case .classRestrictionType(let derived):
       return visit(derived)
-    case .closureCaptureItemList(let derived): 
+    case .closureCaptureItemList(let derived):
       return visit(derived)
-    case .closureCaptureItemSpecifier(let derived): 
+    case .closureCaptureItemSpecifier(let derived):
       return visit(derived)
-    case .closureCaptureItem(let derived): 
+    case .closureCaptureItem(let derived):
       return visit(derived)
-    case .closureCaptureSignature(let derived): 
+    case .closureCaptureSignature(let derived):
       return visit(derived)
-    case .closureExpr(let derived): 
+    case .closureExpr(let derived):
       return visit(derived)
-    case .closureParamList(let derived): 
+    case .closureParamList(let derived):
       return visit(derived)
-    case .closureParam(let derived): 
+    case .closureParam(let derived):
       return visit(derived)
-    case .closureSignature(let derived): 
+    case .closureSignature(let derived):
       return visit(derived)
-    case .codeBlockItemList(let derived): 
+    case .codeBlockItemList(let derived):
       return visit(derived)
-    case .codeBlockItem(let derived): 
+    case .codeBlockItem(let derived):
       return visit(derived)
-    case .codeBlock(let derived): 
+    case .codeBlock(let derived):
       return visit(derived)
-    case .compositionTypeElementList(let derived): 
+    case .compositionTypeElementList(let derived):
       return visit(derived)
-    case .compositionTypeElement(let derived): 
+    case .compositionTypeElement(let derived):
       return visit(derived)
-    case .compositionType(let derived): 
+    case .compositionType(let derived):
       return visit(derived)
-    case .conditionElementList(let derived): 
+    case .conditionElementList(let derived):
       return visit(derived)
-    case .conditionElement(let derived): 
+    case .conditionElement(let derived):
       return visit(derived)
-    case .conformanceRequirement(let derived): 
+    case .conformanceRequirement(let derived):
       return visit(derived)
-    case .constrainedSugarType(let derived): 
+    case .constrainedSugarType(let derived):
       return visit(derived)
-    case .continueStmt(let derived): 
+    case .continueStmt(let derived):
       return visit(derived)
-    case .conventionAttributeArguments(let derived): 
+    case .conventionAttributeArguments(let derived):
       return visit(derived)
-    case .conventionWitnessMethodAttributeArguments(let derived): 
+    case .conventionWitnessMethodAttributeArguments(let derived):
       return visit(derived)
-    case .declEffectSpecifiers(let derived): 
+    case .declEffectSpecifiers(let derived):
       return visit(derived)
-    case .declModifierDetail(let derived): 
+    case .declModifierDetail(let derived):
       return visit(derived)
-    case .declModifier(let derived): 
+    case .declModifier(let derived):
       return visit(derived)
-    case .declNameArgumentList(let derived): 
+    case .declNameArgumentList(let derived):
       return visit(derived)
-    case .declNameArgument(let derived): 
+    case .declNameArgument(let derived):
       return visit(derived)
-    case .declNameArguments(let derived): 
+    case .declNameArguments(let derived):
       return visit(derived)
-    case .declName(let derived): 
+    case .declName(let derived):
       return visit(derived)
-    case .deferStmt(let derived): 
+    case .deferStmt(let derived):
       return visit(derived)
-    case .deinitializerDecl(let derived): 
+    case .deinitializerDecl(let derived):
       return visit(derived)
-    case .derivativeRegistrationAttributeArguments(let derived): 
+    case .derivativeRegistrationAttributeArguments(let derived):
       return visit(derived)
-    case .designatedTypeElement(let derived): 
+    case .designatedTypeElement(let derived):
       return visit(derived)
-    case .designatedTypeList(let derived): 
+    case .designatedTypeList(let derived):
       return visit(derived)
-    case .dictionaryElementList(let derived): 
+    case .dictionaryElementList(let derived):
       return visit(derived)
-    case .dictionaryElement(let derived): 
+    case .dictionaryElement(let derived):
       return visit(derived)
-    case .dictionaryExpr(let derived): 
+    case .dictionaryExpr(let derived):
       return visit(derived)
-    case .dictionaryType(let derived): 
+    case .dictionaryType(let derived):
       return visit(derived)
-    case .differentiabilityParamList(let derived): 
+    case .differentiabilityParamList(let derived):
       return visit(derived)
-    case .differentiabilityParam(let derived): 
+    case .differentiabilityParam(let derived):
       return visit(derived)
-    case .differentiabilityParamsClause(let derived): 
+    case .differentiabilityParamsClause(let derived):
       return visit(derived)
-    case .differentiabilityParams(let derived): 
+    case .differentiabilityParams(let derived):
       return visit(derived)
-    case .differentiableAttributeArguments(let derived): 
+    case .differentiableAttributeArguments(let derived):
       return visit(derived)
-    case .discardAssignmentExpr(let derived): 
+    case .discardAssignmentExpr(let derived):
       return visit(derived)
-    case .doStmt(let derived): 
+    case .doStmt(let derived):
       return visit(derived)
-    case .documentationAttributeArgument(let derived): 
+    case .documentationAttributeArgument(let derived):
       return visit(derived)
-    case .documentationAttributeArguments(let derived): 
+    case .documentationAttributeArguments(let derived):
       return visit(derived)
-    case .dynamicReplacementArguments(let derived): 
+    case .dynamicReplacementArguments(let derived):
       return visit(derived)
-    case .editorPlaceholderDecl(let derived): 
+    case .editorPlaceholderDecl(let derived):
       return visit(derived)
-    case .editorPlaceholderExpr(let derived): 
+    case .editorPlaceholderExpr(let derived):
       return visit(derived)
-    case .effectsArguments(let derived): 
+    case .effectsArguments(let derived):
       return visit(derived)
-    case .enumCaseDecl(let derived): 
+    case .enumCaseDecl(let derived):
       return visit(derived)
-    case .enumCaseElementList(let derived): 
+    case .enumCaseElementList(let derived):
       return visit(derived)
-    case .enumCaseElement(let derived): 
+    case .enumCaseElement(let derived):
       return visit(derived)
-    case .enumDecl(let derived): 
+    case .enumDecl(let derived):
       return visit(derived)
-    case .exposeAttributeArguments(let derived): 
+    case .exposeAttributeArguments(let derived):
       return visit(derived)
-    case .exprList(let derived): 
+    case .exprList(let derived):
       return visit(derived)
-    case .expressionPattern(let derived): 
+    case .expressionPattern(let derived):
       return visit(derived)
-    case .expressionSegment(let derived): 
+    case .expressionSegment(let derived):
       return visit(derived)
-    case .expressionStmt(let derived): 
+    case .expressionStmt(let derived):
       return visit(derived)
-    case .extensionDecl(let derived): 
+    case .extensionDecl(let derived):
       return visit(derived)
-    case .fallthroughStmt(let derived): 
+    case .fallthroughStmt(let derived):
       return visit(derived)
-    case .floatLiteralExpr(let derived): 
+    case .floatLiteralExpr(let derived):
       return visit(derived)
-    case .forInStmt(let derived): 
+    case .forInStmt(let derived):
       return visit(derived)
-    case .forcedValueExpr(let derived): 
+    case .forcedValueExpr(let derived):
       return visit(derived)
-    case .functionCallExpr(let derived): 
+    case .functionCallExpr(let derived):
       return visit(derived)
-    case .functionDecl(let derived): 
+    case .functionDecl(let derived):
       return visit(derived)
-    case .functionParameterList(let derived): 
+    case .functionParameterList(let derived):
       return visit(derived)
-    case .functionParameter(let derived): 
+    case .functionParameter(let derived):
       return visit(derived)
-    case .functionSignature(let derived): 
+    case .functionSignature(let derived):
       return visit(derived)
-    case .functionType(let derived): 
+    case .functionType(let derived):
       return visit(derived)
-    case .genericArgumentClause(let derived): 
+    case .genericArgumentClause(let derived):
       return visit(derived)
-    case .genericArgumentList(let derived): 
+    case .genericArgumentList(let derived):
       return visit(derived)
-    case .genericArgument(let derived): 
+    case .genericArgument(let derived):
       return visit(derived)
-    case .genericParameterClause(let derived): 
+    case .genericParameterClause(let derived):
       return visit(derived)
-    case .genericParameterList(let derived): 
+    case .genericParameterList(let derived):
       return visit(derived)
-    case .genericParameter(let derived): 
+    case .genericParameter(let derived):
       return visit(derived)
-    case .genericRequirementList(let derived): 
+    case .genericRequirementList(let derived):
       return visit(derived)
-    case .genericRequirement(let derived): 
+    case .genericRequirement(let derived):
       return visit(derived)
-    case .genericWhereClause(let derived): 
+    case .genericWhereClause(let derived):
       return visit(derived)
-    case .guardStmt(let derived): 
+    case .guardStmt(let derived):
       return visit(derived)
-    case .identifierExpr(let derived): 
+    case .identifierExpr(let derived):
       return visit(derived)
-    case .identifierPattern(let derived): 
+    case .identifierPattern(let derived):
       return visit(derived)
-    case .ifConfigClauseList(let derived): 
+    case .ifConfigClauseList(let derived):
       return visit(derived)
-    case .ifConfigClause(let derived): 
+    case .ifConfigClause(let derived):
       return visit(derived)
-    case .ifConfigDecl(let derived): 
+    case .ifConfigDecl(let derived):
       return visit(derived)
-    case .ifExpr(let derived): 
+    case .ifExpr(let derived):
       return visit(derived)
-    case .implementsAttributeArguments(let derived): 
+    case .implementsAttributeArguments(let derived):
       return visit(derived)
-    case .implicitlyUnwrappedOptionalType(let derived): 
+    case .implicitlyUnwrappedOptionalType(let derived):
       return visit(derived)
-    case .importDecl(let derived): 
+    case .importDecl(let derived):
       return visit(derived)
-    case .inOutExpr(let derived): 
+    case .inOutExpr(let derived):
       return visit(derived)
-    case .infixOperatorExpr(let derived): 
+    case .infixOperatorExpr(let derived):
       return visit(derived)
-    case .inheritedTypeList(let derived): 
+    case .inheritedTypeList(let derived):
       return visit(derived)
-    case .inheritedType(let derived): 
+    case .inheritedType(let derived):
       return visit(derived)
-    case .initializerClause(let derived): 
+    case .initializerClause(let derived):
       return visit(derived)
-    case .initializerDecl(let derived): 
+    case .initializerDecl(let derived):
       return visit(derived)
-    case .integerLiteralExpr(let derived): 
+    case .integerLiteralExpr(let derived):
       return visit(derived)
-    case .isExpr(let derived): 
+    case .isExpr(let derived):
       return visit(derived)
-    case .isTypePattern(let derived): 
+    case .isTypePattern(let derived):
       return visit(derived)
-    case .keyPathComponentList(let derived): 
+    case .keyPathComponentList(let derived):
       return visit(derived)
-    case .keyPathComponent(let derived): 
+    case .keyPathComponent(let derived):
       return visit(derived)
-    case .keyPathExpr(let derived): 
+    case .keyPathExpr(let derived):
       return visit(derived)
-    case .keyPathOptionalComponent(let derived): 
+    case .keyPathOptionalComponent(let derived):
       return visit(derived)
-    case .keyPathPropertyComponent(let derived): 
+    case .keyPathPropertyComponent(let derived):
       return visit(derived)
-    case .keyPathSubscriptComponent(let derived): 
+    case .keyPathSubscriptComponent(let derived):
       return visit(derived)
-    case .labeledSpecializeEntry(let derived): 
+    case .labeledSpecializeEntry(let derived):
       return visit(derived)
-    case .labeledStmt(let derived): 
+    case .labeledStmt(let derived):
       return visit(derived)
-    case .layoutRequirement(let derived): 
+    case .layoutRequirement(let derived):
       return visit(derived)
-    case .macroDecl(let derived): 
+    case .macroDecl(let derived):
       return visit(derived)
-    case .macroExpansionDecl(let derived): 
+    case .macroExpansionDecl(let derived):
       return visit(derived)
-    case .macroExpansionExpr(let derived): 
+    case .macroExpansionExpr(let derived):
       return visit(derived)
-    case .matchingPatternCondition(let derived): 
+    case .matchingPatternCondition(let derived):
       return visit(derived)
-    case .memberAccessExpr(let derived): 
+    case .memberAccessExpr(let derived):
       return visit(derived)
-    case .memberDeclBlock(let derived): 
+    case .memberDeclBlock(let derived):
       return visit(derived)
-    case .memberDeclListItem(let derived): 
+    case .memberDeclListItem(let derived):
       return visit(derived)
-    case .memberDeclList(let derived): 
+    case .memberDeclList(let derived):
       return visit(derived)
-    case .memberTypeIdentifier(let derived): 
+    case .memberTypeIdentifier(let derived):
       return visit(derived)
-    case .metatypeType(let derived): 
+    case .metatypeType(let derived):
       return visit(derived)
-    case .missingDecl(let derived): 
+    case .missingDecl(let derived):
       return visit(derived)
-    case .missingExpr(let derived): 
+    case .missingExpr(let derived):
       return visit(derived)
-    case .missingPattern(let derived): 
+    case .missingPattern(let derived):
       return visit(derived)
-    case .missingStmt(let derived): 
+    case .missingStmt(let derived):
       return visit(derived)
-    case .missing(let derived): 
+    case .missing(let derived):
       return visit(derived)
-    case .missingType(let derived): 
+    case .missingType(let derived):
       return visit(derived)
-    case .modifierList(let derived): 
+    case .modifierList(let derived):
       return visit(derived)
-    case .moveExpr(let derived): 
+    case .moveExpr(let derived):
       return visit(derived)
-    case .multipleTrailingClosureElementList(let derived): 
+    case .multipleTrailingClosureElementList(let derived):
       return visit(derived)
-    case .multipleTrailingClosureElement(let derived): 
+    case .multipleTrailingClosureElement(let derived):
       return visit(derived)
-    case .namedOpaqueReturnType(let derived): 
+    case .namedOpaqueReturnType(let derived):
       return visit(derived)
-    case .nilLiteralExpr(let derived): 
+    case .nilLiteralExpr(let derived):
       return visit(derived)
-    case .objCSelectorPiece(let derived): 
+    case .objCSelectorPiece(let derived):
       return visit(derived)
-    case .objCSelector(let derived): 
+    case .objCSelector(let derived):
       return visit(derived)
-    case .opaqueReturnTypeOfAttributeArguments(let derived): 
+    case .opaqueReturnTypeOfAttributeArguments(let derived):
       return visit(derived)
-    case .operatorDecl(let derived): 
+    case .operatorDecl(let derived):
       return visit(derived)
-    case .operatorPrecedenceAndTypes(let derived): 
+    case .operatorPrecedenceAndTypes(let derived):
       return visit(derived)
-    case .optionalBindingCondition(let derived): 
+    case .optionalBindingCondition(let derived):
       return visit(derived)
-    case .optionalChainingExpr(let derived): 
+    case .optionalChainingExpr(let derived):
       return visit(derived)
-    case .optionalType(let derived): 
+    case .optionalType(let derived):
       return visit(derived)
-    case .originallyDefinedInArguments(let derived): 
+    case .originallyDefinedInArguments(let derived):
       return visit(derived)
-    case .packElementExpr(let derived): 
+    case .packElementExpr(let derived):
       return visit(derived)
-    case .packExpansionExpr(let derived): 
+    case .packExpansionExpr(let derived):
       return visit(derived)
-    case .packExpansionType(let derived): 
+    case .packExpansionType(let derived):
       return visit(derived)
-    case .packReferenceType(let derived): 
+    case .packReferenceType(let derived):
       return visit(derived)
-    case .parameterClause(let derived): 
+    case .parameterClause(let derived):
       return visit(derived)
-    case .patternBindingList(let derived): 
+    case .patternBindingList(let derived):
       return visit(derived)
-    case .patternBinding(let derived): 
+    case .patternBinding(let derived):
       return visit(derived)
-    case .postfixIfConfigExpr(let derived): 
+    case .postfixIfConfigExpr(let derived):
       return visit(derived)
-    case .postfixUnaryExpr(let derived): 
+    case .postfixUnaryExpr(let derived):
       return visit(derived)
-    case .poundSourceLocationArgs(let derived): 
+    case .poundSourceLocationArgs(let derived):
       return visit(derived)
-    case .poundSourceLocation(let derived): 
+    case .poundSourceLocation(let derived):
       return visit(derived)
-    case .precedenceGroupAssignment(let derived): 
+    case .precedenceGroupAssignment(let derived):
       return visit(derived)
-    case .precedenceGroupAssociativity(let derived): 
+    case .precedenceGroupAssociativity(let derived):
       return visit(derived)
-    case .precedenceGroupAttributeList(let derived): 
+    case .precedenceGroupAttributeList(let derived):
       return visit(derived)
-    case .precedenceGroupDecl(let derived): 
+    case .precedenceGroupDecl(let derived):
       return visit(derived)
-    case .precedenceGroupNameElement(let derived): 
+    case .precedenceGroupNameElement(let derived):
       return visit(derived)
-    case .precedenceGroupNameList(let derived): 
+    case .precedenceGroupNameList(let derived):
       return visit(derived)
-    case .precedenceGroupRelation(let derived): 
+    case .precedenceGroupRelation(let derived):
       return visit(derived)
-    case .prefixOperatorExpr(let derived): 
+    case .prefixOperatorExpr(let derived):
       return visit(derived)
-    case .primaryAssociatedTypeClause(let derived): 
+    case .primaryAssociatedTypeClause(let derived):
       return visit(derived)
-    case .primaryAssociatedTypeList(let derived): 
+    case .primaryAssociatedTypeList(let derived):
       return visit(derived)
-    case .primaryAssociatedType(let derived): 
+    case .primaryAssociatedType(let derived):
       return visit(derived)
-    case .protocolDecl(let derived): 
+    case .protocolDecl(let derived):
       return visit(derived)
-    case .qualifiedDeclName(let derived): 
+    case .qualifiedDeclName(let derived):
       return visit(derived)
-    case .regexLiteralExpr(let derived): 
+    case .regexLiteralExpr(let derived):
       return visit(derived)
-    case .repeatWhileStmt(let derived): 
+    case .repeatWhileStmt(let derived):
       return visit(derived)
-    case .returnClause(let derived): 
+    case .returnClause(let derived):
       return visit(derived)
-    case .returnStmt(let derived): 
+    case .returnStmt(let derived):
       return visit(derived)
-    case .sameTypeRequirement(let derived): 
+    case .sameTypeRequirement(let derived):
       return visit(derived)
-    case .sequenceExpr(let derived): 
+    case .sequenceExpr(let derived):
       return visit(derived)
-    case .simpleTypeIdentifier(let derived): 
+    case .simpleTypeIdentifier(let derived):
       return visit(derived)
-    case .sourceFile(let derived): 
+    case .sourceFile(let derived):
       return visit(derived)
-    case .specializeAttributeSpecList(let derived): 
+    case .specializeAttributeSpecList(let derived):
       return visit(derived)
-    case .specializeExpr(let derived): 
+    case .specializeExpr(let derived):
       return visit(derived)
-    case .stringLiteralExpr(let derived): 
+    case .stringLiteralExpr(let derived):
       return visit(derived)
-    case .stringLiteralSegments(let derived): 
+    case .stringLiteralSegments(let derived):
       return visit(derived)
-    case .stringSegment(let derived): 
+    case .stringSegment(let derived):
       return visit(derived)
-    case .structDecl(let derived): 
+    case .structDecl(let derived):
       return visit(derived)
-    case .subscriptDecl(let derived): 
+    case .subscriptDecl(let derived):
       return visit(derived)
-    case .subscriptExpr(let derived): 
+    case .subscriptExpr(let derived):
       return visit(derived)
-    case .superRefExpr(let derived): 
+    case .superRefExpr(let derived):
       return visit(derived)
-    case .switchCaseLabel(let derived): 
+    case .switchCaseLabel(let derived):
       return visit(derived)
-    case .switchCaseList(let derived): 
+    case .switchCaseList(let derived):
       return visit(derived)
-    case .switchCase(let derived): 
+    case .switchCase(let derived):
       return visit(derived)
-    case .switchDefaultLabel(let derived): 
+    case .switchDefaultLabel(let derived):
       return visit(derived)
-    case .switchExpr(let derived): 
+    case .switchExpr(let derived):
       return visit(derived)
-    case .targetFunctionEntry(let derived): 
+    case .targetFunctionEntry(let derived):
       return visit(derived)
-    case .ternaryExpr(let derived): 
+    case .ternaryExpr(let derived):
       return visit(derived)
-    case .throwStmt(let derived): 
+    case .throwStmt(let derived):
       return visit(derived)
-    case .tryExpr(let derived): 
+    case .tryExpr(let derived):
       return visit(derived)
-    case .tupleExprElementList(let derived): 
+    case .tupleExprElementList(let derived):
       return visit(derived)
-    case .tupleExprElement(let derived): 
+    case .tupleExprElement(let derived):
       return visit(derived)
-    case .tupleExpr(let derived): 
+    case .tupleExpr(let derived):
       return visit(derived)
-    case .tuplePatternElementList(let derived): 
+    case .tuplePatternElementList(let derived):
       return visit(derived)
-    case .tuplePatternElement(let derived): 
+    case .tuplePatternElement(let derived):
       return visit(derived)
-    case .tuplePattern(let derived): 
+    case .tuplePattern(let derived):
       return visit(derived)
-    case .tupleTypeElementList(let derived): 
+    case .tupleTypeElementList(let derived):
       return visit(derived)
-    case .tupleTypeElement(let derived): 
+    case .tupleTypeElement(let derived):
       return visit(derived)
-    case .tupleType(let derived): 
+    case .tupleType(let derived):
       return visit(derived)
-    case .typeAnnotation(let derived): 
+    case .typeAnnotation(let derived):
       return visit(derived)
-    case .typeEffectSpecifiers(let derived): 
+    case .typeEffectSpecifiers(let derived):
       return visit(derived)
-    case .typeExpr(let derived): 
+    case .typeExpr(let derived):
       return visit(derived)
-    case .typeInheritanceClause(let derived): 
+    case .typeInheritanceClause(let derived):
       return visit(derived)
-    case .typeInitializerClause(let derived): 
+    case .typeInitializerClause(let derived):
       return visit(derived)
-    case .typealiasDecl(let derived): 
+    case .typealiasDecl(let derived):
       return visit(derived)
-    case .unavailableFromAsyncArguments(let derived): 
+    case .unavailableFromAsyncArguments(let derived):
       return visit(derived)
-    case .underscorePrivateAttributeArguments(let derived): 
+    case .underscorePrivateAttributeArguments(let derived):
       return visit(derived)
-    case .unexpectedNodes(let derived): 
+    case .unexpectedNodes(let derived):
       return visit(derived)
-    case .unresolvedAsExpr(let derived): 
+    case .unresolvedAsExpr(let derived):
       return visit(derived)
-    case .unresolvedIsExpr(let derived): 
+    case .unresolvedIsExpr(let derived):
       return visit(derived)
-    case .unresolvedPatternExpr(let derived): 
+    case .unresolvedPatternExpr(let derived):
       return visit(derived)
-    case .unresolvedTernaryExpr(let derived): 
+    case .unresolvedTernaryExpr(let derived):
       return visit(derived)
-    case .valueBindingPattern(let derived): 
+    case .valueBindingPattern(let derived):
       return visit(derived)
-    case .variableDecl(let derived): 
+    case .variableDecl(let derived):
       return visit(derived)
-    case .versionTuple(let derived): 
+    case .versionTuple(let derived):
       return visit(derived)
-    case .whereClause(let derived): 
+    case .whereClause(let derived):
       return visit(derived)
-    case .whileStmt(let derived): 
+    case .whileStmt(let derived):
       return visit(derived)
-    case .wildcardPattern(let derived): 
+    case .wildcardPattern(let derived):
       return visit(derived)
-    case .yieldExprListElement(let derived): 
+    case .yieldExprListElement(let derived):
       return visit(derived)
-    case .yieldExprList(let derived): 
+    case .yieldExprList(let derived):
       return visit(derived)
-    case .yieldList(let derived): 
+    case .yieldList(let derived):
       return visit(derived)
-    case .yieldStmt(let derived): 
+    case .yieldStmt(let derived):
       return visit(derived)
     }
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
index 307a62cd795..e40352675aa 100644
--- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -6017,530 +6017,530 @@ open class SyntaxVisitor {
   
   private func visit(_ data: SyntaxData) {
     switch data.raw.kind {
-    case .token: 
+    case .token:
       let node = TokenSyntax(data)
       _ = visit(node)
       // No children to visit.
       visitPost(node)
-    case .accessPathComponent: 
+    case .accessPathComponent:
       visitImplAccessPathComponentSyntax(data)
-    case .accessPath: 
+    case .accessPath:
       visitImplAccessPathSyntax(data)
-    case .accessorBlock: 
+    case .accessorBlock:
       visitImplAccessorBlockSyntax(data)
-    case .accessorDecl: 
+    case .accessorDecl:
       visitImplAccessorDeclSyntax(data)
-    case .accessorList: 
+    case .accessorList:
       visitImplAccessorListSyntax(data)
-    case .accessorParameter: 
+    case .accessorParameter:
       visitImplAccessorParameterSyntax(data)
-    case .actorDecl: 
+    case .actorDecl:
       visitImplActorDeclSyntax(data)
-    case .arrayElementList: 
+    case .arrayElementList:
       visitImplArrayElementListSyntax(data)
-    case .arrayElement: 
+    case .arrayElement:
       visitImplArrayElementSyntax(data)
-    case .arrayExpr: 
+    case .arrayExpr:
       visitImplArrayExprSyntax(data)
-    case .arrayType: 
+    case .arrayType:
       visitImplArrayTypeSyntax(data)
-    case .arrowExpr: 
+    case .arrowExpr:
       visitImplArrowExprSyntax(data)
-    case .asExpr: 
+    case .asExpr:
       visitImplAsExprSyntax(data)
-    case .assignmentExpr: 
+    case .assignmentExpr:
       visitImplAssignmentExprSyntax(data)
-    case .associatedtypeDecl: 
+    case .associatedtypeDecl:
       visitImplAssociatedtypeDeclSyntax(data)
-    case .attributeList: 
+    case .attributeList:
       visitImplAttributeListSyntax(data)
-    case .attribute: 
+    case .attribute:
       visitImplAttributeSyntax(data)
-    case .attributedType: 
+    case .attributedType:
       visitImplAttributedTypeSyntax(data)
-    case .availabilityArgument: 
+    case .availabilityArgument:
       visitImplAvailabilityArgumentSyntax(data)
-    case .availabilityCondition: 
+    case .availabilityCondition:
       visitImplAvailabilityConditionSyntax(data)
-    case .availabilityEntry: 
+    case .availabilityEntry:
       visitImplAvailabilityEntrySyntax(data)
-    case .availabilityLabeledArgument: 
+    case .availabilityLabeledArgument:
       visitImplAvailabilityLabeledArgumentSyntax(data)
-    case .availabilitySpecList: 
+    case .availabilitySpecList:
       visitImplAvailabilitySpecListSyntax(data)
-    case .availabilityVersionRestrictionListEntry: 
+    case .availabilityVersionRestrictionListEntry:
       visitImplAvailabilityVersionRestrictionListEntrySyntax(data)
-    case .availabilityVersionRestrictionList: 
+    case .availabilityVersionRestrictionList:
       visitImplAvailabilityVersionRestrictionListSyntax(data)
-    case .availabilityVersionRestriction: 
+    case .availabilityVersionRestriction:
       visitImplAvailabilityVersionRestrictionSyntax(data)
-    case .awaitExpr: 
+    case .awaitExpr:
       visitImplAwaitExprSyntax(data)
-    case .backDeployedAttributeSpecList: 
+    case .backDeployedAttributeSpecList:
       visitImplBackDeployedAttributeSpecListSyntax(data)
-    case .binaryOperatorExpr: 
+    case .binaryOperatorExpr:
       visitImplBinaryOperatorExprSyntax(data)
-    case .booleanLiteralExpr: 
+    case .booleanLiteralExpr:
       visitImplBooleanLiteralExprSyntax(data)
-    case .borrowExpr: 
+    case .borrowExpr:
       visitImplBorrowExprSyntax(data)
-    case .breakStmt: 
+    case .breakStmt:
       visitImplBreakStmtSyntax(data)
-    case .caseItemList: 
+    case .caseItemList:
       visitImplCaseItemListSyntax(data)
-    case .caseItem: 
+    case .caseItem:
       visitImplCaseItemSyntax(data)
-    case .catchClauseList: 
+    case .catchClauseList:
       visitImplCatchClauseListSyntax(data)
-    case .catchClause: 
+    case .catchClause:
       visitImplCatchClauseSyntax(data)
-    case .catchItemList: 
+    case .catchItemList:
       visitImplCatchItemListSyntax(data)
-    case .catchItem: 
+    case .catchItem:
       visitImplCatchItemSyntax(data)
-    case .classDecl: 
+    case .classDecl:
       visitImplClassDeclSyntax(data)
-    case .classRestrictionType: 
+    case .classRestrictionType:
       visitImplClassRestrictionTypeSyntax(data)
-    case .closureCaptureItemList: 
+    case .closureCaptureItemList:
       visitImplClosureCaptureItemListSyntax(data)
-    case .closureCaptureItemSpecifier: 
+    case .closureCaptureItemSpecifier:
       visitImplClosureCaptureItemSpecifierSyntax(data)
-    case .closureCaptureItem: 
+    case .closureCaptureItem:
       visitImplClosureCaptureItemSyntax(data)
-    case .closureCaptureSignature: 
+    case .closureCaptureSignature:
       visitImplClosureCaptureSignatureSyntax(data)
-    case .closureExpr: 
+    case .closureExpr:
       visitImplClosureExprSyntax(data)
-    case .closureParamList: 
+    case .closureParamList:
       visitImplClosureParamListSyntax(data)
-    case .closureParam: 
+    case .closureParam:
       visitImplClosureParamSyntax(data)
-    case .closureSignature: 
+    case .closureSignature:
       visitImplClosureSignatureSyntax(data)
-    case .codeBlockItemList: 
+    case .codeBlockItemList:
       visitImplCodeBlockItemListSyntax(data)
-    case .codeBlockItem: 
+    case .codeBlockItem:
       visitImplCodeBlockItemSyntax(data)
-    case .codeBlock: 
+    case .codeBlock:
       visitImplCodeBlockSyntax(data)
-    case .compositionTypeElementList: 
+    case .compositionTypeElementList:
       visitImplCompositionTypeElementListSyntax(data)
-    case .compositionTypeElement: 
+    case .compositionTypeElement:
       visitImplCompositionTypeElementSyntax(data)
-    case .compositionType: 
+    case .compositionType:
       visitImplCompositionTypeSyntax(data)
-    case .conditionElementList: 
+    case .conditionElementList:
       visitImplConditionElementListSyntax(data)
-    case .conditionElement: 
+    case .conditionElement:
       visitImplConditionElementSyntax(data)
-    case .conformanceRequirement: 
+    case .conformanceRequirement:
       visitImplConformanceRequirementSyntax(data)
-    case .constrainedSugarType: 
+    case .constrainedSugarType:
       visitImplConstrainedSugarTypeSyntax(data)
-    case .continueStmt: 
+    case .continueStmt:
       visitImplContinueStmtSyntax(data)
-    case .conventionAttributeArguments: 
+    case .conventionAttributeArguments:
       visitImplConventionAttributeArgumentsSyntax(data)
-    case .conventionWitnessMethodAttributeArguments: 
+    case .conventionWitnessMethodAttributeArguments:
       visitImplConventionWitnessMethodAttributeArgumentsSyntax(data)
-    case .declEffectSpecifiers: 
+    case .declEffectSpecifiers:
       visitImplDeclEffectSpecifiersSyntax(data)
-    case .declModifierDetail: 
+    case .declModifierDetail:
       visitImplDeclModifierDetailSyntax(data)
-    case .declModifier: 
+    case .declModifier:
       visitImplDeclModifierSyntax(data)
-    case .declNameArgumentList: 
+    case .declNameArgumentList:
       visitImplDeclNameArgumentListSyntax(data)
-    case .declNameArgument: 
+    case .declNameArgument:
       visitImplDeclNameArgumentSyntax(data)
-    case .declNameArguments: 
+    case .declNameArguments:
       visitImplDeclNameArgumentsSyntax(data)
-    case .declName: 
+    case .declName:
       visitImplDeclNameSyntax(data)
-    case .deferStmt: 
+    case .deferStmt:
       visitImplDeferStmtSyntax(data)
-    case .deinitializerDecl: 
+    case .deinitializerDecl:
       visitImplDeinitializerDeclSyntax(data)
-    case .derivativeRegistrationAttributeArguments: 
+    case .derivativeRegistrationAttributeArguments:
       visitImplDerivativeRegistrationAttributeArgumentsSyntax(data)
-    case .designatedTypeElement: 
+    case .designatedTypeElement:
       visitImplDesignatedTypeElementSyntax(data)
-    case .designatedTypeList: 
+    case .designatedTypeList:
       visitImplDesignatedTypeListSyntax(data)
-    case .dictionaryElementList: 
+    case .dictionaryElementList:
       visitImplDictionaryElementListSyntax(data)
-    case .dictionaryElement: 
+    case .dictionaryElement:
       visitImplDictionaryElementSyntax(data)
-    case .dictionaryExpr: 
+    case .dictionaryExpr:
       visitImplDictionaryExprSyntax(data)
-    case .dictionaryType: 
+    case .dictionaryType:
       visitImplDictionaryTypeSyntax(data)
-    case .differentiabilityParamList: 
+    case .differentiabilityParamList:
       visitImplDifferentiabilityParamListSyntax(data)
-    case .differentiabilityParam: 
+    case .differentiabilityParam:
       visitImplDifferentiabilityParamSyntax(data)
-    case .differentiabilityParamsClause: 
+    case .differentiabilityParamsClause:
       visitImplDifferentiabilityParamsClauseSyntax(data)
-    case .differentiabilityParams: 
+    case .differentiabilityParams:
       visitImplDifferentiabilityParamsSyntax(data)
-    case .differentiableAttributeArguments: 
+    case .differentiableAttributeArguments:
       visitImplDifferentiableAttributeArgumentsSyntax(data)
-    case .discardAssignmentExpr: 
+    case .discardAssignmentExpr:
       visitImplDiscardAssignmentExprSyntax(data)
-    case .doStmt: 
+    case .doStmt:
       visitImplDoStmtSyntax(data)
-    case .documentationAttributeArgument: 
+    case .documentationAttributeArgument:
       visitImplDocumentationAttributeArgumentSyntax(data)
-    case .documentationAttributeArguments: 
+    case .documentationAttributeArguments:
       visitImplDocumentationAttributeArgumentsSyntax(data)
-    case .dynamicReplacementArguments: 
+    case .dynamicReplacementArguments:
       visitImplDynamicReplacementArgumentsSyntax(data)
-    case .editorPlaceholderDecl: 
+    case .editorPlaceholderDecl:
       visitImplEditorPlaceholderDeclSyntax(data)
-    case .editorPlaceholderExpr: 
+    case .editorPlaceholderExpr:
       visitImplEditorPlaceholderExprSyntax(data)
-    case .effectsArguments: 
+    case .effectsArguments:
       visitImplEffectsArgumentsSyntax(data)
-    case .enumCaseDecl: 
+    case .enumCaseDecl:
       visitImplEnumCaseDeclSyntax(data)
-    case .enumCaseElementList: 
+    case .enumCaseElementList:
       visitImplEnumCaseElementListSyntax(data)
-    case .enumCaseElement: 
+    case .enumCaseElement:
       visitImplEnumCaseElementSyntax(data)
-    case .enumDecl: 
+    case .enumDecl:
       visitImplEnumDeclSyntax(data)
-    case .exposeAttributeArguments: 
+    case .exposeAttributeArguments:
       visitImplExposeAttributeArgumentsSyntax(data)
-    case .exprList: 
+    case .exprList:
       visitImplExprListSyntax(data)
-    case .expressionPattern: 
+    case .expressionPattern:
       visitImplExpressionPatternSyntax(data)
-    case .expressionSegment: 
+    case .expressionSegment:
       visitImplExpressionSegmentSyntax(data)
-    case .expressionStmt: 
+    case .expressionStmt:
       visitImplExpressionStmtSyntax(data)
-    case .extensionDecl: 
+    case .extensionDecl:
       visitImplExtensionDeclSyntax(data)
-    case .fallthroughStmt: 
+    case .fallthroughStmt:
       visitImplFallthroughStmtSyntax(data)
-    case .floatLiteralExpr: 
+    case .floatLiteralExpr:
       visitImplFloatLiteralExprSyntax(data)
-    case .forInStmt: 
+    case .forInStmt:
       visitImplForInStmtSyntax(data)
-    case .forcedValueExpr: 
+    case .forcedValueExpr:
       visitImplForcedValueExprSyntax(data)
-    case .functionCallExpr: 
+    case .functionCallExpr:
       visitImplFunctionCallExprSyntax(data)
-    case .functionDecl: 
+    case .functionDecl:
       visitImplFunctionDeclSyntax(data)
-    case .functionParameterList: 
+    case .functionParameterList:
       visitImplFunctionParameterListSyntax(data)
-    case .functionParameter: 
+    case .functionParameter:
       visitImplFunctionParameterSyntax(data)
-    case .functionSignature: 
+    case .functionSignature:
       visitImplFunctionSignatureSyntax(data)
-    case .functionType: 
+    case .functionType:
       visitImplFunctionTypeSyntax(data)
-    case .genericArgumentClause: 
+    case .genericArgumentClause:
       visitImplGenericArgumentClauseSyntax(data)
-    case .genericArgumentList: 
+    case .genericArgumentList:
       visitImplGenericArgumentListSyntax(data)
-    case .genericArgument: 
+    case .genericArgument:
       visitImplGenericArgumentSyntax(data)
-    case .genericParameterClause: 
+    case .genericParameterClause:
       visitImplGenericParameterClauseSyntax(data)
-    case .genericParameterList: 
+    case .genericParameterList:
       visitImplGenericParameterListSyntax(data)
-    case .genericParameter: 
+    case .genericParameter:
       visitImplGenericParameterSyntax(data)
-    case .genericRequirementList: 
+    case .genericRequirementList:
       visitImplGenericRequirementListSyntax(data)
-    case .genericRequirement: 
+    case .genericRequirement:
       visitImplGenericRequirementSyntax(data)
-    case .genericWhereClause: 
+    case .genericWhereClause:
       visitImplGenericWhereClauseSyntax(data)
-    case .guardStmt: 
+    case .guardStmt:
       visitImplGuardStmtSyntax(data)
-    case .identifierExpr: 
+    case .identifierExpr:
       visitImplIdentifierExprSyntax(data)
-    case .identifierPattern: 
+    case .identifierPattern:
       visitImplIdentifierPatternSyntax(data)
-    case .ifConfigClauseList: 
+    case .ifConfigClauseList:
       visitImplIfConfigClauseListSyntax(data)
-    case .ifConfigClause: 
+    case .ifConfigClause:
       visitImplIfConfigClauseSyntax(data)
-    case .ifConfigDecl: 
+    case .ifConfigDecl:
       visitImplIfConfigDeclSyntax(data)
-    case .ifExpr: 
+    case .ifExpr:
       visitImplIfExprSyntax(data)
-    case .implementsAttributeArguments: 
+    case .implementsAttributeArguments:
       visitImplImplementsAttributeArgumentsSyntax(data)
-    case .implicitlyUnwrappedOptionalType: 
+    case .implicitlyUnwrappedOptionalType:
       visitImplImplicitlyUnwrappedOptionalTypeSyntax(data)
-    case .importDecl: 
+    case .importDecl:
       visitImplImportDeclSyntax(data)
-    case .inOutExpr: 
+    case .inOutExpr:
       visitImplInOutExprSyntax(data)
-    case .infixOperatorExpr: 
+    case .infixOperatorExpr:
       visitImplInfixOperatorExprSyntax(data)
-    case .inheritedTypeList: 
+    case .inheritedTypeList:
       visitImplInheritedTypeListSyntax(data)
-    case .inheritedType: 
+    case .inheritedType:
       visitImplInheritedTypeSyntax(data)
-    case .initializerClause: 
+    case .initializerClause:
       visitImplInitializerClauseSyntax(data)
-    case .initializerDecl: 
+    case .initializerDecl:
       visitImplInitializerDeclSyntax(data)
-    case .integerLiteralExpr: 
+    case .integerLiteralExpr:
       visitImplIntegerLiteralExprSyntax(data)
-    case .isExpr: 
+    case .isExpr:
       visitImplIsExprSyntax(data)
-    case .isTypePattern: 
+    case .isTypePattern:
       visitImplIsTypePatternSyntax(data)
-    case .keyPathComponentList: 
+    case .keyPathComponentList:
       visitImplKeyPathComponentListSyntax(data)
-    case .keyPathComponent: 
+    case .keyPathComponent:
       visitImplKeyPathComponentSyntax(data)
-    case .keyPathExpr: 
+    case .keyPathExpr:
       visitImplKeyPathExprSyntax(data)
-    case .keyPathOptionalComponent: 
+    case .keyPathOptionalComponent:
       visitImplKeyPathOptionalComponentSyntax(data)
-    case .keyPathPropertyComponent: 
+    case .keyPathPropertyComponent:
       visitImplKeyPathPropertyComponentSyntax(data)
-    case .keyPathSubscriptComponent: 
+    case .keyPathSubscriptComponent:
       visitImplKeyPathSubscriptComponentSyntax(data)
-    case .labeledSpecializeEntry: 
+    case .labeledSpecializeEntry:
       visitImplLabeledSpecializeEntrySyntax(data)
-    case .labeledStmt: 
+    case .labeledStmt:
       visitImplLabeledStmtSyntax(data)
-    case .layoutRequirement: 
+    case .layoutRequirement:
       visitImplLayoutRequirementSyntax(data)
-    case .macroDecl: 
+    case .macroDecl:
       visitImplMacroDeclSyntax(data)
-    case .macroExpansionDecl: 
+    case .macroExpansionDecl:
       visitImplMacroExpansionDeclSyntax(data)
-    case .macroExpansionExpr: 
+    case .macroExpansionExpr:
       visitImplMacroExpansionExprSyntax(data)
-    case .matchingPatternCondition: 
+    case .matchingPatternCondition:
       visitImplMatchingPatternConditionSyntax(data)
-    case .memberAccessExpr: 
+    case .memberAccessExpr:
       visitImplMemberAccessExprSyntax(data)
-    case .memberDeclBlock: 
+    case .memberDeclBlock:
       visitImplMemberDeclBlockSyntax(data)
-    case .memberDeclListItem: 
+    case .memberDeclListItem:
       visitImplMemberDeclListItemSyntax(data)
-    case .memberDeclList: 
+    case .memberDeclList:
       visitImplMemberDeclListSyntax(data)
-    case .memberTypeIdentifier: 
+    case .memberTypeIdentifier:
       visitImplMemberTypeIdentifierSyntax(data)
-    case .metatypeType: 
+    case .metatypeType:
       visitImplMetatypeTypeSyntax(data)
-    case .missingDecl: 
+    case .missingDecl:
       visitImplMissingDeclSyntax(data)
-    case .missingExpr: 
+    case .missingExpr:
       visitImplMissingExprSyntax(data)
-    case .missingPattern: 
+    case .missingPattern:
       visitImplMissingPatternSyntax(data)
-    case .missingStmt: 
+    case .missingStmt:
       visitImplMissingStmtSyntax(data)
-    case .missing: 
+    case .missing:
       visitImplMissingSyntax(data)
-    case .missingType: 
+    case .missingType:
       visitImplMissingTypeSyntax(data)
-    case .modifierList: 
+    case .modifierList:
       visitImplModifierListSyntax(data)
-    case .moveExpr: 
+    case .moveExpr:
       visitImplMoveExprSyntax(data)
-    case .multipleTrailingClosureElementList: 
+    case .multipleTrailingClosureElementList:
       visitImplMultipleTrailingClosureElementListSyntax(data)
-    case .multipleTrailingClosureElement: 
+    case .multipleTrailingClosureElement:
       visitImplMultipleTrailingClosureElementSyntax(data)
-    case .namedOpaqueReturnType: 
+    case .namedOpaqueReturnType:
       visitImplNamedOpaqueReturnTypeSyntax(data)
-    case .nilLiteralExpr: 
+    case .nilLiteralExpr:
       visitImplNilLiteralExprSyntax(data)
-    case .objCSelectorPiece: 
+    case .objCSelectorPiece:
       visitImplObjCSelectorPieceSyntax(data)
-    case .objCSelector: 
+    case .objCSelector:
       visitImplObjCSelectorSyntax(data)
-    case .opaqueReturnTypeOfAttributeArguments: 
+    case .opaqueReturnTypeOfAttributeArguments:
       visitImplOpaqueReturnTypeOfAttributeArgumentsSyntax(data)
-    case .operatorDecl: 
+    case .operatorDecl:
       visitImplOperatorDeclSyntax(data)
-    case .operatorPrecedenceAndTypes: 
+    case .operatorPrecedenceAndTypes:
       visitImplOperatorPrecedenceAndTypesSyntax(data)
-    case .optionalBindingCondition: 
+    case .optionalBindingCondition:
       visitImplOptionalBindingConditionSyntax(data)
-    case .optionalChainingExpr: 
+    case .optionalChainingExpr:
       visitImplOptionalChainingExprSyntax(data)
-    case .optionalType: 
+    case .optionalType:
       visitImplOptionalTypeSyntax(data)
-    case .originallyDefinedInArguments: 
+    case .originallyDefinedInArguments:
       visitImplOriginallyDefinedInArgumentsSyntax(data)
-    case .packElementExpr: 
+    case .packElementExpr:
       visitImplPackElementExprSyntax(data)
-    case .packExpansionExpr: 
+    case .packExpansionExpr:
       visitImplPackExpansionExprSyntax(data)
-    case .packExpansionType: 
+    case .packExpansionType:
       visitImplPackExpansionTypeSyntax(data)
-    case .packReferenceType: 
+    case .packReferenceType:
       visitImplPackReferenceTypeSyntax(data)
-    case .parameterClause: 
+    case .parameterClause:
       visitImplParameterClauseSyntax(data)
-    case .patternBindingList: 
+    case .patternBindingList:
       visitImplPatternBindingListSyntax(data)
-    case .patternBinding: 
+    case .patternBinding:
       visitImplPatternBindingSyntax(data)
-    case .postfixIfConfigExpr: 
+    case .postfixIfConfigExpr:
       visitImplPostfixIfConfigExprSyntax(data)
-    case .postfixUnaryExpr: 
+    case .postfixUnaryExpr:
       visitImplPostfixUnaryExprSyntax(data)
-    case .poundSourceLocationArgs: 
+    case .poundSourceLocationArgs:
       visitImplPoundSourceLocationArgsSyntax(data)
-    case .poundSourceLocation: 
+    case .poundSourceLocation:
       visitImplPoundSourceLocationSyntax(data)
-    case .precedenceGroupAssignment: 
+    case .precedenceGroupAssignment:
       visitImplPrecedenceGroupAssignmentSyntax(data)
-    case .precedenceGroupAssociativity: 
+    case .precedenceGroupAssociativity:
       visitImplPrecedenceGroupAssociativitySyntax(data)
-    case .precedenceGroupAttributeList: 
+    case .precedenceGroupAttributeList:
       visitImplPrecedenceGroupAttributeListSyntax(data)
-    case .precedenceGroupDecl: 
+    case .precedenceGroupDecl:
       visitImplPrecedenceGroupDeclSyntax(data)
-    case .precedenceGroupNameElement: 
+    case .precedenceGroupNameElement:
       visitImplPrecedenceGroupNameElementSyntax(data)
-    case .precedenceGroupNameList: 
+    case .precedenceGroupNameList:
       visitImplPrecedenceGroupNameListSyntax(data)
-    case .precedenceGroupRelation: 
+    case .precedenceGroupRelation:
       visitImplPrecedenceGroupRelationSyntax(data)
-    case .prefixOperatorExpr: 
+    case .prefixOperatorExpr:
       visitImplPrefixOperatorExprSyntax(data)
-    case .primaryAssociatedTypeClause: 
+    case .primaryAssociatedTypeClause:
       visitImplPrimaryAssociatedTypeClauseSyntax(data)
-    case .primaryAssociatedTypeList: 
+    case .primaryAssociatedTypeList:
       visitImplPrimaryAssociatedTypeListSyntax(data)
-    case .primaryAssociatedType: 
+    case .primaryAssociatedType:
       visitImplPrimaryAssociatedTypeSyntax(data)
-    case .protocolDecl: 
+    case .protocolDecl:
       visitImplProtocolDeclSyntax(data)
-    case .qualifiedDeclName: 
+    case .qualifiedDeclName:
       visitImplQualifiedDeclNameSyntax(data)
-    case .regexLiteralExpr: 
+    case .regexLiteralExpr:
       visitImplRegexLiteralExprSyntax(data)
-    case .repeatWhileStmt: 
+    case .repeatWhileStmt:
       visitImplRepeatWhileStmtSyntax(data)
-    case .returnClause: 
+    case .returnClause:
       visitImplReturnClauseSyntax(data)
-    case .returnStmt: 
+    case .returnStmt:
       visitImplReturnStmtSyntax(data)
-    case .sameTypeRequirement: 
+    case .sameTypeRequirement:
       visitImplSameTypeRequirementSyntax(data)
-    case .sequenceExpr: 
+    case .sequenceExpr:
       visitImplSequenceExprSyntax(data)
-    case .simpleTypeIdentifier: 
+    case .simpleTypeIdentifier:
       visitImplSimpleTypeIdentifierSyntax(data)
-    case .sourceFile: 
+    case .sourceFile:
       visitImplSourceFileSyntax(data)
-    case .specializeAttributeSpecList: 
+    case .specializeAttributeSpecList:
       visitImplSpecializeAttributeSpecListSyntax(data)
-    case .specializeExpr: 
+    case .specializeExpr:
       visitImplSpecializeExprSyntax(data)
-    case .stringLiteralExpr: 
+    case .stringLiteralExpr:
       visitImplStringLiteralExprSyntax(data)
-    case .stringLiteralSegments: 
+    case .stringLiteralSegments:
       visitImplStringLiteralSegmentsSyntax(data)
-    case .stringSegment: 
+    case .stringSegment:
       visitImplStringSegmentSyntax(data)
-    case .structDecl: 
+    case .structDecl:
       visitImplStructDeclSyntax(data)
-    case .subscriptDecl: 
+    case .subscriptDecl:
       visitImplSubscriptDeclSyntax(data)
-    case .subscriptExpr: 
+    case .subscriptExpr:
       visitImplSubscriptExprSyntax(data)
-    case .superRefExpr: 
+    case .superRefExpr:
       visitImplSuperRefExprSyntax(data)
-    case .switchCaseLabel: 
+    case .switchCaseLabel:
       visitImplSwitchCaseLabelSyntax(data)
-    case .switchCaseList: 
+    case .switchCaseList:
       visitImplSwitchCaseListSyntax(data)
-    case .switchCase: 
+    case .switchCase:
       visitImplSwitchCaseSyntax(data)
-    case .switchDefaultLabel: 
+    case .switchDefaultLabel:
       visitImplSwitchDefaultLabelSyntax(data)
-    case .switchExpr: 
+    case .switchExpr:
       visitImplSwitchExprSyntax(data)
-    case .targetFunctionEntry: 
+    case .targetFunctionEntry:
       visitImplTargetFunctionEntrySyntax(data)
-    case .ternaryExpr: 
+    case .ternaryExpr:
       visitImplTernaryExprSyntax(data)
-    case .throwStmt: 
+    case .throwStmt:
       visitImplThrowStmtSyntax(data)
-    case .tryExpr: 
+    case .tryExpr:
       visitImplTryExprSyntax(data)
-    case .tupleExprElementList: 
+    case .tupleExprElementList:
       visitImplTupleExprElementListSyntax(data)
-    case .tupleExprElement: 
+    case .tupleExprElement:
       visitImplTupleExprElementSyntax(data)
-    case .tupleExpr: 
+    case .tupleExpr:
       visitImplTupleExprSyntax(data)
-    case .tuplePatternElementList: 
+    case .tuplePatternElementList:
       visitImplTuplePatternElementListSyntax(data)
-    case .tuplePatternElement: 
+    case .tuplePatternElement:
       visitImplTuplePatternElementSyntax(data)
-    case .tuplePattern: 
+    case .tuplePattern:
       visitImplTuplePatternSyntax(data)
-    case .tupleTypeElementList: 
+    case .tupleTypeElementList:
       visitImplTupleTypeElementListSyntax(data)
-    case .tupleTypeElement: 
+    case .tupleTypeElement:
       visitImplTupleTypeElementSyntax(data)
-    case .tupleType: 
+    case .tupleType:
       visitImplTupleTypeSyntax(data)
-    case .typeAnnotation: 
+    case .typeAnnotation:
       visitImplTypeAnnotationSyntax(data)
-    case .typeEffectSpecifiers: 
+    case .typeEffectSpecifiers:
       visitImplTypeEffectSpecifiersSyntax(data)
-    case .typeExpr: 
+    case .typeExpr:
       visitImplTypeExprSyntax(data)
-    case .typeInheritanceClause: 
+    case .typeInheritanceClause:
       visitImplTypeInheritanceClauseSyntax(data)
-    case .typeInitializerClause: 
+    case .typeInitializerClause:
       visitImplTypeInitializerClauseSyntax(data)
-    case .typealiasDecl: 
+    case .typealiasDecl:
       visitImplTypealiasDeclSyntax(data)
-    case .unavailableFromAsyncArguments: 
+    case .unavailableFromAsyncArguments:
       visitImplUnavailableFromAsyncArgumentsSyntax(data)
-    case .underscorePrivateAttributeArguments: 
+    case .underscorePrivateAttributeArguments:
       visitImplUnderscorePrivateAttributeArgumentsSyntax(data)
-    case .unexpectedNodes: 
+    case .unexpectedNodes:
       visitImplUnexpectedNodesSyntax(data)
-    case .unresolvedAsExpr: 
+    case .unresolvedAsExpr:
       visitImplUnresolvedAsExprSyntax(data)
-    case .unresolvedIsExpr: 
+    case .unresolvedIsExpr:
       visitImplUnresolvedIsExprSyntax(data)
-    case .unresolvedPatternExpr: 
+    case .unresolvedPatternExpr:
       visitImplUnresolvedPatternExprSyntax(data)
-    case .unresolvedTernaryExpr: 
+    case .unresolvedTernaryExpr:
       visitImplUnresolvedTernaryExprSyntax(data)
-    case .valueBindingPattern: 
+    case .valueBindingPattern:
       visitImplValueBindingPatternSyntax(data)
-    case .variableDecl: 
+    case .variableDecl:
       visitImplVariableDeclSyntax(data)
-    case .versionTuple: 
+    case .versionTuple:
       visitImplVersionTupleSyntax(data)
-    case .whereClause: 
+    case .whereClause:
       visitImplWhereClauseSyntax(data)
-    case .whileStmt: 
+    case .whileStmt:
       visitImplWhileStmtSyntax(data)
-    case .wildcardPattern: 
+    case .wildcardPattern:
       visitImplWildcardPatternSyntax(data)
-    case .yieldExprListElement: 
+    case .yieldExprListElement:
       visitImplYieldExprListElementSyntax(data)
-    case .yieldExprList: 
+    case .yieldExprList:
       visitImplYieldExprListSyntax(data)
-    case .yieldList: 
+    case .yieldList:
       visitImplYieldListSyntax(data)
-    case .yieldStmt: 
+    case .yieldStmt:
       visitImplYieldStmtSyntax(data)
     }
   }
diff --git a/Sources/SwiftSyntax/generated/TokenKind.swift b/Sources/SwiftSyntax/generated/TokenKind.swift
index c785702881c..77df7505cb8 100644
--- a/Sources/SwiftSyntax/generated/TokenKind.swift
+++ b/Sources/SwiftSyntax/generated/TokenKind.swift
@@ -101,99 +101,99 @@ public enum TokenKind: Hashable {
   @_spi(Testing)
   public var text: String {
     switch self {
-    case .wildcard: 
+    case .wildcard:
       return #"_"#
-    case .leftParen: 
+    case .leftParen:
       return #"("#
-    case .rightParen: 
+    case .rightParen:
       return #")"#
-    case .leftBrace: 
+    case .leftBrace:
       return #"{"#
-    case .rightBrace: 
+    case .rightBrace:
       return #"}"#
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return #"["#
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return #"]"#
-    case .leftAngle: 
+    case .leftAngle:
       return #"<"#
-    case .rightAngle: 
+    case .rightAngle:
       return #">"#
-    case .period: 
+    case .period:
       return #"."#
-    case .comma: 
+    case .comma:
       return #","#
-    case .ellipsis: 
+    case .ellipsis:
       return #"..."#
-    case .colon: 
+    case .colon:
       return #":"#
-    case .semicolon: 
+    case .semicolon:
       return #";"#
-    case .equal: 
+    case .equal:
       return #"="#
-    case .atSign: 
+    case .atSign:
       return #"@"#
-    case .pound: 
+    case .pound:
       return #"#"#
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return #"&"#
-    case .arrow: 
+    case .arrow:
       return #"->"#
-    case .backtick: 
+    case .backtick:
       return #"`"#
-    case .backslash: 
+    case .backslash:
       return #"\"#
-    case .exclamationMark: 
+    case .exclamationMark:
       return #"!"#
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return #"?"#
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return #"?"#
-    case .stringQuote: 
+    case .stringQuote:
       return #"""#
-    case .singleQuote: 
+    case .singleQuote:
       return #"'"#
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return #"""""#
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return #"#sourceLocation"#
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return #"#if"#
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return #"#else"#
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return #"#elseif"#
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return #"#endif"#
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return #"#available"#
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return #"#unavailable"#
-    case .integerLiteral(let text): 
+    case .integerLiteral(let text):
       return text
-    case .floatingLiteral(let text): 
+    case .floatingLiteral(let text):
       return text
-    case .regexLiteral(let text): 
+    case .regexLiteral(let text):
       return text
-    case .unknown(let text): 
+    case .unknown(let text):
       return text
-    case .identifier(let text): 
+    case .identifier(let text):
       return text
-    case .binaryOperator(let text): 
+    case .binaryOperator(let text):
       return text
-    case .postfixOperator(let text): 
+    case .postfixOperator(let text):
       return text
-    case .prefixOperator(let text): 
+    case .prefixOperator(let text):
       return text
-    case .dollarIdentifier(let text): 
+    case .dollarIdentifier(let text):
       return text
-    case .keyword(let assoc): 
+    case .keyword(let assoc):
       return String(syntaxText: assoc.defaultText)
-    case .rawStringDelimiter(let text): 
+    case .rawStringDelimiter(let text):
       return text
-    case .stringSegment(let text): 
+    case .stringSegment(let text):
       return text
-    case .eof: 
+    case .eof:
       return ""
     }
   }
@@ -202,178 +202,178 @@ public enum TokenKind: Hashable {
   @_spi(RawSyntax)
   public var defaultText: SyntaxText? {
     switch self {
-    case .wildcard: 
+    case .wildcard:
       return #"_"#
-    case .leftParen: 
+    case .leftParen:
       return #"("#
-    case .rightParen: 
+    case .rightParen:
       return #")"#
-    case .leftBrace: 
+    case .leftBrace:
       return #"{"#
-    case .rightBrace: 
+    case .rightBrace:
       return #"}"#
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return #"["#
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return #"]"#
-    case .leftAngle: 
+    case .leftAngle:
       return #"<"#
-    case .rightAngle: 
+    case .rightAngle:
       return #">"#
-    case .period: 
+    case .period:
       return #"."#
-    case .comma: 
+    case .comma:
       return #","#
-    case .ellipsis: 
+    case .ellipsis:
       return #"..."#
-    case .colon: 
+    case .colon:
       return #":"#
-    case .semicolon: 
+    case .semicolon:
       return #";"#
-    case .equal: 
+    case .equal:
       return #"="#
-    case .atSign: 
+    case .atSign:
       return #"@"#
-    case .pound: 
+    case .pound:
       return #"#"#
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return #"&"#
-    case .arrow: 
+    case .arrow:
       return #"->"#
-    case .backtick: 
+    case .backtick:
       return #"`"#
-    case .backslash: 
+    case .backslash:
       return #"\"#
-    case .exclamationMark: 
+    case .exclamationMark:
       return #"!"#
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return #"?"#
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return #"?"#
-    case .stringQuote: 
+    case .stringQuote:
       return #"""#
-    case .singleQuote: 
+    case .singleQuote:
       return #"'"#
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return #"""""#
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return #"#sourceLocation"#
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return #"#if"#
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return #"#else"#
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return #"#elseif"#
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return #"#endif"#
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return #"#available"#
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return #"#unavailable"#
-    case .keyword(let assoc): 
+    case .keyword(let assoc):
       return assoc.defaultText
-    case .eof: 
+    case .eof:
       return ""
-    default: 
+    default:
       return ""
     }
   }
   
   public var nameForDiagnostics: String {
     switch self {
-    case .eof: 
+    case .eof:
       return "end of file"
-    case .wildcard: 
+    case .wildcard:
       return #"wildcard"#
-    case .leftParen: 
+    case .leftParen:
       return #"("#
-    case .rightParen: 
+    case .rightParen:
       return #")"#
-    case .leftBrace: 
+    case .leftBrace:
       return #"{"#
-    case .rightBrace: 
+    case .rightBrace:
       return #"}"#
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return #"["#
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return #"]"#
-    case .leftAngle: 
+    case .leftAngle:
       return #"<"#
-    case .rightAngle: 
+    case .rightAngle:
       return #">"#
-    case .period: 
+    case .period:
       return #"."#
-    case .comma: 
+    case .comma:
       return #","#
-    case .ellipsis: 
+    case .ellipsis:
       return #"..."#
-    case .colon: 
+    case .colon:
       return #":"#
-    case .semicolon: 
+    case .semicolon:
       return #";"#
-    case .equal: 
+    case .equal:
       return #"="#
-    case .atSign: 
+    case .atSign:
       return #"@"#
-    case .pound: 
+    case .pound:
       return #"#"#
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return #"&"#
-    case .arrow: 
+    case .arrow:
       return #"->"#
-    case .backtick: 
+    case .backtick:
       return #"`"#
-    case .backslash: 
+    case .backslash:
       return #"\"#
-    case .exclamationMark: 
+    case .exclamationMark:
       return #"!"#
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return #"?"#
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return #"?"#
-    case .stringQuote: 
+    case .stringQuote:
       return #"""#
-    case .singleQuote: 
+    case .singleQuote:
       return #"'"#
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return #"""""#
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return #"#sourceLocation"#
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return #"#if"#
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return #"#else"#
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return #"#elseif"#
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return #"#endif"#
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return #"#available"#
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return #"#unavailable"#
-    case .integerLiteral: 
+    case .integerLiteral:
       return #"integer literal"#
-    case .floatingLiteral: 
+    case .floatingLiteral:
       return #"floating literal"#
-    case .regexLiteral: 
+    case .regexLiteral:
       return #"regex literal"#
-    case .unknown: 
+    case .unknown:
       return #"token"#
-    case .identifier: 
+    case .identifier:
       return #"identifier"#
-    case .binaryOperator: 
+    case .binaryOperator:
       return #"binary operator"#
-    case .postfixOperator: 
+    case .postfixOperator:
       return #"postfix operator"#
-    case .prefixOperator: 
+    case .prefixOperator:
       return #"prefix operator"#
-    case .dollarIdentifier: 
+    case .dollarIdentifier:
       return #"dollar identifier"#
-    case .rawStringDelimiter: 
+    case .rawStringDelimiter:
       return #"raw string delimiter"#
-    case .stringSegment: 
+    case .stringSegment:
       return #"string segment"#
-    case .keyword(let keyword): 
+    case .keyword(let keyword):
       return String(syntaxText: keyword.defaultText)
     }
   }
@@ -385,99 +385,99 @@ public enum TokenKind: Hashable {
   /// `class`, `func`, or `import`.
   public var isLexerClassifiedKeyword: Bool {
     switch self {
-    case .eof: 
+    case .eof:
       return false
-    case .wildcard: 
+    case .wildcard:
       return false
-    case .leftParen: 
+    case .leftParen:
       return false
-    case .rightParen: 
+    case .rightParen:
       return false
-    case .leftBrace: 
+    case .leftBrace:
       return false
-    case .rightBrace: 
+    case .rightBrace:
       return false
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return false
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return false
-    case .leftAngle: 
+    case .leftAngle:
       return false
-    case .rightAngle: 
+    case .rightAngle:
       return false
-    case .period: 
+    case .period:
       return false
-    case .comma: 
+    case .comma:
       return false
-    case .ellipsis: 
+    case .ellipsis:
       return false
-    case .colon: 
+    case .colon:
       return false
-    case .semicolon: 
+    case .semicolon:
       return false
-    case .equal: 
+    case .equal:
       return false
-    case .atSign: 
+    case .atSign:
       return false
-    case .pound: 
+    case .pound:
       return false
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return false
-    case .arrow: 
+    case .arrow:
       return false
-    case .backtick: 
+    case .backtick:
       return false
-    case .backslash: 
+    case .backslash:
       return false
-    case .exclamationMark: 
+    case .exclamationMark:
       return false
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return false
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return false
-    case .stringQuote: 
+    case .stringQuote:
       return false
-    case .singleQuote: 
+    case .singleQuote:
       return false
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return false
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return true
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return true
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return true
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return true
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return true
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return true
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return true
-    case .integerLiteral: 
+    case .integerLiteral:
       return false
-    case .floatingLiteral: 
+    case .floatingLiteral:
       return false
-    case .regexLiteral: 
+    case .regexLiteral:
       return false
-    case .unknown: 
+    case .unknown:
       return false
-    case .identifier: 
+    case .identifier:
       return false
-    case .binaryOperator: 
+    case .binaryOperator:
       return false
-    case .postfixOperator: 
+    case .postfixOperator:
       return false
-    case .prefixOperator: 
+    case .prefixOperator:
       return false
-    case .dollarIdentifier: 
+    case .dollarIdentifier:
       return false
-    case .rawStringDelimiter: 
+    case .rawStringDelimiter:
       return false
-    case .stringSegment: 
+    case .stringSegment:
       return false
-    case .keyword(let keyword): 
+    case .keyword(let keyword):
       return keyword.isLexerClassified
     }
   }
@@ -489,99 +489,99 @@ public enum TokenKind: Hashable {
   /// quote characters in a string literal.
   public var isPunctuation: Bool {
     switch self {
-    case .eof: 
+    case .eof:
       return false
-    case .wildcard: 
+    case .wildcard:
       return false
-    case .leftParen: 
+    case .leftParen:
       return true
-    case .rightParen: 
+    case .rightParen:
       return true
-    case .leftBrace: 
+    case .leftBrace:
       return true
-    case .rightBrace: 
+    case .rightBrace:
       return true
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return true
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return true
-    case .leftAngle: 
+    case .leftAngle:
       return true
-    case .rightAngle: 
+    case .rightAngle:
       return true
-    case .period: 
+    case .period:
       return true
-    case .comma: 
+    case .comma:
       return true
-    case .ellipsis: 
+    case .ellipsis:
       return true
-    case .colon: 
+    case .colon:
       return true
-    case .semicolon: 
+    case .semicolon:
       return true
-    case .equal: 
+    case .equal:
       return true
-    case .atSign: 
+    case .atSign:
       return true
-    case .pound: 
+    case .pound:
       return true
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return true
-    case .arrow: 
+    case .arrow:
       return true
-    case .backtick: 
+    case .backtick:
       return true
-    case .backslash: 
+    case .backslash:
       return true
-    case .exclamationMark: 
+    case .exclamationMark:
       return true
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return true
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return true
-    case .stringQuote: 
+    case .stringQuote:
       return true
-    case .singleQuote: 
+    case .singleQuote:
       return true
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return true
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return false
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return false
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return false
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return false
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return false
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return false
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return false
-    case .integerLiteral: 
+    case .integerLiteral:
       return false
-    case .floatingLiteral: 
+    case .floatingLiteral:
       return false
-    case .regexLiteral: 
+    case .regexLiteral:
       return false
-    case .unknown: 
+    case .unknown:
       return false
-    case .identifier: 
+    case .identifier:
       return false
-    case .binaryOperator: 
+    case .binaryOperator:
       return false
-    case .postfixOperator: 
+    case .postfixOperator:
       return false
-    case .prefixOperator: 
+    case .prefixOperator:
       return false
-    case .dollarIdentifier: 
+    case .dollarIdentifier:
       return false
-    case .keyword: 
+    case .keyword:
       return false
-    case .rawStringDelimiter: 
+    case .rawStringDelimiter:
       return false
-    case .stringSegment: 
+    case .stringSegment:
       return false
     }
   }
@@ -590,101 +590,101 @@ public enum TokenKind: Hashable {
 extension TokenKind: Equatable {
   public static func == (lhs: TokenKind, rhs: TokenKind) -> Bool {
     switch (lhs, rhs) {
-    case (.eof, .eof): 
+    case (.eof, .eof):
       return true
-    case (.wildcard, .wildcard): 
+    case (.wildcard, .wildcard):
       return true
-    case (.leftParen, .leftParen): 
+    case (.leftParen, .leftParen):
       return true
-    case (.rightParen, .rightParen): 
+    case (.rightParen, .rightParen):
       return true
-    case (.leftBrace, .leftBrace): 
+    case (.leftBrace, .leftBrace):
       return true
-    case (.rightBrace, .rightBrace): 
+    case (.rightBrace, .rightBrace):
       return true
-    case (.leftSquareBracket, .leftSquareBracket): 
+    case (.leftSquareBracket, .leftSquareBracket):
       return true
-    case (.rightSquareBracket, .rightSquareBracket): 
+    case (.rightSquareBracket, .rightSquareBracket):
       return true
-    case (.leftAngle, .leftAngle): 
+    case (.leftAngle, .leftAngle):
       return true
-    case (.rightAngle, .rightAngle): 
+    case (.rightAngle, .rightAngle):
       return true
-    case (.period, .period): 
+    case (.period, .period):
       return true
-    case (.comma, .comma): 
+    case (.comma, .comma):
       return true
-    case (.ellipsis, .ellipsis): 
+    case (.ellipsis, .ellipsis):
       return true
-    case (.colon, .colon): 
+    case (.colon, .colon):
       return true
-    case (.semicolon, .semicolon): 
+    case (.semicolon, .semicolon):
       return true
-    case (.equal, .equal): 
+    case (.equal, .equal):
       return true
-    case (.atSign, .atSign): 
+    case (.atSign, .atSign):
       return true
-    case (.pound, .pound): 
+    case (.pound, .pound):
       return true
-    case (.prefixAmpersand, .prefixAmpersand): 
+    case (.prefixAmpersand, .prefixAmpersand):
       return true
-    case (.arrow, .arrow): 
+    case (.arrow, .arrow):
       return true
-    case (.backtick, .backtick): 
+    case (.backtick, .backtick):
       return true
-    case (.backslash, .backslash): 
+    case (.backslash, .backslash):
       return true
-    case (.exclamationMark, .exclamationMark): 
+    case (.exclamationMark, .exclamationMark):
       return true
-    case (.postfixQuestionMark, .postfixQuestionMark): 
+    case (.postfixQuestionMark, .postfixQuestionMark):
       return true
-    case (.infixQuestionMark, .infixQuestionMark): 
+    case (.infixQuestionMark, .infixQuestionMark):
       return true
-    case (.stringQuote, .stringQuote): 
+    case (.stringQuote, .stringQuote):
       return true
-    case (.singleQuote, .singleQuote): 
+    case (.singleQuote, .singleQuote):
       return true
-    case (.multilineStringQuote, .multilineStringQuote): 
+    case (.multilineStringQuote, .multilineStringQuote):
       return true
-    case (.poundSourceLocationKeyword, .poundSourceLocationKeyword): 
+    case (.poundSourceLocationKeyword, .poundSourceLocationKeyword):
       return true
-    case (.poundIfKeyword, .poundIfKeyword): 
+    case (.poundIfKeyword, .poundIfKeyword):
       return true
-    case (.poundElseKeyword, .poundElseKeyword): 
+    case (.poundElseKeyword, .poundElseKeyword):
       return true
-    case (.poundElseifKeyword, .poundElseifKeyword): 
+    case (.poundElseifKeyword, .poundElseifKeyword):
       return true
-    case (.poundEndifKeyword, .poundEndifKeyword): 
+    case (.poundEndifKeyword, .poundEndifKeyword):
       return true
-    case (.poundAvailableKeyword, .poundAvailableKeyword): 
+    case (.poundAvailableKeyword, .poundAvailableKeyword):
       return true
-    case (.poundUnavailableKeyword, .poundUnavailableKeyword): 
+    case (.poundUnavailableKeyword, .poundUnavailableKeyword):
       return true
-    case (.integerLiteral(let lhsText), .integerLiteral(let rhsText)): 
+    case (.integerLiteral(let lhsText), .integerLiteral(let rhsText)):
       return lhsText == rhsText
-    case (.floatingLiteral(let lhsText), .floatingLiteral(let rhsText)): 
+    case (.floatingLiteral(let lhsText), .floatingLiteral(let rhsText)):
       return lhsText == rhsText
-    case (.regexLiteral(let lhsText), .regexLiteral(let rhsText)): 
+    case (.regexLiteral(let lhsText), .regexLiteral(let rhsText)):
       return lhsText == rhsText
-    case (.unknown(let lhsText), .unknown(let rhsText)): 
+    case (.unknown(let lhsText), .unknown(let rhsText)):
       return lhsText == rhsText
-    case (.identifier(let lhsText), .identifier(let rhsText)): 
+    case (.identifier(let lhsText), .identifier(let rhsText)):
       return lhsText == rhsText
-    case (.binaryOperator(let lhsText), .binaryOperator(let rhsText)): 
+    case (.binaryOperator(let lhsText), .binaryOperator(let rhsText)):
       return lhsText == rhsText
-    case (.postfixOperator(let lhsText), .postfixOperator(let rhsText)): 
+    case (.postfixOperator(let lhsText), .postfixOperator(let rhsText)):
       return lhsText == rhsText
-    case (.prefixOperator(let lhsText), .prefixOperator(let rhsText)): 
+    case (.prefixOperator(let lhsText), .prefixOperator(let rhsText)):
       return lhsText == rhsText
-    case (.dollarIdentifier(let lhsText), .dollarIdentifier(let rhsText)): 
+    case (.dollarIdentifier(let lhsText), .dollarIdentifier(let rhsText)):
       return lhsText == rhsText
-    case (.keyword(let lhsText), .keyword(let rhsText)): 
+    case (.keyword(let lhsText), .keyword(let rhsText)):
       return lhsText == rhsText
-    case (.rawStringDelimiter(let lhsText), .rawStringDelimiter(let rhsText)): 
+    case (.rawStringDelimiter(let lhsText), .rawStringDelimiter(let rhsText)):
       return lhsText == rhsText
-    case (.stringSegment(let lhsText), .stringSegment(let rhsText)): 
+    case (.stringSegment(let lhsText), .stringSegment(let rhsText)):
       return lhsText == rhsText
-    default: 
+    default:
       return false
     }
   }
@@ -793,77 +793,77 @@ public enum RawTokenKind: UInt8, Equatable, Hashable {
   @_spi(RawSyntax)
   public var defaultText: SyntaxText? {
     switch self {
-    case .eof: 
+    case .eof:
       return ""
-    case .wildcard: 
+    case .wildcard:
       return #"_"#
-    case .leftParen: 
+    case .leftParen:
       return #"("#
-    case .rightParen: 
+    case .rightParen:
       return #")"#
-    case .leftBrace: 
+    case .leftBrace:
       return #"{"#
-    case .rightBrace: 
+    case .rightBrace:
       return #"}"#
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return #"["#
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return #"]"#
-    case .leftAngle: 
+    case .leftAngle:
       return #"<"#
-    case .rightAngle: 
+    case .rightAngle:
       return #">"#
-    case .period: 
+    case .period:
       return #"."#
-    case .comma: 
+    case .comma:
       return #","#
-    case .ellipsis: 
+    case .ellipsis:
       return #"..."#
-    case .colon: 
+    case .colon:
       return #":"#
-    case .semicolon: 
+    case .semicolon:
       return #";"#
-    case .equal: 
+    case .equal:
       return #"="#
-    case .atSign: 
+    case .atSign:
       return #"@"#
-    case .pound: 
+    case .pound:
       return #"#"#
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return #"&"#
-    case .arrow: 
+    case .arrow:
       return #"->"#
-    case .backtick: 
+    case .backtick:
       return #"`"#
-    case .backslash: 
+    case .backslash:
       return #"\"#
-    case .exclamationMark: 
+    case .exclamationMark:
       return #"!"#
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return #"?"#
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return #"?"#
-    case .stringQuote: 
+    case .stringQuote:
       return #"""#
-    case .singleQuote: 
+    case .singleQuote:
       return #"'"#
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return #"""""#
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return #"#sourceLocation"#
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return #"#if"#
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return #"#else"#
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return #"#elseif"#
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return #"#endif"#
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return #"#available"#
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return #"#unavailable"#
-    default: 
+    default:
       return nil
     }
   }
@@ -875,99 +875,99 @@ public enum RawTokenKind: UInt8, Equatable, Hashable {
   /// quote characters in a string literal.
   public var isPunctuation: Bool {
     switch self {
-    case .eof: 
+    case .eof:
       return false
-    case .wildcard: 
+    case .wildcard:
       return false
-    case .leftParen: 
+    case .leftParen:
       return true
-    case .rightParen: 
+    case .rightParen:
       return true
-    case .leftBrace: 
+    case .leftBrace:
       return true
-    case .rightBrace: 
+    case .rightBrace:
       return true
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return true
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return true
-    case .leftAngle: 
+    case .leftAngle:
       return true
-    case .rightAngle: 
+    case .rightAngle:
       return true
-    case .period: 
+    case .period:
       return true
-    case .comma: 
+    case .comma:
       return true
-    case .ellipsis: 
+    case .ellipsis:
       return true
-    case .colon: 
+    case .colon:
       return true
-    case .semicolon: 
+    case .semicolon:
       return true
-    case .equal: 
+    case .equal:
       return true
-    case .atSign: 
+    case .atSign:
       return true
-    case .pound: 
+    case .pound:
       return true
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return true
-    case .arrow: 
+    case .arrow:
       return true
-    case .backtick: 
+    case .backtick:
       return true
-    case .backslash: 
+    case .backslash:
       return true
-    case .exclamationMark: 
+    case .exclamationMark:
       return true
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return true
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return true
-    case .stringQuote: 
+    case .stringQuote:
       return true
-    case .singleQuote: 
+    case .singleQuote:
       return true
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return true
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return false
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return false
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return false
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return false
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return false
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return false
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return false
-    case .integerLiteral: 
+    case .integerLiteral:
       return false
-    case .floatingLiteral: 
+    case .floatingLiteral:
       return false
-    case .regexLiteral: 
+    case .regexLiteral:
       return false
-    case .unknown: 
+    case .unknown:
       return false
-    case .identifier: 
+    case .identifier:
       return false
-    case .binaryOperator: 
+    case .binaryOperator:
       return false
-    case .postfixOperator: 
+    case .postfixOperator:
       return false
-    case .prefixOperator: 
+    case .prefixOperator:
       return false
-    case .dollarIdentifier: 
+    case .dollarIdentifier:
       return false
-    case .keyword: 
+    case .keyword:
       return false
-    case .rawStringDelimiter: 
+    case .rawStringDelimiter:
       return false
-    case .stringSegment: 
+    case .stringSegment:
       return false
     }
   }
@@ -978,136 +978,136 @@ extension TokenKind {
   @_spi(RawSyntax)
   public static func fromRaw(kind rawKind: RawTokenKind, text: String) -> TokenKind {
     switch rawKind {
-    case .eof: 
+    case .eof:
       return .eof
-    case .wildcard: 
+    case .wildcard:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .wildcard
-    case .leftParen: 
+    case .leftParen:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .leftParen
-    case .rightParen: 
+    case .rightParen:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .rightParen
-    case .leftBrace: 
+    case .leftBrace:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .leftBrace
-    case .rightBrace: 
+    case .rightBrace:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .rightBrace
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .leftSquareBracket
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .rightSquareBracket
-    case .leftAngle: 
+    case .leftAngle:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .leftAngle
-    case .rightAngle: 
+    case .rightAngle:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .rightAngle
-    case .period: 
+    case .period:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .period
-    case .comma: 
+    case .comma:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .comma
-    case .ellipsis: 
+    case .ellipsis:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .ellipsis
-    case .colon: 
+    case .colon:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .colon
-    case .semicolon: 
+    case .semicolon:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .semicolon
-    case .equal: 
+    case .equal:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .equal
-    case .atSign: 
+    case .atSign:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .atSign
-    case .pound: 
+    case .pound:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .pound
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .prefixAmpersand
-    case .arrow: 
+    case .arrow:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .arrow
-    case .backtick: 
+    case .backtick:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .backtick
-    case .backslash: 
+    case .backslash:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .backslash
-    case .exclamationMark: 
+    case .exclamationMark:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .exclamationMark
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .postfixQuestionMark
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .infixQuestionMark
-    case .stringQuote: 
+    case .stringQuote:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .stringQuote
-    case .singleQuote: 
+    case .singleQuote:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .singleQuote
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .multilineStringQuote
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .poundSourceLocationKeyword
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .poundIfKeyword
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .poundElseKeyword
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .poundElseifKeyword
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .poundEndifKeyword
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .poundAvailableKeyword
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .poundUnavailableKeyword
-    case .integerLiteral: 
+    case .integerLiteral:
       return .integerLiteral(text)
-    case .floatingLiteral: 
+    case .floatingLiteral:
       return .floatingLiteral(text)
-    case .regexLiteral: 
+    case .regexLiteral:
       return .regexLiteral(text)
-    case .unknown: 
+    case .unknown:
       return .unknown(text)
-    case .identifier: 
+    case .identifier:
       return .identifier(text)
-    case .binaryOperator: 
+    case .binaryOperator:
       return .binaryOperator(text)
-    case .postfixOperator: 
+    case .postfixOperator:
       return .postfixOperator(text)
-    case .prefixOperator: 
+    case .prefixOperator:
       return .prefixOperator(text)
-    case .dollarIdentifier: 
+    case .dollarIdentifier:
       return .dollarIdentifier(text)
-    case .keyword: 
+    case .keyword:
       var text = text
       return text.withSyntaxText { text in 
         return .keyword(Keyword(text)!)
       }
-    case .rawStringDelimiter: 
+    case .rawStringDelimiter:
       return .rawStringDelimiter(text)
-    case .stringSegment: 
+    case .stringSegment:
       return .stringSegment(text)
     }
   }
@@ -1117,99 +1117,99 @@ extension TokenKind {
   @_spi(RawSyntax)
   public func decomposeToRaw() -> (rawKind: RawTokenKind, string: String?) {
     switch self {
-    case .eof: 
+    case .eof:
       return (.eof, nil)
-    case .wildcard: 
+    case .wildcard:
       return (.wildcard, nil)
-    case .leftParen: 
+    case .leftParen:
       return (.leftParen, nil)
-    case .rightParen: 
+    case .rightParen:
       return (.rightParen, nil)
-    case .leftBrace: 
+    case .leftBrace:
       return (.leftBrace, nil)
-    case .rightBrace: 
+    case .rightBrace:
       return (.rightBrace, nil)
-    case .leftSquareBracket: 
+    case .leftSquareBracket:
       return (.leftSquareBracket, nil)
-    case .rightSquareBracket: 
+    case .rightSquareBracket:
       return (.rightSquareBracket, nil)
-    case .leftAngle: 
+    case .leftAngle:
       return (.leftAngle, nil)
-    case .rightAngle: 
+    case .rightAngle:
       return (.rightAngle, nil)
-    case .period: 
+    case .period:
       return (.period, nil)
-    case .comma: 
+    case .comma:
       return (.comma, nil)
-    case .ellipsis: 
+    case .ellipsis:
       return (.ellipsis, nil)
-    case .colon: 
+    case .colon:
       return (.colon, nil)
-    case .semicolon: 
+    case .semicolon:
       return (.semicolon, nil)
-    case .equal: 
+    case .equal:
       return (.equal, nil)
-    case .atSign: 
+    case .atSign:
       return (.atSign, nil)
-    case .pound: 
+    case .pound:
       return (.pound, nil)
-    case .prefixAmpersand: 
+    case .prefixAmpersand:
       return (.prefixAmpersand, nil)
-    case .arrow: 
+    case .arrow:
       return (.arrow, nil)
-    case .backtick: 
+    case .backtick:
       return (.backtick, nil)
-    case .backslash: 
+    case .backslash:
       return (.backslash, nil)
-    case .exclamationMark: 
+    case .exclamationMark:
       return (.exclamationMark, nil)
-    case .postfixQuestionMark: 
+    case .postfixQuestionMark:
       return (.postfixQuestionMark, nil)
-    case .infixQuestionMark: 
+    case .infixQuestionMark:
       return (.infixQuestionMark, nil)
-    case .stringQuote: 
+    case .stringQuote:
       return (.stringQuote, nil)
-    case .singleQuote: 
+    case .singleQuote:
       return (.singleQuote, nil)
-    case .multilineStringQuote: 
+    case .multilineStringQuote:
       return (.multilineStringQuote, nil)
-    case .poundSourceLocationKeyword: 
+    case .poundSourceLocationKeyword:
       return (.poundSourceLocationKeyword, nil)
-    case .poundIfKeyword: 
+    case .poundIfKeyword:
       return (.poundIfKeyword, nil)
-    case .poundElseKeyword: 
+    case .poundElseKeyword:
       return (.poundElseKeyword, nil)
-    case .poundElseifKeyword: 
+    case .poundElseifKeyword:
       return (.poundElseifKeyword, nil)
-    case .poundEndifKeyword: 
+    case .poundEndifKeyword:
       return (.poundEndifKeyword, nil)
-    case .poundAvailableKeyword: 
+    case .poundAvailableKeyword:
       return (.poundAvailableKeyword, nil)
-    case .poundUnavailableKeyword: 
+    case .poundUnavailableKeyword:
       return (.poundUnavailableKeyword, nil)
-    case .integerLiteral(let str): 
+    case .integerLiteral(let str):
       return (.integerLiteral, str)
-    case .floatingLiteral(let str): 
+    case .floatingLiteral(let str):
       return (.floatingLiteral, str)
-    case .regexLiteral(let str): 
+    case .regexLiteral(let str):
       return (.regexLiteral, str)
-    case .unknown(let str): 
+    case .unknown(let str):
       return (.unknown, str)
-    case .identifier(let str): 
+    case .identifier(let str):
       return (.identifier, str)
-    case .binaryOperator(let str): 
+    case .binaryOperator(let str):
       return (.binaryOperator, str)
-    case .postfixOperator(let str): 
+    case .postfixOperator(let str):
       return (.postfixOperator, str)
-    case .prefixOperator(let str): 
+    case .prefixOperator(let str):
       return (.prefixOperator, str)
-    case .dollarIdentifier(let str): 
+    case .dollarIdentifier(let str):
       return (.dollarIdentifier, str)
-    case .keyword(let keyword): 
+    case .keyword(let keyword):
       return (.keyword, String(syntaxText: keyword.defaultText))
-    case .rawStringDelimiter(let str): 
+    case .rawStringDelimiter(let str):
       return (.rawStringDelimiter, str)
-    case .stringSegment(let str): 
+    case .stringSegment(let str):
       return (.stringSegment, str)
     }
   }
diff --git a/Sources/SwiftSyntax/generated/Trivia.swift b/Sources/SwiftSyntax/generated/Trivia.swift
index 49624594cb6..7f30831083b 100644
--- a/Sources/SwiftSyntax/generated/Trivia.swift
+++ b/Sources/SwiftSyntax/generated/Trivia.swift
@@ -86,35 +86,35 @@ extension TriviaPiece: TextOutputStreamable {
       }
     }
     switch self {
-    case let .spaces(count): 
+    case let .spaces(count):
       printRepeated(" ", count: count)
-    case let .tabs(count): 
+    case let .tabs(count):
       printRepeated("\t", count: count)
-    case let .verticalTabs(count): 
+    case let .verticalTabs(count):
       printRepeated("\u{b}", count: count)
-    case let .formfeeds(count): 
+    case let .formfeeds(count):
       printRepeated("\u{c}", count: count)
-    case let .newlines(count): 
+    case let .newlines(count):
       printRepeated("\n", count: count)
-    case let .carriageReturns(count): 
+    case let .carriageReturns(count):
       printRepeated("\r", count: count)
-    case let .carriageReturnLineFeeds(count): 
+    case let .carriageReturnLineFeeds(count):
       printRepeated("\r\n", count: count)
-    case let .lineComment(text): 
+    case let .lineComment(text):
       target.write(text)
-    case let .blockComment(text): 
+    case let .blockComment(text):
       target.write(text)
-    case let .docLineComment(text): 
+    case let .docLineComment(text):
       target.write(text)
-    case let .docBlockComment(text): 
+    case let .docBlockComment(text):
       target.write(text)
-    case let .backslashes(count): 
+    case let .backslashes(count):
       printRepeated(#"\"#, count: count)
-    case let .pounds(count): 
+    case let .pounds(count):
       printRepeated("#", count: count)
-    case let .unexpectedText(text): 
+    case let .unexpectedText(text):
       target.write(text)
-    case let .shebang(text): 
+    case let .shebang(text):
       target.write(text)
     }
   }
@@ -124,35 +124,35 @@ extension TriviaPiece: CustomDebugStringConvertible {
   /// Returns a description used by dump.
   public var debugDescription: String {
     switch self {
-    case .spaces(let data): 
+    case .spaces(let data):
       return "spaces(\(data))"
-    case .tabs(let data): 
+    case .tabs(let data):
       return "tabs(\(data))"
-    case .verticalTabs(let data): 
+    case .verticalTabs(let data):
       return "verticalTabs(\(data))"
-    case .formfeeds(let data): 
+    case .formfeeds(let data):
       return "formfeeds(\(data))"
-    case .newlines(let data): 
+    case .newlines(let data):
       return "newlines(\(data))"
-    case .carriageReturns(let data): 
+    case .carriageReturns(let data):
       return "carriageReturns(\(data))"
-    case .carriageReturnLineFeeds(let data): 
+    case .carriageReturnLineFeeds(let data):
       return "carriageReturnLineFeeds(\(data))"
-    case .lineComment(let name): 
+    case .lineComment(let name):
       return "lineComment(\(name.debugDescription))"
-    case .blockComment(let name): 
+    case .blockComment(let name):
       return "blockComment(\(name.debugDescription))"
-    case .docLineComment(let name): 
+    case .docLineComment(let name):
       return "docLineComment(\(name.debugDescription))"
-    case .docBlockComment(let name): 
+    case .docBlockComment(let name):
       return "docBlockComment(\(name.debugDescription))"
-    case .backslashes(let data): 
+    case .backslashes(let data):
       return "backslashes(\(data))"
-    case .pounds(let data): 
+    case .pounds(let data):
       return "pounds(\(data))"
-    case .unexpectedText(let name): 
+    case .unexpectedText(let name):
       return "unexpectedText(\(name.debugDescription))"
-    case .shebang(let name): 
+    case .shebang(let name):
       return "shebang(\(name.debugDescription))"
     }
   }
@@ -164,9 +164,9 @@ extension TriviaPiece {
     switch self {
     case .newlines, 
         .carriageReturns, 
-        .carriageReturnLineFeeds: 
+        .carriageReturnLineFeeds:
       return true
-    default: 
+    default:
       return false
     }
   }
@@ -409,35 +409,35 @@ extension TriviaPiece: Equatable {}
 extension TriviaPiece {
   public var sourceLength: SourceLength {
     switch self {
-    case let .spaces(count): 
+    case let .spaces(count):
       return SourceLength(utf8Length: count)
-    case let .tabs(count): 
+    case let .tabs(count):
       return SourceLength(utf8Length: count)
-    case let .verticalTabs(count): 
+    case let .verticalTabs(count):
       return SourceLength(utf8Length: count)
-    case let .formfeeds(count): 
+    case let .formfeeds(count):
       return SourceLength(utf8Length: count)
-    case let .newlines(count): 
+    case let .newlines(count):
       return SourceLength(utf8Length: count)
-    case let .carriageReturns(count): 
+    case let .carriageReturns(count):
       return SourceLength(utf8Length: count)
-    case let .carriageReturnLineFeeds(count): 
+    case let .carriageReturnLineFeeds(count):
       return SourceLength(utf8Length: count * 2)
-    case let .lineComment(text): 
+    case let .lineComment(text):
       return SourceLength(of: text)
-    case let .blockComment(text): 
+    case let .blockComment(text):
       return SourceLength(of: text)
-    case let .docLineComment(text): 
+    case let .docLineComment(text):
       return SourceLength(of: text)
-    case let .docBlockComment(text): 
+    case let .docBlockComment(text):
       return SourceLength(of: text)
-    case let .backslashes(count): 
+    case let .backslashes(count):
       return SourceLength(utf8Length: count)
-    case let .pounds(count): 
+    case let .pounds(count):
       return SourceLength(utf8Length: count)
-    case let .unexpectedText(text): 
+    case let .unexpectedText(text):
       return SourceLength(of: text)
-    case let .shebang(text): 
+    case let .shebang(text):
       return SourceLength(of: text)
     }
   }
@@ -481,35 +481,35 @@ public enum RawTriviaPiece: Equatable {
   
   static func make(_ piece: TriviaPiece, arena: SyntaxArena) -> RawTriviaPiece {
     switch piece {
-    case let .spaces(count): 
+    case let .spaces(count):
       return .spaces(count)
-    case let .tabs(count): 
+    case let .tabs(count):
       return .tabs(count)
-    case let .verticalTabs(count): 
+    case let .verticalTabs(count):
       return .verticalTabs(count)
-    case let .formfeeds(count): 
+    case let .formfeeds(count):
       return .formfeeds(count)
-    case let .newlines(count): 
+    case let .newlines(count):
       return .newlines(count)
-    case let .carriageReturns(count): 
+    case let .carriageReturns(count):
       return .carriageReturns(count)
-    case let .carriageReturnLineFeeds(count): 
+    case let .carriageReturnLineFeeds(count):
       return .carriageReturnLineFeeds(count)
-    case let .lineComment(text): 
+    case let .lineComment(text):
       return .lineComment(arena.intern(text))
-    case let .blockComment(text): 
+    case let .blockComment(text):
       return .blockComment(arena.intern(text))
-    case let .docLineComment(text): 
+    case let .docLineComment(text):
       return .docLineComment(arena.intern(text))
-    case let .docBlockComment(text): 
+    case let .docBlockComment(text):
       return .docBlockComment(arena.intern(text))
-    case let .backslashes(count): 
+    case let .backslashes(count):
       return .backslashes(count)
-    case let .pounds(count): 
+    case let .pounds(count):
       return .pounds(count)
-    case let .unexpectedText(text): 
+    case let .unexpectedText(text):
       return .unexpectedText(arena.intern(text))
-    case let .shebang(text): 
+    case let .shebang(text):
       return .shebang(arena.intern(text))
     }
   }
@@ -530,35 +530,35 @@ extension RawTriviaPiece: CustomDebugStringConvertible {
 extension TriviaPiece {
   @_spi(RawSyntax) public init(raw: RawTriviaPiece) {
     switch raw {
-    case let .spaces(count): 
+    case let .spaces(count):
       self = .spaces(count)
-    case let .tabs(count): 
+    case let .tabs(count):
       self = .tabs(count)
-    case let .verticalTabs(count): 
+    case let .verticalTabs(count):
       self = .verticalTabs(count)
-    case let .formfeeds(count): 
+    case let .formfeeds(count):
       self = .formfeeds(count)
-    case let .newlines(count): 
+    case let .newlines(count):
       self = .newlines(count)
-    case let .carriageReturns(count): 
+    case let .carriageReturns(count):
       self = .carriageReturns(count)
-    case let .carriageReturnLineFeeds(count): 
+    case let .carriageReturnLineFeeds(count):
       self = .carriageReturnLineFeeds(count)
-    case let .lineComment(text): 
+    case let .lineComment(text):
       self = .lineComment(String(syntaxText: text))
-    case let .blockComment(text): 
+    case let .blockComment(text):
       self = .blockComment(String(syntaxText: text))
-    case let .docLineComment(text): 
+    case let .docLineComment(text):
       self = .docLineComment(String(syntaxText: text))
-    case let .docBlockComment(text): 
+    case let .docBlockComment(text):
       self = .docBlockComment(String(syntaxText: text))
-    case let .backslashes(count): 
+    case let .backslashes(count):
       self = .backslashes(count)
-    case let .pounds(count): 
+    case let .pounds(count):
       self = .pounds(count)
-    case let .unexpectedText(text): 
+    case let .unexpectedText(text):
       self = .unexpectedText(String(syntaxText: text))
-    case let .shebang(text): 
+    case let .shebang(text):
       self = .shebang(String(syntaxText: text))
     }
   }
@@ -567,70 +567,70 @@ extension TriviaPiece {
 extension RawTriviaPiece {
   public var byteLength: Int {
     switch self {
-    case let .spaces(count): 
+    case let .spaces(count):
       return count
-    case let .tabs(count): 
+    case let .tabs(count):
       return count
-    case let .verticalTabs(count): 
+    case let .verticalTabs(count):
       return count
-    case let .formfeeds(count): 
+    case let .formfeeds(count):
       return count
-    case let .newlines(count): 
+    case let .newlines(count):
       return count
-    case let .carriageReturns(count): 
+    case let .carriageReturns(count):
       return count
-    case let .carriageReturnLineFeeds(count): 
+    case let .carriageReturnLineFeeds(count):
       return count * 2
-    case let .lineComment(text): 
+    case let .lineComment(text):
       return text.count
-    case let .blockComment(text): 
+    case let .blockComment(text):
       return text.count
-    case let .docLineComment(text): 
+    case let .docLineComment(text):
       return text.count
-    case let .docBlockComment(text): 
+    case let .docBlockComment(text):
       return text.count
-    case let .backslashes(count): 
+    case let .backslashes(count):
       return count
-    case let .pounds(count): 
+    case let .pounds(count):
       return count
-    case let .unexpectedText(text): 
+    case let .unexpectedText(text):
       return text.count
-    case let .shebang(text): 
+    case let .shebang(text):
       return text.count
     }
   }
   
   var storedText: SyntaxText? {
     switch self {
-    case .spaces(_): 
+    case .spaces(_):
       return nil
-    case .tabs(_): 
+    case .tabs(_):
       return nil
-    case .verticalTabs(_): 
+    case .verticalTabs(_):
       return nil
-    case .formfeeds(_): 
+    case .formfeeds(_):
       return nil
-    case .newlines(_): 
+    case .newlines(_):
       return nil
-    case .carriageReturns(_): 
+    case .carriageReturns(_):
       return nil
-    case .carriageReturnLineFeeds(_): 
+    case .carriageReturnLineFeeds(_):
       return nil
-    case .lineComment(let text): 
+    case .lineComment(let text):
       return text
-    case .blockComment(let text): 
+    case .blockComment(let text):
       return text
-    case .docLineComment(let text): 
+    case .docLineComment(let text):
       return text
-    case .docBlockComment(let text): 
+    case .docBlockComment(let text):
       return text
-    case .backslashes(_): 
+    case .backslashes(_):
       return nil
-    case .pounds(_): 
+    case .pounds(_):
       return nil
-    case .unexpectedText(let text): 
+    case .unexpectedText(let text):
       return text
-    case .shebang(let text): 
+    case .shebang(let text):
       return text
     }
   }
@@ -642,9 +642,9 @@ extension RawTriviaPiece {
     switch self {
     case .newlines, 
         .carriageReturns, 
-        .carriageReturnLineFeeds: 
+        .carriageReturnLineFeeds:
       return true
-    default: 
+    default:
       return false
     }
   }
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift
index db56b6ff04a..e1ff6302bee 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift
@@ -76,23 +76,23 @@ public struct RawAccessPathComponentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndTrailingDot: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingDot: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingDot: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -192,31 +192,31 @@ public struct RawAccessorBlockSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBrace: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBraceAndAccessors: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var accessors: RawAccessorListSyntax {
-    layoutView.children[3].map(RawAccessorListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawAccessorListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAccessorsAndRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBrace: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -282,55 +282,55 @@ public struct RawAccessorDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifier: RawDeclModifierSyntax? {
-    layoutView.children[3].map(RawDeclModifierSyntax.init(raw: ))
+    layoutView.children[3].map(RawDeclModifierSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifierAndAccessorKind: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var accessorKind: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAccessorKindAndParameter: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var parameter: RawAccessorParameterSyntax? {
-    layoutView.children[7].map(RawAccessorParameterSyntax.init(raw: ))
+    layoutView.children[7].map(RawAccessorParameterSyntax.init(raw:))
   }
   
   public var unexpectedBetweenParameterAndEffectSpecifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var effectSpecifiers: RawDeclEffectSpecifiersSyntax? {
-    layoutView.children[9].map(RawDeclEffectSpecifiersSyntax.init(raw: ))
+    layoutView.children[9].map(RawDeclEffectSpecifiersSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEffectSpecifiersAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax? {
-    layoutView.children[11].map(RawCodeBlockSyntax.init(raw: ))
+    layoutView.children[11].map(RawCodeBlockSyntax.init(raw:))
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -430,31 +430,31 @@ public struct RawAccessorParameterSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -528,71 +528,71 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndActorKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var actorKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenActorKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritanceClause: RawTypeInheritanceClauseSyntax? {
-    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var members: RawMemberDeclBlockSyntax {
-    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw: ))!
+    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -688,23 +688,23 @@ public struct RawArrayElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -758,31 +758,31 @@ public struct RawArrayExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftSquare: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftSquareAndElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elements: RawArrayElementListSyntax {
-    layoutView.children[3].map(RawArrayElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawArrayElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenElementsAndRightSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightSquare: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -836,31 +836,31 @@ public struct RawArrayTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftSquareBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftSquareBracket: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftSquareBracketAndElementType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elementType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenElementTypeAndRightSquareBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightSquareBracket: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightSquareBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -910,23 +910,23 @@ public struct RawArrowExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeEffectSpecifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var effectSpecifiers: RawTypeEffectSpecifiersSyntax? {
-    layoutView.children[1].map(RawTypeEffectSpecifiersSyntax.init(raw: ))
+    layoutView.children[1].map(RawTypeEffectSpecifiersSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEffectSpecifiersAndArrowToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var arrowToken: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterArrowToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -984,39 +984,39 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var asTok: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionOrExclamationMark: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeName: RawTypeSyntax {
-    layoutView.children[7].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1062,15 +1062,15 @@ public struct RawAssignmentExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAssignToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var assignToken: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterAssignToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1140,63 +1140,63 @@ public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndAssociatedtypeKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var associatedtypeKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAssociatedtypeKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndInheritanceClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritanceClause: RawTypeInheritanceClauseSyntax? {
-    layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritanceClauseAndInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var initializer: RawTypeInitializerClauseSyntax? {
-    layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1512,31 +1512,31 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAtSignToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var atSignToken: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAtSignTokenAndAttributeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributeName: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAttributeNameAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLeftParenAndArgument: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var argument: RawSyntax? {
@@ -1544,15 +1544,15 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenArgumentAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1606,31 +1606,31 @@ public struct RawAttributedTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var specifier: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenSpecifierAndAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[3].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[3].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var baseType: RawTypeSyntax {
-    layoutView.children[5].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1720,7 +1720,7 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeEntry: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var entry: RawSyntax {
@@ -1728,15 +1728,15 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenEntryAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1794,39 +1794,39 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var availabilityKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var availabilitySpec: RawAvailabilitySpecListSyntax {
-    layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1884,39 +1884,39 @@ public struct RawAvailabilityEntrySyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndAvailabilityList: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var availabilityList: RawAvailabilitySpecListSyntax {
-    layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAvailabilityListAndSemicolon: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var semicolon: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2002,23 +2002,23 @@ public struct RawAvailabilityLabeledArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var value: RawSyntax {
@@ -2026,7 +2026,7 @@ public struct RawAvailabilityLabeledArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedAfterValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2122,23 +2122,23 @@ public struct RawAvailabilityVersionRestrictionListEntrySyntax: RawSyntaxNodePro
   }
   
   public var unexpectedBeforeAvailabilityVersionRestriction: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var availabilityVersionRestriction: RawAvailabilityVersionRestrictionSyntax {
-    layoutView.children[1].map(RawAvailabilityVersionRestrictionSyntax.init(raw: ))!
+    layoutView.children[1].map(RawAvailabilityVersionRestrictionSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2234,23 +2234,23 @@ public struct RawAvailabilityVersionRestrictionSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePlatform: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var platform: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPlatformAndVersion: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var version: RawVersionTupleSyntax? {
-    layoutView.children[3].map(RawVersionTupleSyntax.init(raw: ))
+    layoutView.children[3].map(RawVersionTupleSyntax.init(raw:))
   }
   
   public var unexpectedAfterVersion: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2300,23 +2300,23 @@ public struct RawAwaitExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAwaitKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var awaitKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAwaitKeywordAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2370,31 +2370,31 @@ public struct RawBackDeployedAttributeSpecListSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var beforeLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBeforeLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndVersionList: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var versionList: RawAvailabilityVersionRestrictionListSyntax {
-    layoutView.children[5].map(RawAvailabilityVersionRestrictionListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawAvailabilityVersionRestrictionListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterVersionList: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2440,15 +2440,15 @@ public struct RawBinaryOperatorExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var operatorToken: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2494,15 +2494,15 @@ public struct RawBooleanLiteralExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBooleanLiteral: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var booleanLiteral: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBooleanLiteral: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2552,23 +2552,23 @@ public struct RawBorrowExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBorrowKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var borrowKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBorrowKeywordAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2618,23 +2618,23 @@ public struct RawBreakStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBreakKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var breakKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBreakKeywordAndLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2734,31 +2734,31 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax {
-    layoutView.children[1].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[1].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whereClause: RawWhereClauseSyntax? {
-    layoutView.children[3].map(RawWhereClauseSyntax.init(raw: ))
+    layoutView.children[3].map(RawWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2858,31 +2858,31 @@ public struct RawCatchClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeCatchKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var catchKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCatchKeywordAndCatchItems: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var catchItems: RawCatchItemListSyntax? {
-    layoutView.children[3].map(RawCatchItemListSyntax.init(raw: ))
+    layoutView.children[3].map(RawCatchItemListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCatchItemsAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[5].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -2982,31 +2982,31 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax? {
-    layoutView.children[1].map(RawPatternSyntax.init(raw: ))
+    layoutView.children[1].map(RawPatternSyntax.init(raw:))
   }
   
   public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whereClause: RawWhereClauseSyntax? {
-    layoutView.children[3].map(RawWhereClauseSyntax.init(raw: ))
+    layoutView.children[3].map(RawWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3080,71 +3080,71 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndClassKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var classKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenClassKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritanceClause: RawTypeInheritanceClauseSyntax? {
-    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var members: RawMemberDeclBlockSyntax {
-    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw: ))!
+    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3190,15 +3190,15 @@ public struct RawClassRestrictionTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeClassKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var classKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterClassKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3302,39 +3302,39 @@ public struct RawClosureCaptureItemSpecifierSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var specifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var detail: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3396,47 +3396,47 @@ public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var specifier: RawClosureCaptureItemSpecifierSyntax? {
-    layoutView.children[1].map(RawClosureCaptureItemSpecifierSyntax.init(raw: ))
+    layoutView.children[1].map(RawClosureCaptureItemSpecifierSyntax.init(raw:))
   }
   
   public var unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenNameAndAssignToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var assignToken: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAssignTokenAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[7].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[7].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3490,31 +3490,31 @@ public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftSquare: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftSquareAndItems: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var items: RawClosureCaptureItemListSyntax? {
-    layoutView.children[3].map(RawClosureCaptureItemListSyntax.init(raw: ))
+    layoutView.children[3].map(RawClosureCaptureItemListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenItemsAndRightSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightSquare: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3572,39 +3572,39 @@ public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBrace: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBraceAndSignature: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var signature: RawClosureSignatureSyntax? {
-    layoutView.children[3].map(RawClosureSignatureSyntax.init(raw: ))
+    layoutView.children[3].map(RawClosureSignatureSyntax.init(raw:))
   }
   
   public var unexpectedBetweenSignatureAndStatements: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var statements: RawCodeBlockItemListSyntax {
-    layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenStatementsAndRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBrace: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3700,23 +3700,23 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3814,23 +3814,23 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndCapture: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var capture: RawClosureCaptureSignatureSyntax? {
-    layoutView.children[3].map(RawClosureCaptureSignatureSyntax.init(raw: ))
+    layoutView.children[3].map(RawClosureCaptureSignatureSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCaptureAndInput: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var input: RawSyntax? {
@@ -3838,31 +3838,31 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var effectSpecifiers: RawTypeEffectSpecifiersSyntax? {
-    layoutView.children[7].map(RawTypeEffectSpecifiersSyntax.init(raw: ))
+    layoutView.children[7].map(RawTypeEffectSpecifiersSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var output: RawReturnClauseSyntax? {
-    layoutView.children[9].map(RawReturnClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawReturnClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inTok: RawTokenSyntax {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterInTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -3998,7 +3998,7 @@ public struct RawCodeBlockItemSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeItem: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var item: RawSyntax {
@@ -4006,15 +4006,15 @@ public struct RawCodeBlockItemSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenItemAndSemicolon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var semicolon: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4068,31 +4068,31 @@ public struct RawCodeBlockSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBrace: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBraceAndStatements: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var statements: RawCodeBlockItemListSyntax {
-    layoutView.children[3].map(RawCodeBlockItemListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawCodeBlockItemListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenStatementsAndRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBrace: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4188,23 +4188,23 @@ public struct RawCompositionTypeElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var type: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenTypeAndAmpersand: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ampersand: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterAmpersand: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4250,15 +4250,15 @@ public struct RawCompositionTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elements: RawCompositionTypeElementListSyntax {
-    layoutView.children[1].map(RawCompositionTypeElementListSyntax.init(raw: ))!
+    layoutView.children[1].map(RawCompositionTypeElementListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4402,7 +4402,7 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeCondition: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var condition: RawSyntax {
@@ -4410,15 +4410,15 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenConditionAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4472,31 +4472,31 @@ public struct RawConformanceRequirementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftTypeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftTypeIdentifier: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftTypeIdentifierAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndRightTypeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightTypeIdentifier: RawTypeSyntax {
-    layoutView.children[5].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightTypeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4546,23 +4546,23 @@ public struct RawConstrainedSugarTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeSomeOrAnySpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var someOrAnySpecifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSomeOrAnySpecifierAndBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var baseType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4612,23 +4612,23 @@ public struct RawContinueStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeContinueKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var continueKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenContinueKeywordAndLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4690,47 +4690,47 @@ public struct RawConventionAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeConventionLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var conventionLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenConventionLabelAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCommaAndCTypeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var cTypeLabel: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCTypeLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenColonAndCTypeString: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var cTypeString: RawStringLiteralExprSyntax? {
-    layoutView.children[9].map(RawStringLiteralExprSyntax.init(raw: ))
+    layoutView.children[9].map(RawStringLiteralExprSyntax.init(raw:))
   }
   
   public var unexpectedAfterCTypeString: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4784,31 +4784,31 @@ public struct RawConventionWitnessMethodAttributeArgumentsSyntax: RawSyntaxNodeP
   }
   
   public var unexpectedBeforeWitnessMethodLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var witnessMethodLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWitnessMethodLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndProtocolName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var protocolName: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterProtocolName: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4858,23 +4858,23 @@ public struct RawDeclEffectSpecifiersSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var asyncSpecifier: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var throwsSpecifier: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -4928,31 +4928,31 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var detail: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5002,23 +5002,23 @@ public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var detail: RawDeclModifierDetailSyntax? {
-    layoutView.children[3].map(RawDeclModifierDetailSyntax.init(raw: ))
+    layoutView.children[3].map(RawDeclModifierDetailSyntax.init(raw:))
   }
   
   public var unexpectedAfterDetail: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5114,23 +5114,23 @@ public struct RawDeclNameArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5184,31 +5184,31 @@ public struct RawDeclNameArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var arguments: RawDeclNameArgumentListSyntax {
-    layoutView.children[3].map(RawDeclNameArgumentListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawDeclNameArgumentListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5258,23 +5258,23 @@ public struct RawDeclNameSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeDeclBaseName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declBaseName: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declNameArguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw: ))
+    layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw:))
   }
   
   public var unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5359,23 +5359,23 @@ public struct RawDeferStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeDeferKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var deferKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDeferKeywordAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[3].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[3].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5433,39 +5433,39 @@ public struct RawDeinitializerDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndDeinitKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var deinitKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDeinitKeywordAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax? {
-    layoutView.children[7].map(RawCodeBlockSyntax.init(raw: ))
+    layoutView.children[7].map(RawCodeBlockSyntax.init(raw:))
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5535,63 +5535,63 @@ public struct RawDerivativeRegistrationAttributeArgumentsSyntax: RawSyntaxNodePr
   }
   
   public var unexpectedBeforeOfLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ofLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenOfLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndOriginalDeclName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var originalDeclName: RawQualifiedDeclNameSyntax {
-    layoutView.children[5].map(RawQualifiedDeclNameSyntax.init(raw: ))!
+    layoutView.children[5].map(RawQualifiedDeclNameSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenOriginalDeclNameAndPeriod: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var period: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenPeriodAndAccessorKind: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var accessorKind: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAccessorKindAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax? {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCommaAndDiffParams: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var diffParams: RawDifferentiabilityParamsClauseSyntax? {
-    layoutView.children[13].map(RawDifferentiabilityParamsClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawDifferentiabilityParamsClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterDiffParams: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5641,23 +5641,23 @@ public struct RawDesignatedTypeElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeadingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leadingComma: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeadingCommaAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5807,39 +5807,39 @@ public struct RawDictionaryElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeKeyExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var keyExpression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenKeyExpressionAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndValueExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var valueExpression: RawExprSyntax {
-    layoutView.children[5].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenValueExpressionAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -5925,15 +5925,15 @@ public struct RawDictionaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftSquare: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftSquareAndContent: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var content: RawSyntax {
@@ -5941,15 +5941,15 @@ public struct RawDictionaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenContentAndRightSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightSquare: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6011,47 +6011,47 @@ public struct RawDictionaryTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftSquareBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftSquareBracket: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftSquareBracketAndKeyType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var keyType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenKeyTypeAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndValueType: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var valueType: RawTypeSyntax {
-    layoutView.children[7].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenValueTypeAndRightSquareBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightSquareBracket: RawTokenSyntax {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightSquareBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6147,23 +6147,23 @@ public struct RawDifferentiabilityParamSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeParameter: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var parameter: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenParameterAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6249,23 +6249,23 @@ public struct RawDifferentiabilityParamsClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeWrtLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var wrtLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWrtLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndParameters: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var parameters: RawSyntax {
@@ -6273,7 +6273,7 @@ public struct RawDifferentiabilityParamsClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedAfterParameters: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6327,31 +6327,31 @@ public struct RawDifferentiabilityParamsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndDiffParams: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var diffParams: RawDifferentiabilityParamListSyntax {
-    layoutView.children[3].map(RawDifferentiabilityParamListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawDifferentiabilityParamListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDiffParamsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6413,47 +6413,47 @@ public struct RawDifferentiableAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeDiffKind: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var diffKind: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDiffKindAndDiffKindComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var diffKindComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDiffKindCommaAndDiffParams: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var diffParams: RawDifferentiabilityParamsClauseSyntax? {
-    layoutView.children[5].map(RawDifferentiabilityParamsClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawDifferentiabilityParamsClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDiffParamsAndDiffParamsComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var diffParamsComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDiffParamsCommaAndWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[9].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6499,15 +6499,15 @@ public struct RawDiscardAssignmentExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeWildcard: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var wildcard: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterWildcard: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6561,31 +6561,31 @@ public struct RawDoStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeDoKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var doKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDoKeywordAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[3].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[3].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBodyAndCatchClauses: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var catchClauses: RawCatchClauseListSyntax? {
-    layoutView.children[5].map(RawCatchClauseListSyntax.init(raw: ))
+    layoutView.children[5].map(RawCatchClauseListSyntax.init(raw:))
   }
   
   public var unexpectedAfterCatchClauses: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6675,23 +6675,23 @@ public struct RawDocumentationAttributeArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var value: RawSyntax {
@@ -6699,15 +6699,15 @@ public struct RawDocumentationAttributeArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenValueAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6807,31 +6807,31 @@ public struct RawDynamicReplacementArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeForLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var forLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenForLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndDeclname: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declname: RawDeclNameSyntax {
-    layoutView.children[5].map(RawDeclNameSyntax.init(raw: ))!
+    layoutView.children[5].map(RawDeclNameSyntax.init(raw:))!
   }
   
   public var unexpectedAfterDeclname: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6877,15 +6877,15 @@ public struct RawEditorPlaceholderDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -6931,15 +6931,15 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7043,39 +7043,39 @@ public struct RawEnumCaseDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndCaseKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var caseKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCaseKeywordAndElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elements: RawEnumCaseElementListSyntax {
-    layoutView.children[7].map(RawEnumCaseElementListSyntax.init(raw: ))!
+    layoutView.children[7].map(RawEnumCaseElementListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7179,39 +7179,39 @@ public struct RawEnumCaseElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndAssociatedValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var associatedValue: RawParameterClauseSyntax? {
-    layoutView.children[3].map(RawParameterClauseSyntax.init(raw: ))
+    layoutView.children[3].map(RawParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAssociatedValueAndRawValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rawValue: RawInitializerClauseSyntax? {
-    layoutView.children[5].map(RawInitializerClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawInitializerClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenRawValueAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7285,71 +7285,71 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndEnumKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var enumKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenEnumKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndGenericParameters: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameters: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParametersAndInheritanceClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritanceClause: RawTypeInheritanceClauseSyntax? {
-    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var members: RawMemberDeclBlockSyntax {
-    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw: ))!
+    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7403,31 +7403,31 @@ public struct RawExposeAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLanguage: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var language: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLanguageAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCommaAndCxxName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var cxxName: RawStringLiteralExprSyntax? {
-    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw: ))
+    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))
   }
   
   public var unexpectedAfterCxxName: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7554,15 +7554,15 @@ public struct RawExpressionPatternSyntax: RawPatternSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7624,47 +7624,47 @@ public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var backslash: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBackslashAndDelimiter: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var delimiter: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDelimiterAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndExpressions: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expressions: RawTupleExprElementListSyntax {
-    layoutView.children[7].map(RawTupleExprElementListSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTupleExprElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7710,15 +7710,15 @@ public struct RawExpressionStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7788,63 +7788,63 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndExtensionKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var extensionKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExtensionKeywordAndExtendedType: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var extendedType: RawTypeSyntax {
-    layoutView.children[7].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExtendedTypeAndInheritanceClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritanceClause: RawTypeInheritanceClauseSyntax? {
-    layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[11].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[11].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var members: RawMemberDeclBlockSyntax {
-    layoutView.children[13].map(RawMemberDeclBlockSyntax.init(raw: ))!
+    layoutView.children[13].map(RawMemberDeclBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7890,15 +7890,15 @@ public struct RawFallthroughStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeFallthroughKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var fallthroughKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterFallthroughKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -7944,15 +7944,15 @@ public struct RawFloatLiteralExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeFloatingDigits: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var floatingDigits: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterFloatingDigits: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8034,87 +8034,87 @@ public struct RawForInStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeForKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var forKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenForKeywordAndTryKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var tryKeyword: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTryKeywordAndAwaitKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var awaitKeyword: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAwaitKeywordAndCaseKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var caseKeyword: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCaseKeywordAndPattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax {
-    layoutView.children[9].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[9].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeAnnotation: RawTypeAnnotationSyntax? {
-    layoutView.children[11].map(RawTypeAnnotationSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeAnnotationSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTypeAnnotationAndInKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inKeyword: RawTokenSyntax {
-    layoutView.children[13].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[13].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenInKeywordAndSequenceExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var sequenceExpr: RawExprSyntax {
-    layoutView.children[15].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[15].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSequenceExprAndWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whereClause: RawWhereClauseSyntax? {
-    layoutView.children[17].map(RawWhereClauseSyntax.init(raw: ))
+    layoutView.children[17].map(RawWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenWhereClauseAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[19].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[19].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[20].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[20].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8164,23 +8164,23 @@ public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var exclamationMark: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8246,55 +8246,55 @@ public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var calledExpression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCalledExpressionAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var argumentList: RawTupleExprElementListSyntax {
-    layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingClosure: RawClosureExprSyntax? {
-    layoutView.children[9].map(RawClosureExprSyntax.init(raw: ))
+    layoutView.children[9].map(RawClosureExprSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? {
-    layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw: ))
+    layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw:))
   }
   
   public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8368,71 +8368,71 @@ public struct RawFunctionDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndFuncKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var funcKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenFuncKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndSignature: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var signature: RawFunctionSignatureSyntax {
-    layoutView.children[11].map(RawFunctionSignatureSyntax.init(raw: ))!
+    layoutView.children[11].map(RawFunctionSignatureSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSignatureAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax? {
-    layoutView.children[15].map(RawCodeBlockSyntax.init(raw: ))
+    layoutView.children[15].map(RawCodeBlockSyntax.init(raw:))
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8556,79 +8556,79 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var firstName: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var secondName: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var type: RawTypeSyntax? {
-    layoutView.children[11].map(RawTypeSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ellipsis: RawTokenSyntax? {
-    layoutView.children[13].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[13].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEllipsisAndDefaultArgument: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var defaultArgument: RawInitializerClauseSyntax? {
-    layoutView.children[15].map(RawInitializerClauseSyntax.init(raw: ))
+    layoutView.children[15].map(RawInitializerClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDefaultArgumentAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[17].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[17].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8682,31 +8682,31 @@ public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeInput: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var input: RawParameterClauseSyntax {
-    layoutView.children[1].map(RawParameterClauseSyntax.init(raw: ))!
+    layoutView.children[1].map(RawParameterClauseSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var effectSpecifiers: RawDeclEffectSpecifiersSyntax? {
-    layoutView.children[3].map(RawDeclEffectSpecifiersSyntax.init(raw: ))
+    layoutView.children[3].map(RawDeclEffectSpecifiersSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var output: RawReturnClauseSyntax? {
-    layoutView.children[5].map(RawReturnClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawReturnClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterOutput: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8768,47 +8768,47 @@ public struct RawFunctionTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var arguments: RawTupleTypeElementListSyntax {
-    layoutView.children[3].map(RawTupleTypeElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTupleTypeElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenRightParenAndEffectSpecifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var effectSpecifiers: RawTypeEffectSpecifiersSyntax? {
-    layoutView.children[7].map(RawTypeEffectSpecifiersSyntax.init(raw: ))
+    layoutView.children[7].map(RawTypeEffectSpecifiersSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var output: RawReturnClauseSyntax {
-    layoutView.children[9].map(RawReturnClauseSyntax.init(raw: ))!
+    layoutView.children[9].map(RawReturnClauseSyntax.init(raw:))!
   }
   
   public var unexpectedAfterOutput: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8862,31 +8862,31 @@ public struct RawGenericArgumentClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftAngleBracket: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftAngleBracketAndArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var arguments: RawGenericArgumentListSyntax {
-    layoutView.children[3].map(RawGenericArgumentListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawGenericArgumentListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentsAndRightAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightAngleBracket: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -8982,23 +8982,23 @@ public struct RawGenericArgumentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeArgumentType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var argumentType: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentTypeAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9056,39 +9056,39 @@ public struct RawGenericParameterClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftAngleBracket: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftAngleBracketAndGenericParameterList: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterList: RawGenericParameterListSyntax {
-    layoutView.children[3].map(RawGenericParameterListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawGenericParameterListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenGenericParameterListAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[5].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndRightAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightAngleBracket: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9200,55 +9200,55 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndEllipsis: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ellipsis: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEllipsisAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenColonAndInheritedType: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritedType: RawTypeSyntax? {
-    layoutView.children[9].map(RawTypeSyntax.init(raw: ))
+    layoutView.children[9].map(RawTypeSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritedTypeAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9384,7 +9384,7 @@ public struct RawGenericRequirementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawSyntax {
@@ -9392,15 +9392,15 @@ public struct RawGenericRequirementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenBodyAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9450,23 +9450,23 @@ public struct RawGenericWhereClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeWhereKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whereKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWhereKeywordAndRequirementList: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var requirementList: RawGenericRequirementListSyntax {
-    layoutView.children[3].map(RawGenericRequirementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawGenericRequirementListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRequirementList: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9524,39 +9524,39 @@ public struct RawGuardStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeGuardKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var guardKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenGuardKeywordAndConditions: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var conditions: RawConditionElementListSyntax {
-    layoutView.children[3].map(RawConditionElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenConditionsAndElseKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elseKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenElseKeywordAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[7].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[7].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9606,23 +9606,23 @@ public struct RawIdentifierExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declNameArguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw: ))
+    layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw:))
   }
   
   public var unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9668,15 +9668,15 @@ public struct RawIdentifierPatternSyntax: RawPatternSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9832,23 +9832,23 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var poundKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var condition: RawExprSyntax? {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))
+    layoutView.children[3].map(RawExprSyntax.init(raw:))
   }
   
   public var unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elements: RawSyntax? {
@@ -9856,7 +9856,7 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedAfterElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -9906,23 +9906,23 @@ public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeClauses: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var clauses: RawIfConfigClauseListSyntax {
-    layoutView.children[1].map(RawIfConfigClauseListSyntax.init(raw: ))!
+    layoutView.children[1].map(RawIfConfigClauseListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenClausesAndPoundEndif: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var poundEndif: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPoundEndif: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10016,39 +10016,39 @@ public struct RawIfExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ifKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var conditions: RawConditionElementListSyntax {
-    layoutView.children[3].map(RawConditionElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[5].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBodyAndElseKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elseKeyword: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenElseKeywordAndElseBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elseBody: RawSyntax? {
@@ -10056,7 +10056,7 @@ public struct RawIfExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedAfterElseBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10114,39 +10114,39 @@ public struct RawImplementsAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var type: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenTypeAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCommaAndDeclBaseName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declBaseName: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declNameArguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw: ))
+    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:))
   }
   
   public var unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10196,23 +10196,23 @@ public struct RawImplicitlyUnwrappedOptionalTypeSyntax: RawTypeSyntaxNodeProtoco
   }
   
   public var unexpectedBeforeWrappedType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var wrappedType: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWrappedTypeAndExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var exclamationMark: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10274,47 +10274,47 @@ public struct RawImportDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndImportTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var importTok: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenImportTokAndImportKind: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var importKind: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenImportKindAndPath: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var path: RawAccessPathSyntax {
-    layoutView.children[9].map(RawAccessPathSyntax.init(raw: ))!
+    layoutView.children[9].map(RawAccessPathSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPath: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10364,23 +10364,23 @@ public struct RawInOutExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAmpersand: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ampersand: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAmpersandAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10434,31 +10434,31 @@ public struct RawInfixOperatorExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftOperand: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftOperand: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftOperandAndOperatorOperand: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var operatorOperand: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenOperatorOperandAndRightOperand: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightOperand: RawExprSyntax {
-    layoutView.children[5].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightOperand: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10554,23 +10554,23 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeName: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10620,23 +10620,23 @@ public struct RawInitializerClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeEqual: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var equal: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var value: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10710,71 +10710,71 @@ public struct RawInitializerDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndInitKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var initKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenInitKeywordAndOptionalMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var optionalMark: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenOptionalMarkAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndSignature: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var signature: RawFunctionSignatureSyntax {
-    layoutView.children[11].map(RawFunctionSignatureSyntax.init(raw: ))!
+    layoutView.children[11].map(RawFunctionSignatureSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSignatureAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax? {
-    layoutView.children[15].map(RawCodeBlockSyntax.init(raw: ))
+    layoutView.children[15].map(RawCodeBlockSyntax.init(raw:))
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10820,15 +10820,15 @@ public struct RawIntegerLiteralExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeDigits: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var digits: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterDigits: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10882,31 +10882,31 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var isTok: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeName: RawTypeSyntax {
-    layoutView.children[5].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -10956,23 +10956,23 @@ public struct RawIsTypePatternSyntax: RawPatternSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIsKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var isKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIsKeywordAndType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var type: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11108,15 +11108,15 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePeriod: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var period: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var component: RawSyntax {
@@ -11124,7 +11124,7 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedAfterComponent: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11178,31 +11178,31 @@ public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var backslash: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBackslashAndRoot: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var root: RawTypeSyntax? {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))
   }
   
   public var unexpectedBetweenRootAndComponents: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var components: RawKeyPathComponentListSyntax {
-    layoutView.children[5].map(RawKeyPathComponentListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawKeyPathComponentListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterComponents: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11248,15 +11248,15 @@ public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionOrExclamationMark: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11310,31 +11310,31 @@ public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declNameArguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw: ))
+    layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericArgumentClause: RawGenericArgumentClauseSyntax? {
-    layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11388,31 +11388,31 @@ public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBracket: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var argumentList: RawTupleExprElementListSyntax {
-    layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBracket: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11470,39 +11470,39 @@ public struct RawLabeledSpecializeEntrySyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var value: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenValueAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11556,31 +11556,31 @@ public struct RawLabeledStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabelName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var labelName: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelNameAndLabelColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var labelColon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelColonAndStatement: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var statement: RawStmtSyntax {
-    layoutView.children[5].map(RawStmtSyntax.init(raw: ))!
+    layoutView.children[5].map(RawStmtSyntax.init(raw:))!
   }
   
   public var unexpectedAfterStatement: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11654,71 +11654,71 @@ public struct RawLayoutRequirementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeTypeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeIdentifier: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenTypeIdentifierAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndLayoutConstraint: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var layoutConstraint: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLayoutConstraintAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLeftParenAndSize: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var size: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenSizeAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax? {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenCommaAndAlignment: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var alignment: RawTokenSyntax? {
-    layoutView.children[13].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[13].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAlignmentAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax? {
-    layoutView.children[15].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[15].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11824,47 +11824,47 @@ public struct RawMacroDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndMacroKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var macroKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMacroKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndSignature: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var signature: RawSyntax {
@@ -11872,23 +11872,23 @@ public struct RawMacroDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenSignatureAndDefinition: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var definition: RawInitializerClauseSyntax? {
-    layoutView.children[13].map(RawInitializerClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawInitializerClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDefinitionAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[15].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[15].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -11962,71 +11962,71 @@ public struct RawMacroExpansionDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var poundToken: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var macro: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericArguments: RawGenericArgumentClauseSyntax? {
-    layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var argumentList: RawTupleExprElementListSyntax {
-    layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax? {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingClosure: RawClosureExprSyntax? {
-    layoutView.children[13].map(RawClosureExprSyntax.init(raw: ))
+    layoutView.children[13].map(RawClosureExprSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? {
-    layoutView.children[15].map(RawMultipleTrailingClosureElementListSyntax.init(raw: ))
+    layoutView.children[15].map(RawMultipleTrailingClosureElementListSyntax.init(raw:))
   }
   
   public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12100,71 +12100,71 @@ public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var poundToken: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var macro: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericArguments: RawGenericArgumentClauseSyntax? {
-    layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var argumentList: RawTupleExprElementListSyntax {
-    layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax? {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingClosure: RawClosureExprSyntax? {
-    layoutView.children[13].map(RawClosureExprSyntax.init(raw: ))
+    layoutView.children[13].map(RawClosureExprSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? {
-    layoutView.children[15].map(RawMultipleTrailingClosureElementListSyntax.init(raw: ))
+    layoutView.children[15].map(RawMultipleTrailingClosureElementListSyntax.init(raw:))
   }
   
   public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12222,39 +12222,39 @@ public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var caseKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCaseKeywordAndPattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax {
-    layoutView.children[3].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[3].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeAnnotation: RawTypeAnnotationSyntax? {
-    layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw: ))
+    layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var initializer: RawInitializerClauseSyntax {
-    layoutView.children[7].map(RawInitializerClauseSyntax.init(raw: ))!
+    layoutView.children[7].map(RawInitializerClauseSyntax.init(raw:))!
   }
   
   public var unexpectedAfterInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12312,39 +12312,39 @@ public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBase: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var base: RawExprSyntax? {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))
+    layoutView.children[1].map(RawExprSyntax.init(raw:))
   }
   
   public var unexpectedBetweenBaseAndDot: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var dot: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDotAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declNameArguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw: ))
+    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:))
   }
   
   public var unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12398,31 +12398,31 @@ public struct RawMemberDeclBlockSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBrace: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBraceAndMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var members: RawMemberDeclListSyntax {
-    layoutView.children[3].map(RawMemberDeclListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawMemberDeclListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMembersAndRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBrace: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12472,23 +12472,23 @@ public struct RawMemberDeclListItemSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeDecl: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var decl: RawDeclSyntax {
-    layoutView.children[1].map(RawDeclSyntax.init(raw: ))!
+    layoutView.children[1].map(RawDeclSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDeclAndSemicolon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var semicolon: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12592,39 +12592,39 @@ public struct RawMemberTypeIdentifierSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var baseType: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBaseTypeAndPeriod: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var period: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPeriodAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericArgumentClause: RawGenericArgumentClauseSyntax? {
-    layoutView.children[7].map(RawGenericArgumentClauseSyntax.init(raw: ))
+    layoutView.children[7].map(RawGenericArgumentClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12678,31 +12678,31 @@ public struct RawMetatypeTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var baseType: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBaseTypeAndPeriod: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var period: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPeriodAndTypeOrProtocol: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeOrProtocol: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterTypeOrProtocol: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12752,23 +12752,23 @@ public struct RawMissingDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedAfterModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12807,7 +12807,7 @@ public struct RawMissingExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpected: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12846,7 +12846,7 @@ public struct RawMissingPatternSyntax: RawPatternSyntaxNodeProtocol {
   }
   
   public var unexpected: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12885,7 +12885,7 @@ public struct RawMissingStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpected: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12924,7 +12924,7 @@ public struct RawMissingSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpected: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -12963,7 +12963,7 @@ public struct RawMissingTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpected: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13059,23 +13059,23 @@ public struct RawMoveExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeMoveKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var moveKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMoveKeywordAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13175,31 +13175,31 @@ public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndClosure: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var closure: RawClosureExprSyntax {
-    layoutView.children[5].map(RawClosureExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawClosureExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterClosure: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13249,23 +13249,23 @@ public struct RawNamedOpaqueReturnTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeGenericParameters: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameters: RawGenericParameterClauseSyntax {
-    layoutView.children[1].map(RawGenericParameterClauseSyntax.init(raw: ))!
+    layoutView.children[1].map(RawGenericParameterClauseSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenGenericParametersAndBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var baseType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13311,15 +13311,15 @@ public struct RawNilLiteralExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeNilKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var nilKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterNilKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13369,23 +13369,23 @@ public struct RawObjCSelectorPieceSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenNameAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13485,31 +13485,31 @@ public struct RawOpaqueReturnTypeOfAttributeArgumentsSyntax: RawSyntaxNodeProtoc
   }
   
   public var unexpectedBeforeMangledName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var mangledName: RawStringLiteralExprSyntax {
-    layoutView.children[1].map(RawStringLiteralExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawStringLiteralExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMangledNameAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCommaAndOrdinal: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ordinal: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterOrdinal: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13571,47 +13571,47 @@ public struct RawOperatorDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndOperatorKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var operatorKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenOperatorKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndOperatorPrecedenceAndTypes: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var operatorPrecedenceAndTypes: RawOperatorPrecedenceAndTypesSyntax? {
-    layoutView.children[9].map(RawOperatorPrecedenceAndTypesSyntax.init(raw: ))
+    layoutView.children[9].map(RawOperatorPrecedenceAndTypesSyntax.init(raw:))
   }
   
   public var unexpectedAfterOperatorPrecedenceAndTypes: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13665,31 +13665,31 @@ public struct RawOperatorPrecedenceAndTypesSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndPrecedenceGroup: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var precedenceGroup: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPrecedenceGroupAndDesignatedTypes: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var designatedTypes: RawDesignatedTypeListSyntax {
-    layoutView.children[5].map(RawDesignatedTypeListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawDesignatedTypeListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterDesignatedTypes: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13747,39 +13747,39 @@ public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var letOrVarKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLetOrVarKeywordAndPattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax {
-    layoutView.children[3].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[3].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeAnnotation: RawTypeAnnotationSyntax? {
-    layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw: ))
+    layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var initializer: RawInitializerClauseSyntax? {
-    layoutView.children[7].map(RawInitializerClauseSyntax.init(raw: ))
+    layoutView.children[7].map(RawInitializerClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13829,23 +13829,23 @@ public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndQuestionMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionMark: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterQuestionMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13895,23 +13895,23 @@ public struct RawOptionalTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeWrappedType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var wrappedType: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWrappedTypeAndQuestionMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionMark: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterQuestionMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -13973,47 +13973,47 @@ public struct RawOriginallyDefinedInArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeModuleLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var moduleLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenModuleLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndModuleName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var moduleName: RawStringLiteralExprSyntax {
-    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenModuleNameAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCommaAndPlatforms: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var platforms: RawAvailabilityVersionRestrictionListSyntax {
-    layoutView.children[9].map(RawAvailabilityVersionRestrictionListSyntax.init(raw: ))!
+    layoutView.children[9].map(RawAvailabilityVersionRestrictionListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPlatforms: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14063,23 +14063,23 @@ public struct RawPackElementExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeEachKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var eachKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenEachKeywordAndPackRefExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var packRefExpr: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPackRefExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14129,23 +14129,23 @@ public struct RawPackExpansionExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeRepeatKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var repeatKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenRepeatKeywordAndPatternExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var patternExpr: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPatternExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14195,23 +14195,23 @@ public struct RawPackExpansionTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeRepeatKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var repeatKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenRepeatKeywordAndPatternType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var patternType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPatternType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14261,23 +14261,23 @@ public struct RawPackReferenceTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeEachKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var eachKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenEachKeywordAndPackType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var packType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPackType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14331,31 +14331,31 @@ public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var parameterList: RawFunctionParameterListSyntax {
-    layoutView.children[3].map(RawFunctionParameterListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawFunctionParameterListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14495,31 +14495,31 @@ public struct RawPatternBindingSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax {
-    layoutView.children[1].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[1].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeAnnotation: RawTypeAnnotationSyntax? {
-    layoutView.children[3].map(RawTypeAnnotationSyntax.init(raw: ))
+    layoutView.children[3].map(RawTypeAnnotationSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var initializer: RawInitializerClauseSyntax? {
-    layoutView.children[5].map(RawInitializerClauseSyntax.init(raw: ))
+    layoutView.children[5].map(RawInitializerClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInitializerAndAccessor: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var accessor: RawSyntax? {
@@ -14527,15 +14527,15 @@ public struct RawPatternBindingSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenAccessorAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14620,23 +14620,23 @@ public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBase: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var base: RawExprSyntax? {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))
+    layoutView.children[1].map(RawExprSyntax.init(raw:))
   }
   
   public var unexpectedBetweenBaseAndConfig: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var config: RawIfConfigDeclSyntax {
-    layoutView.children[3].map(RawIfConfigDeclSyntax.init(raw: ))!
+    layoutView.children[3].map(RawIfConfigDeclSyntax.init(raw:))!
   }
   
   public var unexpectedAfterConfig: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14686,23 +14686,23 @@ public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndOperatorToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var operatorToken: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14772,63 +14772,63 @@ public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var fileArgLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var fileArgColon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var fileName: RawStringLiteralExprSyntax {
-    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenFileNameAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCommaAndLineArgLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var lineArgLabel: RawTokenSyntax {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLineArgLabelAndLineArgColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var lineArgColon: RawTokenSyntax {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLineArgColonAndLineNumber: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var lineNumber: RawTokenSyntax {
-    layoutView.children[13].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[13].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterLineNumber: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14886,39 +14886,39 @@ public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePoundSourceLocation: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var poundSourceLocation: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPoundSourceLocationAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndArgs: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var args: RawPoundSourceLocationArgsSyntax? {
-    layoutView.children[5].map(RawPoundSourceLocationArgsSyntax.init(raw: ))
+    layoutView.children[5].map(RawPoundSourceLocationArgsSyntax.init(raw:))
   }
   
   public var unexpectedBetweenArgsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -14972,31 +14972,31 @@ public struct RawPrecedenceGroupAssignmentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAssignmentKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var assignmentKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAssignmentKeywordAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndFlag: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var flag: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterFlag: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15050,31 +15050,31 @@ public struct RawPrecedenceGroupAssociativitySyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAssociativityKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var associativityKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAssociativityKeywordAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var value: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15230,63 +15230,63 @@ public struct RawPrecedenceGroupDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndPrecedencegroupKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var precedencegroupKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPrecedencegroupKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndLeftBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBrace: RawTokenSyntax {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBraceAndGroupAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var groupAttributes: RawPrecedenceGroupAttributeListSyntax {
-    layoutView.children[11].map(RawPrecedenceGroupAttributeListSyntax.init(raw: ))!
+    layoutView.children[11].map(RawPrecedenceGroupAttributeListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenGroupAttributesAndRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBrace: RawTokenSyntax {
-    layoutView.children[13].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[13].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15336,23 +15336,23 @@ public struct RawPrecedenceGroupNameElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15452,31 +15452,31 @@ public struct RawPrecedenceGroupRelationSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeHigherThanOrLowerThan: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var higherThanOrLowerThan: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenHigherThanOrLowerThanAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndOtherNames: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var otherNames: RawPrecedenceGroupNameListSyntax {
-    layoutView.children[5].map(RawPrecedenceGroupNameListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawPrecedenceGroupNameListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterOtherNames: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15526,23 +15526,23 @@ public struct RawPrefixOperatorExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var operatorToken: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenOperatorTokenAndPostfixExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var postfixExpression: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPostfixExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15596,31 +15596,31 @@ public struct RawPrimaryAssociatedTypeClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftAngleBracket: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var primaryAssociatedTypeList: RawPrimaryAssociatedTypeListSyntax {
-    layoutView.children[3].map(RawPrimaryAssociatedTypeListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawPrimaryAssociatedTypeListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightAngleBracket: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightAngleBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15716,23 +15716,23 @@ public struct RawPrimaryAssociatedTypeSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15806,71 +15806,71 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndProtocolKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var protocolKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenProtocolKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var primaryAssociatedTypeClause: RawPrimaryAssociatedTypeClauseSyntax? {
-    layoutView.children[9].map(RawPrimaryAssociatedTypeClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawPrimaryAssociatedTypeClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritanceClause: RawTypeInheritanceClauseSyntax? {
-    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var members: RawMemberDeclBlockSyntax {
-    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw: ))!
+    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -15928,39 +15928,39 @@ public struct RawQualifiedDeclNameSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeBaseType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var baseType: RawTypeSyntax? {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))
   }
   
   public var unexpectedBetweenBaseTypeAndDot: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var dot: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenDotAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var arguments: RawDeclNameArgumentsSyntax? {
-    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw: ))
+    layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:))
   }
   
   public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16006,15 +16006,15 @@ public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeRegex: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var regex: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRegex: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16072,39 +16072,39 @@ public struct RawRepeatWhileStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeRepeatKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var repeatKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenRepeatKeywordAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[3].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[3].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenBodyAndWhileKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whileKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWhileKeywordAndCondition: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var condition: RawExprSyntax {
-    layoutView.children[7].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[7].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterCondition: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16154,23 +16154,23 @@ public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeArrow: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var arrow: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var returnType: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterReturnType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16220,23 +16220,23 @@ public struct RawReturnStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeReturnKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var returnKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenReturnKeywordAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax? {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))
+    layoutView.children[3].map(RawExprSyntax.init(raw:))
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16290,31 +16290,31 @@ public struct RawSameTypeRequirementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftTypeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftTypeIdentifier: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftTypeIdentifierAndEqualityToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var equalityToken: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenEqualityTokenAndRightTypeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightTypeIdentifier: RawTypeSyntax {
-    layoutView.children[5].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightTypeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16360,15 +16360,15 @@ public struct RawSequenceExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elements: RawExprListSyntax {
-    layoutView.children[1].map(RawExprListSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16418,23 +16418,23 @@ public struct RawSimpleTypeIdentifierSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenNameAndGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericArgumentClause: RawGenericArgumentClauseSyntax? {
-    layoutView.children[3].map(RawGenericArgumentClauseSyntax.init(raw: ))
+    layoutView.children[3].map(RawGenericArgumentClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16484,23 +16484,23 @@ public struct RawSourceFileSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeStatements: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var statements: RawCodeBlockItemListSyntax {
-    layoutView.children[1].map(RawCodeBlockItemListSyntax.init(raw: ))!
+    layoutView.children[1].map(RawCodeBlockItemListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenStatementsAndEOFToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var eofToken: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterEOFToken: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16644,23 +16644,23 @@ public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericArgumentClause: RawGenericArgumentClauseSyntax {
-    layoutView.children[3].map(RawGenericArgumentClauseSyntax.init(raw: ))!
+    layoutView.children[3].map(RawGenericArgumentClauseSyntax.init(raw:))!
   }
   
   public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16757,47 +16757,47 @@ public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeOpenDelimiter: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var openDelimiter: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenOpenDelimiterAndOpenQuote: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var openQuote: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenOpenQuoteAndSegments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var segments: RawStringLiteralSegmentsSyntax {
-    layoutView.children[5].map(RawStringLiteralSegmentsSyntax.init(raw: ))!
+    layoutView.children[5].map(RawStringLiteralSegmentsSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSegmentsAndCloseQuote: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var closeQuote: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCloseQuoteAndCloseDelimiter: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var closeDelimiter: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterCloseDelimiter: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -16921,15 +16921,15 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeContent: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var content: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterContent: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17003,71 +17003,71 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndStructKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var structKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenStructKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritanceClause: RawTypeInheritanceClauseSyntax? {
-    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw: ))
+    layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var members: RawMemberDeclBlockSyntax {
-    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw: ))!
+    layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17173,63 +17173,63 @@ public struct RawSubscriptDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndSubscriptKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var subscriptKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSubscriptKeywordAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[7].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[7].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndIndices: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var indices: RawParameterClauseSyntax {
-    layoutView.children[9].map(RawParameterClauseSyntax.init(raw: ))!
+    layoutView.children[9].map(RawParameterClauseSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIndicesAndResult: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var result: RawReturnClauseSyntax {
-    layoutView.children[11].map(RawReturnClauseSyntax.init(raw: ))!
+    layoutView.children[11].map(RawReturnClauseSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenResultAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericWhereClauseAndAccessor: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var accessor: RawSyntax? {
@@ -17237,7 +17237,7 @@ public struct RawSubscriptDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedAfterAccessor: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17303,55 +17303,55 @@ public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var calledExpression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCalledExpressionAndLeftBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBracket: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var argumentList: RawTupleExprElementListSyntax {
-    layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBracket: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenRightBracketAndTrailingClosure: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingClosure: RawClosureExprSyntax? {
-    layoutView.children[9].map(RawClosureExprSyntax.init(raw: ))
+    layoutView.children[9].map(RawClosureExprSyntax.init(raw:))
   }
   
   public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? {
-    layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw: ))
+    layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw:))
   }
   
   public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17397,15 +17397,15 @@ public struct RawSuperRefExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeSuperKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var superKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterSuperKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17459,31 +17459,31 @@ public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var caseKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var caseItems: RawCaseItemListSyntax {
-    layoutView.children[3].map(RawCaseItemListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawCaseItemListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17647,15 +17647,15 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var unknownAttr: RawAttributeSyntax? {
-    layoutView.children[1].map(RawAttributeSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeSyntax.init(raw:))
   }
   
   public var unexpectedBetweenUnknownAttrAndLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawSyntax {
@@ -17663,15 +17663,15 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBetweenLabelAndStatements: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var statements: RawCodeBlockItemListSyntax {
-    layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw: ))!
+    layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterStatements: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17721,23 +17721,23 @@ public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var defaultKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17799,47 +17799,47 @@ public struct RawSwitchExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var switchKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftBrace: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var cases: RawSwitchCaseListSyntax {
-    layoutView.children[7].map(RawSwitchCaseListSyntax.init(raw: ))!
+    layoutView.children[7].map(RawSwitchCaseListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightBrace: RawTokenSyntax {
-    layoutView.children[9].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17897,39 +17897,39 @@ public struct RawTargetFunctionEntrySyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndDeclname: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var declname: RawDeclNameSyntax {
-    layoutView.children[5].map(RawDeclNameSyntax.init(raw: ))!
+    layoutView.children[5].map(RawDeclNameSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenDeclnameAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -17991,47 +17991,47 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeConditionExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var conditionExpression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenConditionExpressionAndQuestionMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionMark: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var firstChoice: RawExprSyntax {
-    layoutView.children[5].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colonMark: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonMarkAndSecondChoice: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var secondChoice: RawExprSyntax {
-    layoutView.children[9].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[9].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterSecondChoice: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18081,23 +18081,23 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var throwKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18151,31 +18151,31 @@ public struct RawTryExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeTryKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var tryKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenTryKeywordAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionOrExclamationMark: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenQuestionOrExclamationMarkAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[5].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18279,39 +18279,39 @@ public struct RawTupleExprElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var label: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenColonAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[5].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18365,31 +18365,31 @@ public struct RawTupleExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndElementList: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elementList: RawTupleExprElementListSyntax {
-    layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenElementListAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18493,39 +18493,39 @@ public struct RawTuplePatternElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLabelName: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var labelName: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLabelNameAndLabelColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var labelColon: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenLabelColonAndPattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax {
-    layoutView.children[5].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[5].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenPatternAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18579,31 +18579,31 @@ public struct RawTuplePatternSyntax: RawPatternSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elements: RawTuplePatternElementListSyntax {
-    layoutView.children[3].map(RawTuplePatternElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTuplePatternElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenElementsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18723,71 +18723,71 @@ public struct RawTupleTypeElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeInOut: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inOut: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInOutAndName: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var name: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenNameAndSecondName: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var secondName: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var type: RawTypeSyntax {
-    layoutView.children[9].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[9].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var ellipsis: RawTokenSyntax? {
-    layoutView.children[11].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenEllipsisAndInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var initializer: RawInitializerClauseSyntax? {
-    layoutView.children[13].map(RawInitializerClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawInitializerClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenInitializerAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[15].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[15].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18841,31 +18841,31 @@ public struct RawTupleTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndElements: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elements: RawTupleTypeElementListSyntax {
-    layoutView.children[3].map(RawTupleTypeElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTupleTypeElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenElementsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18915,23 +18915,23 @@ public struct RawTypeAnnotationSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var type: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterType: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -18981,23 +18981,23 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var asyncSpecifier: RawTokenSyntax? {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var throwsSpecifier: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19043,15 +19043,15 @@ public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeType: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var type: RawTypeSyntax {
-    layoutView.children[1].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterType: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19101,23 +19101,23 @@ public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndInheritedTypeCollection: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var inheritedTypeCollection: RawInheritedTypeListSyntax {
-    layoutView.children[3].map(RawInheritedTypeListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawInheritedTypeListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterInheritedTypeCollection: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19167,23 +19167,23 @@ public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeEqual: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var equal: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var value: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
   }
   
   public var unexpectedAfterValue: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19288,63 +19288,63 @@ public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndTypealiasKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typealiasKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenTypealiasKeywordAndIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var identifier: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericParameterClause: RawGenericParameterClauseSyntax? {
-    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw: ))
+    layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:))
   }
   
   public var unexpectedBetweenGenericParameterClauseAndInitializer: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var initializer: RawTypeInitializerClauseSyntax {
-    layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw: ))!
+    layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var genericWhereClause: RawGenericWhereClauseSyntax? {
-    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw: ))
+    layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
   
   public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19398,31 +19398,31 @@ public struct RawUnavailableFromAsyncArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeMessageLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var messageLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMessageLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndMessage: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var message: RawStringLiteralExprSyntax {
-    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterMessage: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19476,31 +19476,31 @@ public struct RawUnderscorePrivateAttributeArgumentsSyntax: RawSyntaxNodeProtoco
   }
   
   public var unexpectedBeforeSourceFileLabel: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var sourceFileLabel: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenSourceFileLabelAndColon: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colon: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenColonAndFilename: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var filename: RawStringLiteralExprSyntax {
-    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw: ))!
+    layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterFilename: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19596,23 +19596,23 @@ public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAsTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var asTok: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionOrExclamationMark: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19658,15 +19658,15 @@ public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var isTok: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterIsTok: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19712,15 +19712,15 @@ public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var pattern: RawPatternSyntax {
-    layoutView.children[1].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[1].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedAfterPattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19774,31 +19774,31 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeQuestionMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var questionMark: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var firstChoice: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var colonMark: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterColonMark: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19848,23 +19848,23 @@ public struct RawValueBindingPatternSyntax: RawPatternSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var letOrVarKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLetOrVarKeywordAndValuePattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var valuePattern: RawPatternSyntax {
-    layoutView.children[3].map(RawPatternSyntax.init(raw: ))!
+    layoutView.children[3].map(RawPatternSyntax.init(raw:))!
   }
   
   public var unexpectedAfterValuePattern: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -19922,39 +19922,39 @@ public struct RawVariableDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var attributes: RawAttributeListSyntax? {
-    layoutView.children[1].map(RawAttributeListSyntax.init(raw: ))
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var modifiers: RawModifierListSyntax? {
-    layoutView.children[3].map(RawModifierListSyntax.init(raw: ))
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
   }
   
   public var unexpectedBetweenModifiersAndLetOrVarKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var letOrVarKeyword: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLetOrVarKeywordAndBindings: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var bindings: RawPatternBindingListSyntax {
-    layoutView.children[7].map(RawPatternBindingListSyntax.init(raw: ))!
+    layoutView.children[7].map(RawPatternBindingListSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBindings: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -20008,31 +20008,31 @@ public struct RawVersionTupleSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeMajorMinor: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var majorMinor: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenMajorMinorAndPatchPeriod: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var patchPeriod: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedBetweenPatchPeriodAndPatchVersion: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var patchVersion: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterPatchVersion: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -20082,23 +20082,23 @@ public struct RawWhereClauseSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeWhereKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whereKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWhereKeywordAndGuardResult: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var guardResult: RawExprSyntax {
-    layoutView.children[3].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedAfterGuardResult: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -20152,31 +20152,31 @@ public struct RawWhileStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeWhileKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var whileKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWhileKeywordAndConditions: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var conditions: RawConditionElementListSyntax {
-    layoutView.children[3].map(RawConditionElementListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var body: RawCodeBlockSyntax {
-    layoutView.children[5].map(RawCodeBlockSyntax.init(raw: ))!
+    layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))!
   }
   
   public var unexpectedAfterBody: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -20226,23 +20226,23 @@ public struct RawWildcardPatternSyntax: RawPatternSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeWildcard: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var wildcard: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenWildcardAndTypeAnnotation: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var typeAnnotation: RawTypeAnnotationSyntax? {
-    layoutView.children[3].map(RawTypeAnnotationSyntax.init(raw: ))
+    layoutView.children[3].map(RawTypeAnnotationSyntax.init(raw:))
   }
   
   public var unexpectedAfterTypeAnnotation: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -20292,23 +20292,23 @@ public struct RawYieldExprListElementSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var expression: RawExprSyntax {
-    layoutView.children[1].map(RawExprSyntax.init(raw: ))!
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenExpressionAndComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var comma: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw: ))
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
   
   public var unexpectedAfterComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -20408,31 +20408,31 @@ public struct RawYieldListSyntax: RawSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenLeftParenAndElementList: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var elementList: RawYieldExprListSyntax {
-    layoutView.children[3].map(RawYieldExprListSyntax.init(raw: ))!
+    layoutView.children[3].map(RawYieldExprListSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenElementListAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -20514,15 +20514,15 @@ public struct RawYieldStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedBeforeYieldKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var yieldKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw: ))!
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
   public var unexpectedBetweenYieldKeywordAndYields: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
   public var yields: RawSyntax {
@@ -20530,6 +20530,6 @@ public struct RawYieldStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
   
   public var unexpectedAfterYields: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw: ))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift
index c36a40bf88f..216d6085925 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift
@@ -253,33 +253,33 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "parameter"
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -615,41 +615,41 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "type inheritance clause"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -963,37 +963,37 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "inheritance clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1331,41 +1331,41 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "inheritance clause"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1601,25 +1601,25 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1719,13 +1719,13 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1969,25 +1969,25 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "elements"
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2327,41 +2327,41 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "inheritance clause"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2675,37 +2675,37 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "inheritance clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "generic where clause"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3043,41 +3043,41 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "function signature"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3242,17 +3242,17 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3521,29 +3521,29 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3877,41 +3877,41 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "function signature"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3952,9 +3952,9 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .functionLike(let node): 
+      case .functionLike(let node):
         return node._syntaxNode
-      case .valueLike(let node): 
+      case .valueLike(let node):
         return node._syntaxNode
       }
     }
@@ -4294,41 +4294,41 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "macro signature"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "macro definition"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return "generic where clause"
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4669,41 +4669,41 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4887,17 +4887,17 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5150,29 +5150,29 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5364,25 +5364,25 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "arguments"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5711,37 +5711,37 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6079,41 +6079,41 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "primary associated type clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "inheritance clause"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6453,41 +6453,41 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "type inheritance clause"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6528,9 +6528,9 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .accessors(let node): 
+      case .accessors(let node):
         return node._syntaxNode
-      case .getter(let node): 
+      case .getter(let node):
         return node._syntaxNode
       }
     }
@@ -6870,41 +6870,41 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "generic parameter clause"
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7218,37 +7218,37 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "generic parameter clause"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "generic where clause"
-    case 14: 
+    case 14:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7501,25 +7501,25 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift
index 0b0d26d64a6..3fd31866af8 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift
@@ -175,21 +175,21 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -325,17 +325,17 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -521,25 +521,25 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -639,13 +639,13 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -776,17 +776,17 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -882,13 +882,13 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -981,13 +981,13 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1118,17 +1118,17 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1333,25 +1333,25 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1384,9 +1384,9 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .colon(let node): 
+      case .colon(let node):
         return node._syntaxNode
-      case .elements(let node): 
+      case .elements(let node):
         return node._syntaxNode
       }
     }
@@ -1558,21 +1558,21 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1670,13 +1670,13 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1769,13 +1769,13 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1868,13 +1868,13 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2005,17 +2005,17 @@ public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2291,33 +2291,33 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "called expression"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "arguments"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "trailing closure"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "trailing closures"
-    case 12: 
+    case 12:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2459,17 +2459,17 @@ public struct IdentifierExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2498,9 +2498,9 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .ifExpr(let node): 
+      case .ifExpr(let node):
         return node._syntaxNode
-      case .codeBlock(let node): 
+      case .codeBlock(let node):
         return node._syntaxNode
       }
     }
@@ -2743,29 +2743,29 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "body"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "else body"
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2905,17 +2905,17 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3075,21 +3075,21 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3187,13 +3187,13 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3350,21 +3350,21 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3580,21 +3580,21 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "root"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3925,41 +3925,41 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4196,25 +4196,25 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "base"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "name"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4293,9 +4293,9 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4424,17 +4424,17 @@ public struct MoveExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4530,13 +4530,13 @@ public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4667,17 +4667,17 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4811,17 +4811,17 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4955,17 +4955,17 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5130,17 +5130,17 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5274,17 +5274,17 @@ public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5418,17 +5418,17 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5524,13 +5524,13 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5642,13 +5642,13 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5779,17 +5779,17 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6020,29 +6020,29 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6324,33 +6324,33 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "called expression"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "arguments"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "trailing closure"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "trailing closures"
-    case 12: 
+    case 12:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6454,13 +6454,13 @@ public struct SuperRefExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6688,29 +6688,29 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6928,29 +6928,29 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "condition"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "first choice"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "second choice"
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7116,21 +7116,21 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7311,21 +7311,21 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7423,13 +7423,13 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7560,17 +7560,17 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7666,13 +7666,13 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7765,13 +7765,13 @@ public struct UnresolvedPatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7928,21 +7928,21 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift
index dc0fd1e202a..b547cbfb272 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift
@@ -130,17 +130,17 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "name"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -319,21 +319,21 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -495,21 +495,21 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "name"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -645,17 +645,17 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "value"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -720,45 +720,45 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .argumentList(let node): 
+      case .argumentList(let node):
         return node._syntaxNode
-      case .token(let node): 
+      case .token(let node):
         return node._syntaxNode
-      case .string(let node): 
+      case .string(let node):
         return node._syntaxNode
-      case .availability(let node): 
+      case .availability(let node):
         return node._syntaxNode
-      case .specializeArguments(let node): 
+      case .specializeArguments(let node):
         return node._syntaxNode
-      case .objCName(let node): 
+      case .objCName(let node):
         return node._syntaxNode
-      case .implementsArguments(let node): 
+      case .implementsArguments(let node):
         return node._syntaxNode
-      case .differentiableArguments(let node): 
+      case .differentiableArguments(let node):
         return node._syntaxNode
-      case .derivativeRegistrationArguments(let node): 
+      case .derivativeRegistrationArguments(let node):
         return node._syntaxNode
-      case .backDeployedArguments(let node): 
+      case .backDeployedArguments(let node):
         return node._syntaxNode
-      case .conventionArguments(let node): 
+      case .conventionArguments(let node):
         return node._syntaxNode
-      case .conventionWitnessMethodArguments(let node): 
+      case .conventionWitnessMethodArguments(let node):
         return node._syntaxNode
-      case .opaqueReturnTypeOfAttributeArguments(let node): 
+      case .opaqueReturnTypeOfAttributeArguments(let node):
         return node._syntaxNode
-      case .exposeAttributeArguments(let node): 
+      case .exposeAttributeArguments(let node):
         return node._syntaxNode
-      case .originallyDefinedInArguments(let node): 
+      case .originallyDefinedInArguments(let node):
         return node._syntaxNode
-      case .underscorePrivateAttributeArguments(let node): 
+      case .underscorePrivateAttributeArguments(let node):
         return node._syntaxNode
-      case .dynamicReplacementArguments(let node): 
+      case .dynamicReplacementArguments(let node):
         return node._syntaxNode
-      case .unavailableFromAsyncArguments(let node): 
+      case .unavailableFromAsyncArguments(let node):
         return node._syntaxNode
-      case .effectsArguments(let node): 
+      case .effectsArguments(let node):
         return node._syntaxNode
-      case .documentationArguments(let node): 
+      case .documentationArguments(let node):
         return node._syntaxNode
       }
     }
@@ -1152,29 +1152,29 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "name"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1211,11 +1211,11 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .token(let node): 
+      case .token(let node):
         return node._syntaxNode
-      case .availabilityVersionRestriction(let node): 
+      case .availabilityVersionRestriction(let node):
         return node._syntaxNode
-      case .availabilityLabeledArgument(let node): 
+      case .availabilityLabeledArgument(let node):
         return node._syntaxNode
       }
     }
@@ -1371,17 +1371,17 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1586,25 +1586,25 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1815,25 +1815,25 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1866,9 +1866,9 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .string(let node): 
+      case .string(let node):
         return node._syntaxNode
-      case .version(let node): 
+      case .version(let node):
         return node._syntaxNode
       }
     }
@@ -2043,21 +2043,21 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "value"
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2194,17 +2194,17 @@ public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, Syn
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2339,17 +2339,17 @@ public struct AvailabilityVersionRestrictionSyntax: SyntaxProtocol, SyntaxHashab
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "platform"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "version"
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2531,21 +2531,21 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2707,21 +2707,21 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2902,21 +2902,21 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3113,21 +3113,21 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3315,25 +3315,25 @@ public struct ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3549,29 +3549,29 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3756,21 +3756,21 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3906,17 +3906,17 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "name"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -3945,9 +3945,9 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .simpleInput(let node): 
+      case .simpleInput(let node):
         return node._syntaxNode
-      case .input(let node): 
+      case .input(let node):
         return node._syntaxNode
       }
     }
@@ -4216,33 +4216,33 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4281,11 +4281,11 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .decl(let node): 
+      case .decl(let node):
         return node._syntaxNode
-      case .stmt(let node): 
+      case .stmt(let node):
         return node._syntaxNode
-      case .expr(let node): 
+      case .expr(let node):
         return node._syntaxNode
       }
     }
@@ -4441,17 +4441,17 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4630,21 +4630,21 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "statements"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4780,17 +4780,17 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -4823,13 +4823,13 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .expression(let node): 
+      case .expression(let node):
         return node._syntaxNode
-      case .availability(let node): 
+      case .availability(let node):
         return node._syntaxNode
-      case .matchingPattern(let node): 
+      case .matchingPattern(let node):
         return node._syntaxNode
-      case .optionalBinding(let node): 
+      case .optionalBinding(let node):
         return node._syntaxNode
       }
     }
@@ -4996,17 +4996,17 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5166,21 +5166,21 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5395,29 +5395,29 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5583,21 +5583,21 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5733,17 +5733,17 @@ public struct DeclEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -5903,21 +5903,21 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6053,17 +6053,17 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6197,17 +6197,17 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6386,21 +6386,21 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6538,17 +6538,17 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "base name"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "arguments"
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6817,37 +6817,37 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -6991,17 +6991,17 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7187,25 +7187,25 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "key"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "value"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7343,17 +7343,17 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7382,9 +7382,9 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .parameter(let node): 
+      case .parameter(let node):
         return node._syntaxNode
-      case .parameterList(let node): 
+      case .parameterList(let node):
         return node._syntaxNode
       }
     }
@@ -7558,21 +7558,21 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "parameters"
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7754,21 +7754,21 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -7984,29 +7984,29 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -8041,9 +8041,9 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .token(let node): 
+      case .token(let node):
         return node._syntaxNode
-      case .string(let node): 
+      case .string(let node):
         return node._syntaxNode
       }
     }
@@ -8242,25 +8242,25 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -8424,21 +8424,21 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -8630,25 +8630,25 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "associated values"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -8812,21 +8812,21 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -9059,29 +9059,29 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -9500,45 +9500,45 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "attributes"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "modifiers"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "internal name"
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return "type"
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return "default argument"
-    case 16: 
+    case 16:
       return nil
-    case 17: 
+    case 17:
       return nil
-    case 18: 
+    case 18:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -9712,21 +9712,21 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -9907,21 +9907,21 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -10057,17 +10057,17 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -10272,25 +10272,25 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -10598,33 +10598,33 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "name"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "parameter pack specifier"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "inherited type"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -10663,11 +10663,11 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .sameTypeRequirement(let node): 
+      case .sameTypeRequirement(let node):
         return node._syntaxNode
-      case .conformanceRequirement(let node): 
+      case .conformanceRequirement(let node):
         return node._syntaxNode
-      case .layoutRequirement(let node): 
+      case .layoutRequirement(let node):
         return node._syntaxNode
       }
     }
@@ -10821,17 +10821,17 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -10984,17 +10984,17 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -11029,15 +11029,15 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .statements(let node): 
+      case .statements(let node):
         return node._syntaxNode
-      case .switchCases(let node): 
+      case .switchCases(let node):
         return node._syntaxNode
-      case .decls(let node): 
+      case .decls(let node):
         return node._syntaxNode
-      case .postfixExpression(let node): 
+      case .postfixExpression(let node):
         return node._syntaxNode
-      case .attributes(let node): 
+      case .attributes(let node):
         return node._syntaxNode
       }
     }
@@ -11274,21 +11274,21 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "condition"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -11480,25 +11480,25 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "type"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "declaration base name"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "declaration name arguments"
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -11636,17 +11636,17 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -11780,17 +11780,17 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -11821,11 +11821,11 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .property(let node): 
+      case .property(let node):
         return node._syntaxNode
-      case .subscript(let node): 
+      case .subscript(let node):
         return node._syntaxNode
-      case .optional(let node): 
+      case .optional(let node):
         return node._syntaxNode
       }
     }
@@ -11979,17 +11979,17 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -12085,13 +12085,13 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -12248,21 +12248,21 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -12443,21 +12443,21 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "arguments"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -12649,25 +12649,25 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "value"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -12961,41 +12961,41 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "constrained type"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return "size"
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "alignment"
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -13193,25 +13193,25 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -13394,21 +13394,21 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -13546,17 +13546,17 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -13631,9 +13631,9 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -13788,21 +13788,21 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -13938,17 +13938,17 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "name"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -14110,21 +14110,21 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -14307,21 +14307,21 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "precedence group"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -14509,25 +14509,25 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -14762,29 +14762,29 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -14969,21 +14969,21 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "parameters"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -15014,9 +15014,9 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .accessors(let node): 
+      case .accessors(let node):
         return node._syntaxNode
-      case .getter(let node): 
+      case .getter(let node):
         return node._syntaxNode
       }
     }
@@ -15240,29 +15240,29 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "type annotation"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -15532,37 +15532,37 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "file name"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return "line number"
-    case 14: 
+    case 14:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -15733,21 +15733,21 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -15910,21 +15910,21 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -16060,17 +16060,17 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "name"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -16251,21 +16251,21 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -16446,21 +16446,21 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -16596,17 +16596,17 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "name"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -16834,25 +16834,25 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "base type"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "base name"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "arguments"
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -16990,17 +16990,17 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "return type"
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -17160,21 +17160,21 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "left-hand type"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "right-hand type"
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -17329,17 +17329,17 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -17435,13 +17435,13 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -17617,21 +17617,21 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -17662,9 +17662,9 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .default(let node): 
+      case .default(let node):
         return node._syntaxNode
-      case .case(let node): 
+      case .case(let node):
         return node._syntaxNode
       }
     }
@@ -17855,21 +17855,21 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "label"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -18005,17 +18005,17 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -18205,25 +18205,25 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "declaration name"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -18413,25 +18413,25 @@ public struct TupleExprElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "value"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -18621,25 +18621,25 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -18933,41 +18933,41 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "name"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "internal name"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -19113,17 +19113,17 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -19257,17 +19257,17 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -19420,17 +19420,17 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -19564,17 +19564,17 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "type"
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -19734,21 +19734,21 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -19910,21 +19910,21 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -20089,21 +20089,21 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -20239,17 +20239,17 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -20383,17 +20383,17 @@ public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -20572,21 +20572,21 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift
index 64a44e0776f..d8071cba0ac 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift
@@ -92,13 +92,13 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -191,13 +191,13 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -328,17 +328,17 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -413,9 +413,9 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -589,21 +589,21 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -739,17 +739,17 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -883,17 +883,17 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift
index b2c7d822091..5e2c3f5fd88 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift
@@ -130,17 +130,17 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "label"
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -274,17 +274,17 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "label"
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -418,17 +418,17 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -607,21 +607,21 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "body"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -719,13 +719,13 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -818,13 +818,13 @@ public struct FallthroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1163,49 +1163,49 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    case 11: 
+    case 11:
       return nil
-    case 12: 
+    case 12:
       return nil
-    case 13: 
+    case 13:
       return nil
-    case 14: 
+    case 14:
       return nil
-    case 15: 
+    case 15:
       return nil
-    case 16: 
+    case 16:
       return nil
-    case 17: 
+    case 17:
       return nil
-    case 18: 
+    case 18:
       return nil
-    case 19: 
+    case 19:
       return "body"
-    case 20: 
+    case 20:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1426,25 +1426,25 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "condition"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "body"
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1608,21 +1608,21 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "label name"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1699,9 +1699,9 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1882,25 +1882,25 @@ public struct RepeatWhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "body"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "condition"
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2069,17 +2069,17 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2213,17 +2213,17 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2402,21 +2402,21 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2447,9 +2447,9 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     
     public var _syntaxNode: Syntax {
       switch self {
-      case .yieldList(let node): 
+      case .yieldList(let node):
         return node._syntaxNode
-      case .simpleYield(let node): 
+      case .simpleYield(let node):
         return node._syntaxNode
       }
     }
@@ -2595,17 +2595,17 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift
index fdbaad9a0bf..fbda1a8a5bb 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift
@@ -156,21 +156,21 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -351,21 +351,21 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -463,13 +463,13 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -581,13 +581,13 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -718,17 +718,17 @@ public struct ConstrainedSugarTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -940,29 +940,29 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return "key type"
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return "value type"
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1199,29 +1199,29 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    case 9: 
+    case 9:
       return nil
-    case 10: 
+    case 10:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1361,17 +1361,17 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1557,25 +1557,25 @@ public struct MemberTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "base type"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return "name"
-    case 6: 
+    case 6:
       return nil
-    case 7: 
+    case 7:
       return nil
-    case 8: 
+    case 8:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1739,21 +1739,21 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return "base type"
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1830,9 +1830,9 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -1961,17 +1961,17 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2105,17 +2105,17 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2249,17 +2249,17 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2393,17 +2393,17 @@ public struct PackReferenceTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2537,17 +2537,17 @@ public struct SimpleTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }
@@ -2726,21 +2726,21 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
-    case 0: 
+    case 0:
       return nil
-    case 1: 
+    case 1:
       return nil
-    case 2: 
+    case 2:
       return nil
-    case 3: 
+    case 3:
       return nil
-    case 4: 
+    case 4:
       return nil
-    case 5: 
+    case 5:
       return nil
-    case 6: 
+    case 6:
       return nil
-    default: 
+    default:
       fatalError("Invalid index")
     }
   }