From bcf256e4812263ae910eb24008638f9892011a8b Mon Sep 17 00:00:00 2001 From: Rintaro Ishizaki Date: Sun, 25 Aug 2024 17:56:05 -0700 Subject: [PATCH] [Syntax] Introduce SyntaxLayout This replaces most use case of `keyPathInParent` and `SyntaxNodeStructure.layout`. Since getting and comparing `KeyPath` is not trivial, `keyPathInParent` were suffered from performance issue, Newly introduced `SyntaxProtocol.propertyInParent` is trivial, and comparing it with a SyntaxLayoutProperty is also trivial. --- .../SyntaxSupport/SyntaxNodeKind.swift | 13 - .../GenerateSwiftSyntax.swift | 3 +- .../ChildNameForDiagnosticsFile.swift | 10 +- .../swiftsyntax/ChildNameForKeyPathFile.swift | 46 - .../ConcreteSyntaxPropertyFile.swift | 51 + .../swiftsyntax/SyntaxBaseNodesFile.swift | 25 +- .../swiftsyntax/SyntaxCollectionsFile.swift | 2 +- .../swiftsyntax/SyntaxKindFile.swift | 14 + .../SyntaxLayoutPropertyName.swift | 42 + .../swiftsyntax/SyntaxNodesFile.swift | 8 +- Sources/SwiftBasicFormat/BasicFormat.swift | 88 +- .../SwiftIDEUtils/SyntaxClassification.swift | 32 +- Sources/SwiftIDEUtils/SyntaxClassifier.swift | 11 +- .../generated/ChildNameForDiagnostics.swift | 350 +- Sources/SwiftSyntax/CMakeLists.txt | 4 +- Sources/SwiftSyntax/SyntaxCollection.swift | 6 +- Sources/SwiftSyntax/SyntaxLayout.swift | 158 + Sources/SwiftSyntax/SyntaxProtocol.swift | 9 +- .../generated/ChildNameForKeyPath.swift | 3515 -------- .../generated/ConcreteSyntaxProperty.swift | 7489 +++++++++++++++++ .../generated/SyntaxBaseNodes.swift | 54 +- .../generated/SyntaxCollections.swift | 204 +- .../SwiftSyntax/generated/SyntaxKind.swift | 475 ++ .../generated/SyntaxLayoutPropertyName.swift | 3517 ++++++++ .../generated/syntaxNodes/SyntaxNodesAB.swift | 144 +- .../generated/syntaxNodes/SyntaxNodesC.swift | 150 +- .../generated/syntaxNodes/SyntaxNodesD.swift | 138 +- .../generated/syntaxNodes/SyntaxNodesEF.swift | 138 +- .../syntaxNodes/SyntaxNodesGHI.swift | 156 +- .../syntaxNodes/SyntaxNodesJKLMN.swift | 174 +- .../generated/syntaxNodes/SyntaxNodesOP.swift | 174 +- .../syntaxNodes/SyntaxNodesQRS.swift | 144 +- .../syntaxNodes/SyntaxNodesTUVWXYZ.swift | 186 +- .../SyntaxProtocol+Initializer.swift | 20 +- 34 files changed, 13355 insertions(+), 4195 deletions(-) delete mode 100644 CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ChildNameForKeyPathFile.swift create mode 100644 CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ConcreteSyntaxPropertyFile.swift create mode 100644 CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxLayoutPropertyName.swift create mode 100644 Sources/SwiftSyntax/SyntaxLayout.swift delete mode 100644 Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift create mode 100644 Sources/SwiftSyntax/generated/ConcreteSyntaxProperty.swift create mode 100644 Sources/SwiftSyntax/generated/SyntaxLayoutPropertyName.swift diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index 5038fa3d39c..d0212eaa368 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -376,19 +376,6 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon return "\(syntaxType)Protocol" } - /// For base node types, generates the name of the protocol to which all - /// concrete leaf nodes that derive from this base kind should conform. - /// - /// - Warning: This property can only be accessed for base node kinds; attempting to - /// access it for a non-base kind will result in a runtime error. - public var leafProtocolType: TypeSyntax { - if isBase { - return "_Leaf\(syntaxType)NodeProtocol" - } else { - fatalError("Only base kind can define leaf protocol") - } - } - /// If the syntax kind has been renamed, the previous raw value that is now /// deprecated. public var deprecatedRawValue: String? { diff --git a/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift b/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift index 4889bf1d639..b51cd025ec3 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift @@ -115,7 +115,7 @@ struct GenerateSwiftSyntax: AsyncParsableCommand { ), // SwiftSyntax - GeneratedFileSpec(swiftSyntaxGeneratedDir + ["ChildNameForKeyPath.swift"], childNameForKeyPathFile), + GeneratedFileSpec(swiftSyntaxGeneratedDir + ["ConcreteSyntaxProperty.swift"], concreteSyntaxPropertyFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["Keyword.swift"], keywordFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["raw", "RawSyntaxValidation.swift"], rawSyntaxValidationFile), GeneratedFileSpec( @@ -128,6 +128,7 @@ struct GenerateSwiftSyntax: AsyncParsableCommand { GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxCollections.swift"], syntaxCollectionsFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxEnum.swift"], syntaxEnumFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxKind.swift"], syntaxKindFile), + GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxLayoutPropertyName.swift"], syntaxLayoutPropertyNameFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxRewriter.swift"], syntaxRewriterFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxTraits.swift"], syntaxTraitsFile), GeneratedFileSpec( diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftparserdiagnostics/ChildNameForDiagnosticsFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftparserdiagnostics/ChildNameForDiagnosticsFile.swift index 11cc8d4585a..ab016cb3798 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftparserdiagnostics/ChildNameForDiagnosticsFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftparserdiagnostics/ChildNameForDiagnosticsFile.swift @@ -27,13 +27,13 @@ let childNameForDiagnosticFile = SourceFileSyntax(leadingTrivia: copyrightHeader ) try! FunctionDeclSyntax( - "private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String?" + "private func childNameForDiagnostics(_ property: SyntaxLayoutProperty) -> String?" ) { - try! SwitchExprSyntax("switch keyPath") { + try! SwitchExprSyntax("switch property") { for node in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode) { for child in node.children { if let nameForDiagnostics = child.nameForDiagnostics { - SwitchCaseSyntax("case \\\(node.type.syntaxBaseName).\(child.memberCallName):") { + SwitchCaseSyntax("case \(node.type.syntaxBaseName).layout[.\(child.memberCallName)]:") { StmtSyntax(#"return "\#(raw: nameForDiagnostics)""#) } } @@ -52,10 +52,10 @@ let childNameForDiagnosticFile = SourceFileSyntax(leadingTrivia: copyrightHeader """ extension SyntaxProtocol { var childNameInParent: String? { - guard let keyPath = self.keyPathInParent else { + guard let property = self.propertyInParent else { return nil } - return childNameForDiagnostics(keyPath) + return childNameForDiagnostics(property) } } """ diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ChildNameForKeyPathFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ChildNameForKeyPathFile.swift deleted file mode 100644 index 39e27eddc5e..00000000000 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ChildNameForKeyPathFile.swift +++ /dev/null @@ -1,46 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -import SwiftSyntax -import SwiftSyntaxBuilder -import SyntaxSupport -import Utils - -let childNameForKeyPathFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { - try! FunctionDeclSyntax( - """ - /// If the keyPath is one from a layout structure, return the property name - /// of it. - @_spi(RawSyntax) - public func childName(_ keyPath: AnyKeyPath) -> String? - """ - ) { - try! SwitchExprSyntax("switch keyPath") { - for node in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode) { - for child in node.children { - SwitchCaseSyntax( - """ - case \\\(node.type.syntaxBaseName).\(child.memberCallName): - return \(literal: child.identifier.description) - """ - ) - } - } - SwitchCaseSyntax( - """ - default: - return nil - """ - ) - } - } -} diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ConcreteSyntaxPropertyFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ConcreteSyntaxPropertyFile.swift new file mode 100644 index 00000000000..158aa3c7367 --- /dev/null +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/ConcreteSyntaxPropertyFile.swift @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax +import SwiftSyntaxBuilder +import SyntaxSupport +import Utils + +let concreteSyntaxPropertyFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { + DeclSyntax( + """ + extension ConcreteSyntaxProperty { + fileprivate init(_ index: Int) { + self.index = .init(index) + } + } + """ + ) + + for node in NON_BASE_SYNTAX_NODES { + if let layoutNode = node.layoutNode { + try! ExtensionDeclSyntax( + "\(node.apiAttributes())extension ConcreteSyntaxProperty where Base == \(node.kind.syntaxType)" + ) { + for (index, child) in layoutNode.children.enumerated() { + let childType: TypeSyntax = + child.kind.isNodeChoicesEmpty + ? child.syntaxNodeKind.syntaxType + : "\(node.kind.syntaxType).\(child.syntaxChoicesType)" + let type = child.isOptional ? TypeSyntax("\(childType)?") : TypeSyntax("\(childType)") + DeclSyntax( + """ + public static var \(child.varDeclName): ConcreteSyntaxProperty<\(node.kind.syntaxType), \(type)> { + .init(\(raw: index)) + } + """ + ) + } + } + } + } +} diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift index e308b4364e6..349b7e8ecbe 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift @@ -287,8 +287,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { } } - leafProtocolDecl(type: node.kind.leafProtocolType, inheritedType: node.kind.protocolType) - leafProtocolExtension(type: node.kind.leafProtocolType, inheritedType: node.kind.protocolType) + leafProtocolExtension(inheritedType: node.kind.protocolType) } try! ExtensionDeclSyntax( @@ -317,27 +316,13 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { } } - leafProtocolDecl(type: "_LeafSyntaxNodeProtocol", inheritedType: "SyntaxProtocol") - leafProtocolExtension(type: "_LeafSyntaxNodeProtocol", inheritedType: "SyntaxProtocol") + leafProtocolExtension(inheritedType: "SyntaxProtocol") } -private func leafProtocolDecl(type: TypeSyntax, inheritedType: TypeSyntax) -> DeclSyntax { - DeclSyntax( - """ - /// Protocol that syntax nodes conform to if they don't have any semantic subtypes. - /// These are syntax nodes that are not considered base nodes for other syntax types. - /// - /// Syntax nodes conforming to this protocol have their inherited casting methods - /// deprecated to prevent incorrect casting. - public protocol \(type): \(inheritedType) {} - """ - ) -} - -private func leafProtocolExtension(type: TypeSyntax, inheritedType: TypeSyntax) -> DeclSyntax { - DeclSyntax( +private func leafProtocolExtension(inheritedType: TypeSyntax) -> DeclSyntax { + return DeclSyntax( #""" - extension \#(type) { + extension _LeafSyntaxNodeProtocol where Self: \#(inheritedType) { /// Checks if the current leaf syntax node can be cast to a different specified type. /// /// - Returns: `false` since the leaf node cannot be cast to a different specified type. diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxCollectionsFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxCollectionsFile.swift index cb5697b6a81..f83e044fc90 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxCollectionsFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxCollectionsFile.swift @@ -59,7 +59,7 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { """ ) - DeclSyntax("public static let syntaxKind = SyntaxKind.\(node.memberCallName)") + DeclSyntax("public static var syntaxKind: SyntaxKind { .\(node.enumCaseCallName) }") } } } diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxKindFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxKindFile.swift index 2403c551d7e..1a887abf046 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxKindFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxKindFile.swift @@ -46,6 +46,20 @@ let syntaxKindFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { } } + try VariableDeclSyntax("public var isLayout: Bool") { + try SwitchExprSyntax("switch self") { + for node in SYNTAX_NODES where node.layoutNode != nil { + SwitchCaseSyntax("case .\(node.enumCaseCallName):") { + StmtSyntax("return true") + } + } + + SwitchCaseSyntax("default:") { + StmtSyntax("return false") + } + } + } + try VariableDeclSyntax("public var isMissing: Bool") { try SwitchExprSyntax("switch self") { for name in SyntaxNodeKind.allCases where name.isMissing { diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxLayoutPropertyName.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxLayoutPropertyName.swift new file mode 100644 index 00000000000..a1e9f31b80a --- /dev/null +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxLayoutPropertyName.swift @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax +import SwiftSyntaxBuilder +import SyntaxSupport +import Utils + +let syntaxLayoutPropertyNameFile = try! SourceFileSyntax(leadingTrivia: copyrightHeader) { + try ExtensionDeclSyntax("extension SyntaxLayoutProperty") { + try VariableDeclSyntax( + """ + /// Property name if this is a valid property. + /// 'nil' if the `syntaxKind` is not a layout syntax, or the index is out of range. + @_spi(RawSyntax) + public var name: String? + """ + ) { + try SwitchExprSyntax("switch (self.syntaxKind, self.index.value)") { + for node in NON_BASE_SYNTAX_NODES { + if let layoutNode = node.layoutNode { + for (index, child) in layoutNode.children.enumerated() { + SwitchCaseSyntax("case (.\(node.enumCaseCallName), \(literal: index)):") { + StmtSyntax("return \(literal: child.identifier.description)") + } + } + } + } + SwitchCaseSyntax("default: return nil") + } + } + } +} diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift index 7fc4e916377..cf439501cc7 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift @@ -30,7 +30,7 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax { \(SwiftSyntax.Trivia(joining: [node.documentation, node.experimentalDocNote, node.grammar, node.containedIn]))\ \(node.node.apiAttributes())\ - public struct \(node.kind.syntaxType): \(node.baseType.syntaxBaseName)Protocol, SyntaxHashable, \(node.base.leafProtocolType) + public struct \(node.kind.syntaxType): \(node.baseType.syntaxBaseName)Protocol, SyntaxHashable, _LayoutSyntaxNodeProtocol """ ) { for childNodeChoices in node.node.childrenNodeChoices() { @@ -208,6 +208,12 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax { } } + // ======== + // Metadata + // ======== + + DeclSyntax("public static var syntaxKind: SyntaxKind { .\(node.enumCaseCallName) }") + let layout = ArrayExprSyntax { for child in node.children { ArrayElementSyntax( diff --git a/Sources/SwiftBasicFormat/BasicFormat.swift b/Sources/SwiftBasicFormat/BasicFormat.swift index 1cf8b170bcb..7455182a37b 100644 --- a/Sources/SwiftBasicFormat/BasicFormat.swift +++ b/Sources/SwiftBasicFormat/BasicFormat.swift @@ -188,39 +188,40 @@ open class BasicFormat: SyntaxRewriter { /// Whether a leading newline on `token` should be added. open func requiresIndent(_ node: some SyntaxProtocol) -> Bool { - guard let keyPath = node.keyPathInParent else { + + guard let property = node.propertyInParent else { return false } - switch keyPath { - case \AccessorBlockSyntax.accessors: + switch property { + case AccessorBlockSyntax.layout[.accessors]: return true - case \ArrayExprSyntax.elements: + case ArrayExprSyntax.layout[.elements]: return true - case \ClosureExprSyntax.statements: + case ClosureExprSyntax.layout[.statements]: return true - case \ClosureParameterClauseSyntax.parameters: + case ClosureParameterClauseSyntax.layout[.parameters]: return true - case \CodeBlockSyntax.statements: + case CodeBlockSyntax.layout[.statements]: return true - case \DictionaryElementSyntax.value: + case DictionaryElementSyntax.layout[.value]: return true - case \DictionaryExprSyntax.content: + case DictionaryExprSyntax.layout[.content]: return true - case \EnumCaseParameterClauseSyntax.parameters: + case EnumCaseParameterClauseSyntax.layout[.parameters]: return true - case \FunctionCallExprSyntax.arguments: + case FunctionCallExprSyntax.layout[.arguments]: return true - case \FunctionTypeSyntax.parameters: + case FunctionTypeSyntax.layout[.parameters]: return true - case \MemberDeclBlockSyntax.members: + case MemberBlockSyntax.layout[.members]: return true - case \ParameterClauseSyntax.parameters: + case FunctionParameterClauseSyntax.layout[.parameters]: return true - case \SwitchCaseSyntax.statements: + case SwitchCaseSyntax.layout[.statements]: return true - case \TupleExprSyntax.elements: + case TupleExprSyntax.layout[.elements]: return true - case \TupleTypeSyntax.elements: + case TupleTypeSyntax.layout[.elements]: return true default: return false @@ -234,17 +235,17 @@ open class BasicFormat: SyntaxRewriter { /// as a closure or if it gets interpreted as the statements body. We should /// thus be conservative and not add a newline after the `{` in `BasicFormat`. private func isLeftBraceOfClosureInStmtConditionExpr(_ token: TokenSyntax?) -> Bool { - guard let token, token.keyPathInParent == \ClosureExprSyntax.leftBrace else { + guard let token, token.propertyInParent == ClosureExprSyntax.layout[.leftBrace] else { return false } return token.ancestorOrSelf(mapping: { - switch $0.keyPathInParent { - case \CatchItemSyntax.pattern, - \ConditionElementSyntax.condition, - \ExpressionPatternSyntax.expression, - \ForStmtSyntax.sequence, - \ForStmtSyntax.whereClause, - \SwitchExprSyntax.subject: + switch $0.propertyInParent { + case CatchItemSyntax.layout[.pattern], + ConditionElementSyntax.layout[.condition], + ExpressionPatternSyntax.layout[.expression], + ForStmtSyntax.layout[.sequence], + ForStmtSyntax.layout[.whereClause], + SwitchExprSyntax.layout[.subject]: return $0 default: return nil @@ -275,11 +276,8 @@ open class BasicFormat: SyntaxRewriter { if let ancestorsParent = ancestor.parent, childrenSeparatedByNewline(ancestorsParent) { return true } - switch ancestor.keyPathInParent { - case \IfConfigClauseSyntax.elements: + if ancestor.propertyInParent == IfConfigClauseSyntax.layout[.elements] { return true - default: - break } } } @@ -363,9 +361,9 @@ open class BasicFormat: SyntaxRewriter { (nil, _): return false case (_, .colon): - switch second?.keyPathInParent { - case \TernaryExprSyntax.colon, - \UnresolvedTernaryExprSyntax.colon: + switch second?.propertyInParent { + case TernaryExprSyntax.layout[.colon], + UnresolvedTernaryExprSyntax.layout[.colon]: break default: return false @@ -377,12 +375,12 @@ open class BasicFormat: SyntaxRewriter { // `<` and `>` need to be separated by a space because otherwise they become an operator return false case (_, .leftParen): - switch second?.keyPathInParent { - case \ClosureParameterClauseSyntax.leftParen, - \FunctionTypeSyntax.leftParen, - \TupleExprSyntax.leftParen, - \TuplePatternSyntax.leftParen, - \TupleTypeSyntax.leftParen: + switch second?.propertyInParent { + case ClosureParameterClauseSyntax.layout[.leftParen], + FunctionTypeSyntax.layout[.leftParen], + TupleExprSyntax.layout[.leftParen], + TuplePatternSyntax.layout[.leftParen], + TupleTypeSyntax.layout[.leftParen]: break default: return false @@ -392,13 +390,13 @@ open class BasicFormat: SyntaxRewriter { break } - switch first?.keyPathInParent { - case \ExpressionSegmentSyntax.backslash, - \ExpressionSegmentSyntax.rightParen, - \DeclNameArgumentSyntax.colon, - \SimpleStringLiteralExprSyntax.openingQuote, - \StringLiteralExprSyntax.openingQuote, - \RegexLiteralExprSyntax.openingSlash: + switch first?.propertyInParent { + case ExpressionSegmentSyntax.layout[.backslash], + ExpressionSegmentSyntax.layout[.rightParen], + DeclNameArgumentSyntax.layout[.colon], + SimpleStringLiteralExprSyntax.layout[.openingQuote], + StringLiteralExprSyntax.layout[.openingQuote], + RegexLiteralExprSyntax.layout[.openingSlash]: return false default: break diff --git a/Sources/SwiftIDEUtils/SyntaxClassification.swift b/Sources/SwiftIDEUtils/SyntaxClassification.swift index 1979483c777..83265392775 100644 --- a/Sources/SwiftIDEUtils/SyntaxClassification.swift +++ b/Sources/SwiftIDEUtils/SyntaxClassification.swift @@ -63,35 +63,35 @@ extension SyntaxClassification { /// - childKind: The node syntax kind. /// - Returns: A pair of classification and whether it is "forced", or nil if /// no classification is attached. - internal static func classify(_ keyPath: AnyKeyPath) -> (SyntaxClassification, Bool)? { - switch keyPath { - case \AttributeSyntax.attributeName: + internal static func classify(_ property: SyntaxLayoutProperty) -> (SyntaxClassification, Bool)? { + switch property { + case AttributeSyntax.layout[.attributeName]: return (.attribute, true) - case \PlatformVersionItemSyntax.platformVersion: + case PlatformVersionItemSyntax.layout[.platformVersion]: return (.keyword, false) - case \AvailabilityVersionRestrictionSyntax.platform: + case PlatformVersionSyntax.layout[.platform]: return (.keyword, false) - case \DeclModifierSyntax.name: + case DeclModifierSyntax.layout[.name]: return (.attribute, false) - case \IfConfigClauseSyntax.poundKeyword: + case IfConfigClauseSyntax.layout[.poundKeyword]: return (.ifConfigDirective, false) - case \IfConfigClauseSyntax.condition: + case IfConfigClauseSyntax.layout[.condition]: return (.ifConfigDirective, false) - case \IfConfigDeclSyntax.poundEndif: + case IfConfigDeclSyntax.layout[.poundEndif]: return (.ifConfigDirective, false) - case \MemberTypeIdentifierSyntax.name: + case MemberTypeSyntax.layout[.name]: return (.type, false) - case \OperatorDeclSyntax.name: + case OperatorDeclSyntax.layout[.name]: return (.operator, false) - case \PrecedenceGroupAssociativitySyntax.associativityLabel: + case PrecedenceGroupAssociativitySyntax.layout[.associativityLabel]: return (.keyword, false) - case \PrecedenceGroupRelationSyntax.higherThanOrLowerThanLabel: + case PrecedenceGroupRelationSyntax.layout[.higherThanOrLowerThanLabel]: return (.keyword, false) - case \SimpleTypeIdentifierSyntax.name: + case IdentifierTypeSyntax.layout[.name]: return (.type, false) - case \FunctionParameterSyntax.firstName: + case FunctionParameterSyntax.layout[.firstName]: return (.argumentLabel, false) - case \LabeledExprSyntax.label: + case LabeledExprSyntax.layout[.label]: return (.argumentLabel, false) default: return nil diff --git a/Sources/SwiftIDEUtils/SyntaxClassifier.swift b/Sources/SwiftIDEUtils/SyntaxClassifier.swift index 52ac4dd713c..bcdb7398d7a 100644 --- a/Sources/SwiftIDEUtils/SyntaxClassifier.swift +++ b/Sources/SwiftIDEUtils/SyntaxClassifier.swift @@ -21,8 +21,8 @@ fileprivate extension SyntaxProtocol { var contextualClassif: (SyntaxClassification, Bool)? = nil var curData = Syntax(self) repeat { - guard let parent = curData.parent, let keyPath = curData.keyPathInParent else { break } - contextualClassif = SyntaxClassification.classify(keyPath) + guard let parent = curData.parent, let property = curData.propertyInParent else { break } + contextualClassif = SyntaxClassification.classify(property) curData = parent } while contextualClassif == nil return contextualClassif @@ -202,11 +202,8 @@ private struct ClassificationVisitor { for case (let index, let child?) in children.enumerated() { let classification: (classification: SyntaxClassification, force: Bool)? - if case .layout(let layout) = descriptor.node.kind.syntaxNodeType.structure { - classification = SyntaxClassification.classify(layout[index]) - } else { - classification = nil - } + let property = SyntaxLayoutProperty(syntaxKind: descriptor.node.kind, index: .init(index)) + classification = SyntaxClassification.classify(property) if let classification, classification.force { // Leading trivia. diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift index bc48ad45b7f..3f474f1bb17 100644 --- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift @@ -18,349 +18,349 @@ @_spi(ExperimentalLanguageFeatures) import SwiftSyntax #endif -private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { - switch keyPath { - case \AccessorDeclSyntax.attributes: +private func childNameForDiagnostics(_ property: SyntaxLayoutProperty) -> String? { + switch property { + case AccessorDeclSyntax.layout[.attributes]: return "attributes" - case \AccessorDeclSyntax.modifier: + case AccessorDeclSyntax.layout[.modifier]: return "modifiers" - case \AccessorDeclSyntax.parameters: + case AccessorDeclSyntax.layout[.parameters]: return "parameter" - case \AccessorParametersSyntax.name: + case AccessorParametersSyntax.layout[.name]: return "name" - case \ActorDeclSyntax.attributes: + case ActorDeclSyntax.layout[.attributes]: return "attributes" - case \ActorDeclSyntax.modifiers: + case ActorDeclSyntax.layout[.modifiers]: return "modifiers" - case \ActorDeclSyntax.genericParameterClause: + case ActorDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \ActorDeclSyntax.inheritanceClause: + case ActorDeclSyntax.layout[.inheritanceClause]: return "inheritance clause" - case \ActorDeclSyntax.genericWhereClause: + case ActorDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \ArrayElementSyntax.expression: + case ArrayElementSyntax.layout[.expression]: return "value" - case \AssociatedTypeDeclSyntax.attributes: + case AssociatedTypeDeclSyntax.layout[.attributes]: return "attributes" - case \AssociatedTypeDeclSyntax.modifiers: + case AssociatedTypeDeclSyntax.layout[.modifiers]: return "modifiers" - case \AssociatedTypeDeclSyntax.inheritanceClause: + case AssociatedTypeDeclSyntax.layout[.inheritanceClause]: return "inheritance clause" - case \AssociatedTypeDeclSyntax.genericWhereClause: + case AssociatedTypeDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \AttributeSyntax.attributeName: + case AttributeSyntax.layout[.attributeName]: return "name" - case \AvailabilityLabeledArgumentSyntax.label: + case AvailabilityLabeledArgumentSyntax.layout[.label]: return "label" - case \AvailabilityLabeledArgumentSyntax.value: + case AvailabilityLabeledArgumentSyntax.layout[.value]: return "value" - case \BreakStmtSyntax.label: + case BreakStmtSyntax.layout[.label]: return "label" - case \ClassDeclSyntax.attributes: + case ClassDeclSyntax.layout[.attributes]: return "attributes" - case \ClassDeclSyntax.modifiers: + case ClassDeclSyntax.layout[.modifiers]: return "modifiers" - case \ClassDeclSyntax.genericParameterClause: + case ClassDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \ClassDeclSyntax.inheritanceClause: + case ClassDeclSyntax.layout[.inheritanceClause]: return "inheritance clause" - case \ClassDeclSyntax.genericWhereClause: + case ClassDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \ClosureParameterClauseSyntax.parameters: + case ClosureParameterClauseSyntax.layout[.parameters]: return "parameters" - case \ClosureParameterSyntax.attributes: + case ClosureParameterSyntax.layout[.attributes]: return "attributes" - case \ClosureParameterSyntax.modifiers: + case ClosureParameterSyntax.layout[.modifiers]: return "modifiers" - case \ClosureParameterSyntax.type: + case ClosureParameterSyntax.layout[.type]: return "type" - case \ClosureShorthandParameterSyntax.name: + case ClosureShorthandParameterSyntax.layout[.name]: return "name" - case \ClosureSignatureSyntax.attributes: + case ClosureSignatureSyntax.layout[.attributes]: return "attributes" - case \CodeBlockSyntax.statements: + case CodeBlockSyntax.layout[.statements]: return "statements" - case \ContinueStmtSyntax.label: + case ContinueStmtSyntax.layout[.label]: return "label" - case \DeinitializerDeclSyntax.attributes: + case DeinitializerDeclSyntax.layout[.attributes]: return "attributes" - case \DeinitializerDeclSyntax.modifiers: + case DeinitializerDeclSyntax.layout[.modifiers]: return "modifiers" - case \DictionaryElementSyntax.key: + case DictionaryElementSyntax.layout[.key]: return "key" - case \DictionaryElementSyntax.value: + case DictionaryElementSyntax.layout[.value]: return "value" - case \DictionaryTypeSyntax.key: + case DictionaryTypeSyntax.layout[.key]: return "key type" - case \DictionaryTypeSyntax.value: + case DictionaryTypeSyntax.layout[.value]: return "value type" - case \DifferentiabilityWithRespectToArgumentSyntax.arguments: + case DifferentiabilityWithRespectToArgumentSyntax.layout[.arguments]: return "arguments" - case \DoExprSyntax.body: + case DoExprSyntax.layout[.body]: return "body" - case \DoStmtSyntax.body: + case DoStmtSyntax.layout[.body]: return "body" - case \DocumentationAttributeArgumentSyntax.label: + case DocumentationAttributeArgumentSyntax.layout[.label]: return "label" - case \EnumCaseDeclSyntax.attributes: + case EnumCaseDeclSyntax.layout[.attributes]: return "attributes" - case \EnumCaseDeclSyntax.modifiers: + case EnumCaseDeclSyntax.layout[.modifiers]: return "modifiers" - case \EnumCaseDeclSyntax.elements: + case EnumCaseDeclSyntax.layout[.elements]: return "elements" - case \EnumCaseElementSyntax.parameterClause: + case EnumCaseElementSyntax.layout[.parameterClause]: return "associated values" - case \EnumCaseParameterClauseSyntax.parameters: + case EnumCaseParameterClauseSyntax.layout[.parameters]: return "parameters" - case \EnumCaseParameterSyntax.modifiers: + case EnumCaseParameterSyntax.layout[.modifiers]: return "modifiers" - case \EnumCaseParameterSyntax.type: + case EnumCaseParameterSyntax.layout[.type]: return "type" - case \EnumCaseParameterSyntax.defaultValue: + case EnumCaseParameterSyntax.layout[.defaultValue]: return "default value" - case \EnumDeclSyntax.attributes: + case EnumDeclSyntax.layout[.attributes]: return "attributes" - case \EnumDeclSyntax.modifiers: + case EnumDeclSyntax.layout[.modifiers]: return "modifiers" - case \EnumDeclSyntax.genericParameterClause: + case EnumDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \EnumDeclSyntax.inheritanceClause: + case EnumDeclSyntax.layout[.inheritanceClause]: return "inheritance clause" - case \EnumDeclSyntax.genericWhereClause: + case EnumDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \ExtensionDeclSyntax.attributes: + case ExtensionDeclSyntax.layout[.attributes]: return "attributes" - case \ExtensionDeclSyntax.modifiers: + case ExtensionDeclSyntax.layout[.modifiers]: return "modifiers" - case \ExtensionDeclSyntax.inheritanceClause: + case ExtensionDeclSyntax.layout[.inheritanceClause]: return "inheritance clause" - case \ExtensionDeclSyntax.genericWhereClause: + case ExtensionDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \ForStmtSyntax.body: + case ForStmtSyntax.layout[.body]: return "body" - case \FunctionCallExprSyntax.calledExpression: + case FunctionCallExprSyntax.layout[.calledExpression]: return "called expression" - case \FunctionCallExprSyntax.arguments: + case FunctionCallExprSyntax.layout[.arguments]: return "arguments" - case \FunctionCallExprSyntax.trailingClosure: + case FunctionCallExprSyntax.layout[.trailingClosure]: return "trailing closure" - case \FunctionCallExprSyntax.additionalTrailingClosures: + case FunctionCallExprSyntax.layout[.additionalTrailingClosures]: return "trailing closures" - case \FunctionDeclSyntax.attributes: + case FunctionDeclSyntax.layout[.attributes]: return "attributes" - case \FunctionDeclSyntax.modifiers: + case FunctionDeclSyntax.layout[.modifiers]: return "modifiers" - case \FunctionDeclSyntax.genericParameterClause: + case FunctionDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \FunctionDeclSyntax.signature: + case FunctionDeclSyntax.layout[.signature]: return "function signature" - case \FunctionDeclSyntax.genericWhereClause: + case FunctionDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \FunctionParameterClauseSyntax.parameters: + case FunctionParameterClauseSyntax.layout[.parameters]: return "parameters" - case \FunctionParameterSyntax.attributes: + case FunctionParameterSyntax.layout[.attributes]: return "attributes" - case \FunctionParameterSyntax.modifiers: + case FunctionParameterSyntax.layout[.modifiers]: return "modifiers" - case \FunctionParameterSyntax.secondName: + case FunctionParameterSyntax.layout[.secondName]: return "internal name" - case \FunctionParameterSyntax.type: + case FunctionParameterSyntax.layout[.type]: return "type" - case \FunctionParameterSyntax.defaultValue: + case FunctionParameterSyntax.layout[.defaultValue]: return "default value" - case \GenericParameterSyntax.specifier: + case GenericParameterSyntax.layout[.specifier]: return "specifier" - case \GenericParameterSyntax.name: + case GenericParameterSyntax.layout[.name]: return "name" - case \GenericParameterSyntax.inheritedType: + case GenericParameterSyntax.layout[.inheritedType]: return "inherited type" - case \GuardStmtSyntax.conditions: + case GuardStmtSyntax.layout[.conditions]: return "condition" - case \GuardStmtSyntax.body: + case GuardStmtSyntax.layout[.body]: return "body" - case \IfConfigClauseSyntax.condition: + case IfConfigClauseSyntax.layout[.condition]: return "condition" - case \IfExprSyntax.body: + case IfExprSyntax.layout[.body]: return "body" - case \IfExprSyntax.elseBody: + case IfExprSyntax.layout[.elseBody]: return "else body" - case \ImplementsAttributeArgumentsSyntax.type: + case ImplementsAttributeArgumentsSyntax.layout[.type]: return "type" - case \ImplementsAttributeArgumentsSyntax.declName: + case ImplementsAttributeArgumentsSyntax.layout[.declName]: return "declaration name" - case \ImportDeclSyntax.attributes: + case ImportDeclSyntax.layout[.attributes]: return "attributes" - case \ImportDeclSyntax.modifiers: + case ImportDeclSyntax.layout[.modifiers]: return "modifiers" - case \ImportPathComponentSyntax.name: + case ImportPathComponentSyntax.layout[.name]: return "name" - case \InitializerDeclSyntax.attributes: + case InitializerDeclSyntax.layout[.attributes]: return "attributes" - case \InitializerDeclSyntax.modifiers: + case InitializerDeclSyntax.layout[.modifiers]: return "modifiers" - case \InitializerDeclSyntax.genericParameterClause: + case InitializerDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \InitializerDeclSyntax.signature: + case InitializerDeclSyntax.layout[.signature]: return "function signature" - case \InitializerDeclSyntax.genericWhereClause: + case InitializerDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \KeyPathExprSyntax.root: + case KeyPathExprSyntax.layout[.root]: return "root" - case \KeyPathSubscriptComponentSyntax.arguments: + case KeyPathSubscriptComponentSyntax.layout[.arguments]: return "arguments" - case \LabeledExprSyntax.label: + case LabeledExprSyntax.layout[.label]: return "label" - case \LabeledExprSyntax.expression: + case LabeledExprSyntax.layout[.expression]: return "value" - case \LabeledSpecializeArgumentSyntax.label: + case LabeledSpecializeArgumentSyntax.layout[.label]: return "label" - case \LabeledSpecializeArgumentSyntax.value: + case LabeledSpecializeArgumentSyntax.layout[.value]: return "value" - case \LabeledStmtSyntax.label: + case LabeledStmtSyntax.layout[.label]: return "label name" - case \LayoutRequirementSyntax.type: + case LayoutRequirementSyntax.layout[.type]: return "constrained type" - case \LayoutRequirementSyntax.size: + case LayoutRequirementSyntax.layout[.size]: return "size" - case \LayoutRequirementSyntax.alignment: + case LayoutRequirementSyntax.layout[.alignment]: return "alignment" - case \LifetimeSpecifierArgumentSyntax.parameter: + case LifetimeSpecifierArgumentSyntax.layout[.parameter]: return "parameter reference" - case \MacroDeclSyntax.attributes: + case MacroDeclSyntax.layout[.attributes]: return "attributes" - case \MacroDeclSyntax.modifiers: + case MacroDeclSyntax.layout[.modifiers]: return "modifiers" - case \MacroDeclSyntax.genericParameterClause: + case MacroDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \MacroDeclSyntax.signature: + case MacroDeclSyntax.layout[.signature]: return "macro signature" - case \MacroDeclSyntax.definition: + case MacroDeclSyntax.layout[.definition]: return "macro definition" - case \MacroDeclSyntax.genericWhereClause: + case MacroDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \MacroExpansionDeclSyntax.attributes: + case MacroExpansionDeclSyntax.layout[.attributes]: return "attributes" - case \MacroExpansionDeclSyntax.modifiers: + case MacroExpansionDeclSyntax.layout[.modifiers]: return "modifiers" - case \MemberAccessExprSyntax.base: + case MemberAccessExprSyntax.layout[.base]: return "base" - case \MemberAccessExprSyntax.declName: + case MemberAccessExprSyntax.layout[.declName]: return "name" - case \MemberTypeSyntax.baseType: + case MemberTypeSyntax.layout[.baseType]: return "base type" - case \MemberTypeSyntax.name: + case MemberTypeSyntax.layout[.name]: return "name" - case \MetatypeTypeSyntax.baseType: + case MetatypeTypeSyntax.layout[.baseType]: return "base type" - case \MultipleTrailingClosureElementSyntax.label: + case MultipleTrailingClosureElementSyntax.layout[.label]: return "label" - case \ObjCSelectorPieceSyntax.name: + case ObjCSelectorPieceSyntax.layout[.name]: return "name" - case \OperatorDeclSyntax.fixitySpecifier: + case OperatorDeclSyntax.layout[.fixitySpecifier]: return "fixity" - case \OperatorPrecedenceAndTypesSyntax.precedenceGroup: + case OperatorPrecedenceAndTypesSyntax.layout[.precedenceGroup]: return "precedence group" - case \PatternBindingSyntax.typeAnnotation: + case PatternBindingSyntax.layout[.typeAnnotation]: return "type annotation" - case \PlatformVersionSyntax.platform: + case PlatformVersionSyntax.layout[.platform]: return "platform" - case \PlatformVersionSyntax.version: + case PlatformVersionSyntax.layout[.version]: return "version" - case \PoundSourceLocationArgumentsSyntax.fileName: + case PoundSourceLocationArgumentsSyntax.layout[.fileName]: return "file name" - case \PoundSourceLocationArgumentsSyntax.lineNumber: + case PoundSourceLocationArgumentsSyntax.layout[.lineNumber]: return "line number" - case \PoundSourceLocationSyntax.arguments: + case PoundSourceLocationSyntax.layout[.arguments]: return "arguments" - case \PrecedenceGroupDeclSyntax.attributes: + case PrecedenceGroupDeclSyntax.layout[.attributes]: return "attributes" - case \PrecedenceGroupDeclSyntax.modifiers: + case PrecedenceGroupDeclSyntax.layout[.modifiers]: return "modifiers" - case \PrecedenceGroupNameSyntax.name: + case PrecedenceGroupNameSyntax.layout[.name]: return "name" - case \PrimaryAssociatedTypeSyntax.name: + case PrimaryAssociatedTypeSyntax.layout[.name]: return "name" - case \ProtocolDeclSyntax.attributes: + case ProtocolDeclSyntax.layout[.attributes]: return "attributes" - case \ProtocolDeclSyntax.modifiers: + case ProtocolDeclSyntax.layout[.modifiers]: return "modifiers" - case \ProtocolDeclSyntax.primaryAssociatedTypeClause: + case ProtocolDeclSyntax.layout[.primaryAssociatedTypeClause]: return "primary associated type clause" - case \ProtocolDeclSyntax.inheritanceClause: + case ProtocolDeclSyntax.layout[.inheritanceClause]: return "inheritance clause" - case \ProtocolDeclSyntax.genericWhereClause: + case ProtocolDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \RepeatStmtSyntax.body: + case RepeatStmtSyntax.layout[.body]: return "body" - case \RepeatStmtSyntax.condition: + case RepeatStmtSyntax.layout[.condition]: return "condition" - case \ReturnClauseSyntax.type: + case ReturnClauseSyntax.layout[.type]: return "return type" - case \SameTypeRequirementSyntax.leftType: + case SameTypeRequirementSyntax.layout[.leftType]: return "left-hand type" - case \SameTypeRequirementSyntax.rightType: + case SameTypeRequirementSyntax.layout[.rightType]: return "right-hand type" - case \SpecializeAvailabilityArgumentSyntax.availabilityLabel: + case SpecializeAvailabilityArgumentSyntax.layout[.availabilityLabel]: return "label" - case \SpecializeTargetFunctionArgumentSyntax.targetLabel: + case SpecializeTargetFunctionArgumentSyntax.layout[.targetLabel]: return "label" - case \SpecializeTargetFunctionArgumentSyntax.declName: + case SpecializeTargetFunctionArgumentSyntax.layout[.declName]: return "declaration name" - case \StructDeclSyntax.attributes: + case StructDeclSyntax.layout[.attributes]: return "attributes" - case \StructDeclSyntax.modifiers: + case StructDeclSyntax.layout[.modifiers]: return "modifiers" - case \StructDeclSyntax.genericParameterClause: + case StructDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \StructDeclSyntax.inheritanceClause: + case StructDeclSyntax.layout[.inheritanceClause]: return "inheritance clause" - case \StructDeclSyntax.genericWhereClause: + case StructDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \SubscriptCallExprSyntax.calledExpression: + case SubscriptCallExprSyntax.layout[.calledExpression]: return "called expression" - case \SubscriptCallExprSyntax.arguments: + case SubscriptCallExprSyntax.layout[.arguments]: return "arguments" - case \SubscriptCallExprSyntax.trailingClosure: + case SubscriptCallExprSyntax.layout[.trailingClosure]: return "trailing closure" - case \SubscriptCallExprSyntax.additionalTrailingClosures: + case SubscriptCallExprSyntax.layout[.additionalTrailingClosures]: return "trailing closures" - case \SubscriptDeclSyntax.attributes: + case SubscriptDeclSyntax.layout[.attributes]: return "attributes" - case \SubscriptDeclSyntax.modifiers: + case SubscriptDeclSyntax.layout[.modifiers]: return "modifiers" - case \SubscriptDeclSyntax.genericParameterClause: + case SubscriptDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \SubscriptDeclSyntax.genericWhereClause: + case SubscriptDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \SwitchCaseSyntax.label: + case SwitchCaseSyntax.layout[.label]: return "label" - case \TernaryExprSyntax.condition: + case TernaryExprSyntax.layout[.condition]: return "condition" - case \TernaryExprSyntax.thenExpression: + case TernaryExprSyntax.layout[.thenExpression]: return "first choice" - case \TernaryExprSyntax.elseExpression: + case TernaryExprSyntax.layout[.elseExpression]: return "second choice" - case \ThrowsClauseSyntax.type: + case ThrowsClauseSyntax.layout[.type]: return "thrown type" - case \TuplePatternElementSyntax.label: + case TuplePatternElementSyntax.layout[.label]: return "label" - case \TupleTypeElementSyntax.firstName: + case TupleTypeElementSyntax.layout[.firstName]: return "name" - case \TupleTypeElementSyntax.secondName: + case TupleTypeElementSyntax.layout[.secondName]: return "internal name" - case \TypeAliasDeclSyntax.attributes: + case TypeAliasDeclSyntax.layout[.attributes]: return "attributes" - case \TypeAliasDeclSyntax.modifiers: + case TypeAliasDeclSyntax.layout[.modifiers]: return "modifiers" - case \TypeAliasDeclSyntax.genericParameterClause: + case TypeAliasDeclSyntax.layout[.genericParameterClause]: return "generic parameter clause" - case \TypeAliasDeclSyntax.genericWhereClause: + case TypeAliasDeclSyntax.layout[.genericWhereClause]: return "generic where clause" - case \TypeInitializerClauseSyntax.value: + case TypeInitializerClauseSyntax.layout[.value]: return "type" - case \VariableDeclSyntax.attributes: + case VariableDeclSyntax.layout[.attributes]: return "attributes" - case \VariableDeclSyntax.modifiers: + case VariableDeclSyntax.layout[.modifiers]: return "modifiers" default: return nil @@ -369,9 +369,9 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { extension SyntaxProtocol { var childNameInParent: String? { - guard let keyPath = self.keyPathInParent else { + guard let property = self.propertyInParent else { return nil } - return childNameForDiagnostics(keyPath) + return childNameForDiagnostics(property) } } diff --git a/Sources/SwiftSyntax/CMakeLists.txt b/Sources/SwiftSyntax/CMakeLists.txt index 8001de25c4e..e874d2a05f2 100644 --- a/Sources/SwiftSyntax/CMakeLists.txt +++ b/Sources/SwiftSyntax/CMakeLists.txt @@ -30,6 +30,7 @@ add_swift_syntax_library(SwiftSyntax SyntaxCollection.swift SyntaxHashable.swift SyntaxIdentifier.swift + SyntaxLayout.swift SyntaxNodeStructure.swift SyntaxProtocol.swift SyntaxText.swift @@ -56,7 +57,7 @@ add_swift_syntax_library(SwiftSyntax generated/raw/RawSyntaxNodesTUVWXYZ.swift generated/raw/RawSyntaxValidation.swift - generated/ChildNameForKeyPath.swift + generated/ConcreteSyntaxProperty.swift generated/Keyword.swift generated/RenamedChildrenCompatibility.swift generated/RenamedNodesCompatibility.swift @@ -65,6 +66,7 @@ add_swift_syntax_library(SwiftSyntax generated/SyntaxCollections.swift generated/SyntaxEnum.swift generated/SyntaxKind.swift + generated/SyntaxLayoutPropertyName.swift generated/SyntaxRewriter.swift generated/SyntaxTraits.swift generated/SyntaxVisitor.swift diff --git a/Sources/SwiftSyntax/SyntaxCollection.swift b/Sources/SwiftSyntax/SyntaxCollection.swift index a6af1f39597..d28390b2dcc 100644 --- a/Sources/SwiftSyntax/SyntaxCollection.swift +++ b/Sources/SwiftSyntax/SyntaxCollection.swift @@ -10,12 +10,10 @@ // //===----------------------------------------------------------------------===// -public protocol SyntaxCollection: SyntaxProtocol, BidirectionalCollection, ExpressibleByArrayLiteral +public protocol SyntaxCollection: SyntaxProtocol, _LeafSyntaxNodeProtocol, BidirectionalCollection, + ExpressibleByArrayLiteral where Element: SyntaxProtocol, Index == SyntaxChildrenIndex { associatedtype Iterator = SyntaxCollectionIterator - - /// The ``SyntaxKind`` of the syntax node that conforms to ``SyntaxCollection``. - static var syntaxKind: SyntaxKind { get } } extension SyntaxCollection { diff --git a/Sources/SwiftSyntax/SyntaxLayout.swift b/Sources/SwiftSyntax/SyntaxLayout.swift new file mode 100644 index 00000000000..1cec952cfc4 --- /dev/null +++ b/Sources/SwiftSyntax/SyntaxLayout.swift @@ -0,0 +1,158 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2024 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +/// Protocol for concrete layout syntax nodes. +public protocol _LayoutSyntaxNodeProtocol: _LeafSyntaxNodeProtocol {} + +extension _LayoutSyntaxNodeProtocol { + /// A type metadata describing the layout of the this syntax type. + public static var layout: SyntaxLayout.Type { + SyntaxLayout.self + } +} + +/// Represent an index in a layout. +public struct SyntaxLayoutIndex: Equatable, Comparable { + let value: Int + + @_spi(RawSyntax) + public init(_ value: Int) { + self.value = value + } + + public static func == (lhs: Self, rhs: Self) -> Bool { + lhs.value == rhs.value + } + + public static func < (lhs: Self, rhs: Self) -> Bool { + lhs.value < rhs.value + } +} + +/// Represent a property in a layout syntax. +public struct SyntaxLayoutProperty: Equatable { + /// 'SyntaxKind' of the parent layout node. + let syntaxKind: SyntaxKind + /// Index in the parent node layout. + let index: SyntaxLayoutIndex + + @_spi(RawSyntax) + public init(syntaxKind: SyntaxKind, index: SyntaxLayoutIndex) { + self.syntaxKind = syntaxKind + self.index = index + } + + public static func == (lhs: Self, rhs: Self) -> Bool { + lhs.syntaxKind == rhs.syntaxKind && lhs.index == rhs.index + } +} + +/// A type describing the layout of a `_LayoutSyntaxProtocol` syntax node. +public struct SyntaxLayout { + // 'SyntaxLayout' is a metadata only type (at this point) + private init() { fatalError() } +} + +/// Represent a typed property in a layout syntax. +/// +/// Specialized types have static properties to instantiate this type. E.g.: +/// +/// let exprProperty: ConcreteSyntaxProperty = .expression +/// +/// The property can be used similar to 'KeyPath'. +/// +/// let expr/*: ExprSyntax?*/ = returnStmt[property: exprProperty] +/// let newReturnStmt = returnStmt.with(.expression, expr) +/// +public struct ConcreteSyntaxProperty { + let index: SyntaxLayoutIndex + + // ConcreteSyntaxProperty can only be constructed by `ConcreteSyntaxProperty.${name}` + private init() { fatalError() } +} + +extension SyntaxLayout { + /// Get ``SyntaxLayoutProperty`` from ``ConcreteSyntaxProperty`` of the `Base` type. + /// This is convenient for comparing with '.propertyInParent'. E.g. + /// + /// // Check if 'node' is a 'FunctionDeclSyntax.name'. + /// if node.propertyInParent == FunctionDeclSyntax.layout[.name] { ... } + /// + public static subscript(property: ConcreteSyntaxProperty) -> SyntaxLayoutProperty { + return SyntaxLayoutProperty(syntaxKind: Base.syntaxKind, index: property.index) + } +} + +extension Syntax { + /// Implementation of `SyntaxProtocol.propertyInParent` + var propertyInParent: SyntaxLayoutProperty? { + guard let parentKind = data.parent?.pointee.raw.kind, parentKind.isLayout else { + return nil + } + return SyntaxLayoutProperty( + syntaxKind: parentKind, + index: SyntaxLayoutIndex(Int(absoluteInfo.layoutIndexInParent)) + ) + } +} + +extension SyntaxProtocol { + /// Return 'SyntaxLayoutProperty' in the parent node, if this node is a child + /// of a layout node. 'nil' otherwise. + @inline(__always) + public var propertyInParent: SyntaxLayoutProperty? { + self._syntaxNode.propertyInParent + } + + /// Get a property value. + /// The property must be retrieved from the correct 'SyntaxLayout' + public subscript(property: SyntaxLayoutProperty) -> Syntax? { + precondition(property.syntaxKind == self.kind) + return self._syntaxNode.child(at: Int(property.index.value)) + } +} + +extension _LayoutSyntaxNodeProtocol { + /// A property value. + public subscript(property: ConcreteSyntaxProperty) -> T { + get { + self._syntaxNode.child(at: Int(property.index.value))!.cast(T.self) + } + set { + self = self.with(property, newValue) + } + } + + /// A property value. + public subscript(property: ConcreteSyntaxProperty) -> T? { + get { + self._syntaxNode.child(at: Int(property.index.value))?.cast(T.self) + } + set { + self = self.with(property, newValue) + } + } + + /// Returns a new syntax node that has the `property` replaced by `value`. + public func with(_ property: ConcreteSyntaxProperty, _ value: T) -> Self { + self._syntaxNode + .replacingChild(at: Int(property.index.value), with: Syntax(value), arena: SyntaxArena()) + .cast(Self.self) + } + + /// Returns a new syntax node that has the `property` replaced by `value`. + public func with(_ property: ConcreteSyntaxProperty, _ value: T?) -> Self { + self._syntaxNode + .replacingChild(at: Int(property.index.value), with: Syntax(value), arena: SyntaxArena()) + .cast(Self.self) + } +} diff --git a/Sources/SwiftSyntax/SyntaxProtocol.swift b/Sources/SwiftSyntax/SyntaxProtocol.swift index a870594f8a7..947089eba11 100644 --- a/Sources/SwiftSyntax/SyntaxProtocol.swift +++ b/Sources/SwiftSyntax/SyntaxProtocol.swift @@ -688,7 +688,7 @@ extension SyntaxProtocol { target.write("\n") target.write(indentString) target.write(isLastChild ? "╰─" : "├─") - if let keyPath = child.keyPathInParent, let name = childName(keyPath) { + if let property = child.propertyInParent, let name = property.name { target.write("\(name): ") } else if self.kind.isSyntaxCollection { target.write("[\(num)]: ") @@ -743,3 +743,10 @@ extension SyntaxChildChoices { return self.as(S.self)! } } + +/// Protocol that syntax nodes conform to if they don't have any semantic subtypes. +/// These are syntax nodes that are not considered base nodes for other syntax types. +public protocol _LeafSyntaxNodeProtocol: SyntaxProtocol { + /// The ``SyntaxKind`` of the syntax node. + static var syntaxKind: SyntaxKind { get } +} diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift deleted file mode 100644 index 566b0142125..00000000000 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ /dev/null @@ -1,3515 +0,0 @@ -//// Automatically generated by generate-swift-syntax -//// Do not edit directly! -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -/// If the keyPath is one from a layout structure, return the property name -/// of it. -@_spi(RawSyntax) -public func childName(_ keyPath: AnyKeyPath) -> String? { - switch keyPath { - case \ABIAttributeArgumentsSyntax.unexpectedBeforeProvider: - return "unexpectedBeforeProvider" - case \ABIAttributeArgumentsSyntax.provider: - return "provider" - case \ABIAttributeArgumentsSyntax.unexpectedAfterProvider: - return "unexpectedAfterProvider" - case \AccessorBlockSyntax.unexpectedBeforeLeftBrace: - return "unexpectedBeforeLeftBrace" - case \AccessorBlockSyntax.leftBrace: - return "leftBrace" - case \AccessorBlockSyntax.unexpectedBetweenLeftBraceAndAccessors: - return "unexpectedBetweenLeftBraceAndAccessors" - case \AccessorBlockSyntax.accessors: - return "accessors" - case \AccessorBlockSyntax.unexpectedBetweenAccessorsAndRightBrace: - return "unexpectedBetweenAccessorsAndRightBrace" - case \AccessorBlockSyntax.rightBrace: - return "rightBrace" - case \AccessorBlockSyntax.unexpectedAfterRightBrace: - return "unexpectedAfterRightBrace" - case \AccessorDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \AccessorDeclSyntax.attributes: - return "attributes" - case \AccessorDeclSyntax.unexpectedBetweenAttributesAndModifier: - return "unexpectedBetweenAttributesAndModifier" - case \AccessorDeclSyntax.modifier: - return "modifier" - case \AccessorDeclSyntax.unexpectedBetweenModifierAndAccessorSpecifier: - return "unexpectedBetweenModifierAndAccessorSpecifier" - case \AccessorDeclSyntax.accessorSpecifier: - return "accessorSpecifier" - case \AccessorDeclSyntax.unexpectedBetweenAccessorSpecifierAndParameters: - return "unexpectedBetweenAccessorSpecifierAndParameters" - case \AccessorDeclSyntax.parameters: - return "parameters" - case \AccessorDeclSyntax.unexpectedBetweenParametersAndEffectSpecifiers: - return "unexpectedBetweenParametersAndEffectSpecifiers" - case \AccessorDeclSyntax.effectSpecifiers: - return "effectSpecifiers" - case \AccessorDeclSyntax.unexpectedBetweenEffectSpecifiersAndBody: - return "unexpectedBetweenEffectSpecifiersAndBody" - case \AccessorDeclSyntax.body: - return "body" - case \AccessorDeclSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \AccessorEffectSpecifiersSyntax.unexpectedBeforeAsyncSpecifier: - return "unexpectedBeforeAsyncSpecifier" - case \AccessorEffectSpecifiersSyntax.asyncSpecifier: - return "asyncSpecifier" - case \AccessorEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsClause: - return "unexpectedBetweenAsyncSpecifierAndThrowsClause" - case \AccessorEffectSpecifiersSyntax.throwsClause: - return "throwsClause" - case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrowsClause: - return "unexpectedAfterThrowsClause" - case \AccessorParametersSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \AccessorParametersSyntax.leftParen: - return "leftParen" - case \AccessorParametersSyntax.unexpectedBetweenLeftParenAndName: - return "unexpectedBetweenLeftParenAndName" - case \AccessorParametersSyntax.name: - return "name" - case \AccessorParametersSyntax.unexpectedBetweenNameAndRightParen: - return "unexpectedBetweenNameAndRightParen" - case \AccessorParametersSyntax.rightParen: - return "rightParen" - case \AccessorParametersSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \ActorDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \ActorDeclSyntax.attributes: - return "attributes" - case \ActorDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \ActorDeclSyntax.modifiers: - return "modifiers" - case \ActorDeclSyntax.unexpectedBetweenModifiersAndActorKeyword: - return "unexpectedBetweenModifiersAndActorKeyword" - case \ActorDeclSyntax.actorKeyword: - return "actorKeyword" - case \ActorDeclSyntax.unexpectedBetweenActorKeywordAndName: - return "unexpectedBetweenActorKeywordAndName" - case \ActorDeclSyntax.name: - return "name" - case \ActorDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: - return "unexpectedBetweenNameAndGenericParameterClause" - case \ActorDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \ActorDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: - return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \ActorDeclSyntax.inheritanceClause: - return "inheritanceClause" - case \ActorDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: - return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ActorDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \ActorDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" - case \ActorDeclSyntax.memberBlock: - return "memberBlock" - case \ActorDeclSyntax.unexpectedAfterMemberBlock: - return "unexpectedAfterMemberBlock" - case \ArrayElementSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \ArrayElementSyntax.expression: - return "expression" - case \ArrayElementSyntax.unexpectedBetweenExpressionAndTrailingComma: - return "unexpectedBetweenExpressionAndTrailingComma" - case \ArrayElementSyntax.trailingComma: - return "trailingComma" - case \ArrayElementSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \ArrayExprSyntax.unexpectedBeforeLeftSquare: - return "unexpectedBeforeLeftSquare" - case \ArrayExprSyntax.leftSquare: - return "leftSquare" - case \ArrayExprSyntax.unexpectedBetweenLeftSquareAndElements: - return "unexpectedBetweenLeftSquareAndElements" - case \ArrayExprSyntax.elements: - return "elements" - case \ArrayExprSyntax.unexpectedBetweenElementsAndRightSquare: - return "unexpectedBetweenElementsAndRightSquare" - case \ArrayExprSyntax.rightSquare: - return "rightSquare" - case \ArrayExprSyntax.unexpectedAfterRightSquare: - return "unexpectedAfterRightSquare" - case \ArrayTypeSyntax.unexpectedBeforeLeftSquare: - return "unexpectedBeforeLeftSquare" - case \ArrayTypeSyntax.leftSquare: - return "leftSquare" - case \ArrayTypeSyntax.unexpectedBetweenLeftSquareAndElement: - return "unexpectedBetweenLeftSquareAndElement" - case \ArrayTypeSyntax.element: - return "element" - case \ArrayTypeSyntax.unexpectedBetweenElementAndRightSquare: - return "unexpectedBetweenElementAndRightSquare" - case \ArrayTypeSyntax.rightSquare: - return "rightSquare" - case \ArrayTypeSyntax.unexpectedAfterRightSquare: - return "unexpectedAfterRightSquare" - case \ArrowExprSyntax.unexpectedBeforeEffectSpecifiers: - return "unexpectedBeforeEffectSpecifiers" - case \ArrowExprSyntax.effectSpecifiers: - return "effectSpecifiers" - case \ArrowExprSyntax.unexpectedBetweenEffectSpecifiersAndArrow: - return "unexpectedBetweenEffectSpecifiersAndArrow" - case \ArrowExprSyntax.arrow: - return "arrow" - case \ArrowExprSyntax.unexpectedAfterArrow: - return "unexpectedAfterArrow" - case \AsExprSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \AsExprSyntax.expression: - return "expression" - case \AsExprSyntax.unexpectedBetweenExpressionAndAsKeyword: - return "unexpectedBetweenExpressionAndAsKeyword" - case \AsExprSyntax.asKeyword: - return "asKeyword" - case \AsExprSyntax.unexpectedBetweenAsKeywordAndQuestionOrExclamationMark: - return "unexpectedBetweenAsKeywordAndQuestionOrExclamationMark" - case \AsExprSyntax.questionOrExclamationMark: - return "questionOrExclamationMark" - case \AsExprSyntax.unexpectedBetweenQuestionOrExclamationMarkAndType: - return "unexpectedBetweenQuestionOrExclamationMarkAndType" - case \AsExprSyntax.type: - return "type" - case \AsExprSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \AssignmentExprSyntax.unexpectedBeforeEqual: - return "unexpectedBeforeEqual" - case \AssignmentExprSyntax.equal: - return "equal" - case \AssignmentExprSyntax.unexpectedAfterEqual: - return "unexpectedAfterEqual" - case \AssociatedTypeDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \AssociatedTypeDeclSyntax.attributes: - return "attributes" - case \AssociatedTypeDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \AssociatedTypeDeclSyntax.modifiers: - return "modifiers" - case \AssociatedTypeDeclSyntax.unexpectedBetweenModifiersAndAssociatedtypeKeyword: - return "unexpectedBetweenModifiersAndAssociatedtypeKeyword" - case \AssociatedTypeDeclSyntax.associatedtypeKeyword: - return "associatedtypeKeyword" - case \AssociatedTypeDeclSyntax.unexpectedBetweenAssociatedtypeKeywordAndName: - return "unexpectedBetweenAssociatedtypeKeywordAndName" - case \AssociatedTypeDeclSyntax.name: - return "name" - case \AssociatedTypeDeclSyntax.unexpectedBetweenNameAndInheritanceClause: - return "unexpectedBetweenNameAndInheritanceClause" - case \AssociatedTypeDeclSyntax.inheritanceClause: - return "inheritanceClause" - case \AssociatedTypeDeclSyntax.unexpectedBetweenInheritanceClauseAndInitializer: - return "unexpectedBetweenInheritanceClauseAndInitializer" - case \AssociatedTypeDeclSyntax.initializer: - return "initializer" - case \AssociatedTypeDeclSyntax.unexpectedBetweenInitializerAndGenericWhereClause: - return "unexpectedBetweenInitializerAndGenericWhereClause" - case \AssociatedTypeDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \AssociatedTypeDeclSyntax.unexpectedAfterGenericWhereClause: - return "unexpectedAfterGenericWhereClause" - case \AttributeSyntax.unexpectedBeforeAtSign: - return "unexpectedBeforeAtSign" - case \AttributeSyntax.atSign: - return "atSign" - case \AttributeSyntax.unexpectedBetweenAtSignAndAttributeName: - return "unexpectedBetweenAtSignAndAttributeName" - case \AttributeSyntax.attributeName: - return "attributeName" - case \AttributeSyntax.unexpectedBetweenAttributeNameAndLeftParen: - return "unexpectedBetweenAttributeNameAndLeftParen" - case \AttributeSyntax.leftParen: - return "leftParen" - case \AttributeSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" - case \AttributeSyntax.arguments: - return "arguments" - case \AttributeSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \AttributeSyntax.rightParen: - return "rightParen" - case \AttributeSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \AttributedTypeSyntax.unexpectedBeforeSpecifiers: - return "unexpectedBeforeSpecifiers" - case \AttributedTypeSyntax.specifiers: - return "specifiers" - case \AttributedTypeSyntax.unexpectedBetweenSpecifiersAndAttributes: - return "unexpectedBetweenSpecifiersAndAttributes" - case \AttributedTypeSyntax.attributes: - return "attributes" - case \AttributedTypeSyntax.unexpectedBetweenAttributesAndBaseType: - return "unexpectedBetweenAttributesAndBaseType" - case \AttributedTypeSyntax.baseType: - return "baseType" - case \AttributedTypeSyntax.unexpectedAfterBaseType: - return "unexpectedAfterBaseType" - case \AvailabilityArgumentSyntax.unexpectedBeforeArgument: - return "unexpectedBeforeArgument" - case \AvailabilityArgumentSyntax.argument: - return "argument" - case \AvailabilityArgumentSyntax.unexpectedBetweenArgumentAndTrailingComma: - return "unexpectedBetweenArgumentAndTrailingComma" - case \AvailabilityArgumentSyntax.trailingComma: - return "trailingComma" - case \AvailabilityArgumentSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \AvailabilityConditionSyntax.unexpectedBeforeAvailabilityKeyword: - return "unexpectedBeforeAvailabilityKeyword" - case \AvailabilityConditionSyntax.availabilityKeyword: - return "availabilityKeyword" - case \AvailabilityConditionSyntax.unexpectedBetweenAvailabilityKeywordAndLeftParen: - return "unexpectedBetweenAvailabilityKeywordAndLeftParen" - case \AvailabilityConditionSyntax.leftParen: - return "leftParen" - case \AvailabilityConditionSyntax.unexpectedBetweenLeftParenAndAvailabilityArguments: - return "unexpectedBetweenLeftParenAndAvailabilityArguments" - case \AvailabilityConditionSyntax.availabilityArguments: - return "availabilityArguments" - case \AvailabilityConditionSyntax.unexpectedBetweenAvailabilityArgumentsAndRightParen: - return "unexpectedBetweenAvailabilityArgumentsAndRightParen" - case \AvailabilityConditionSyntax.rightParen: - return "rightParen" - case \AvailabilityConditionSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \AvailabilityLabeledArgumentSyntax.unexpectedBeforeLabel: - return "unexpectedBeforeLabel" - case \AvailabilityLabeledArgumentSyntax.label: - return "label" - case \AvailabilityLabeledArgumentSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \AvailabilityLabeledArgumentSyntax.colon: - return "colon" - case \AvailabilityLabeledArgumentSyntax.unexpectedBetweenColonAndValue: - return "unexpectedBetweenColonAndValue" - case \AvailabilityLabeledArgumentSyntax.value: - return "value" - case \AvailabilityLabeledArgumentSyntax.unexpectedAfterValue: - return "unexpectedAfterValue" - case \AwaitExprSyntax.unexpectedBeforeAwaitKeyword: - return "unexpectedBeforeAwaitKeyword" - case \AwaitExprSyntax.awaitKeyword: - return "awaitKeyword" - case \AwaitExprSyntax.unexpectedBetweenAwaitKeywordAndExpression: - return "unexpectedBetweenAwaitKeywordAndExpression" - case \AwaitExprSyntax.expression: - return "expression" - case \AwaitExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \BackDeployedAttributeArgumentsSyntax.unexpectedBeforeBeforeLabel: - return "unexpectedBeforeBeforeLabel" - case \BackDeployedAttributeArgumentsSyntax.beforeLabel: - return "beforeLabel" - case \BackDeployedAttributeArgumentsSyntax.unexpectedBetweenBeforeLabelAndColon: - return "unexpectedBetweenBeforeLabelAndColon" - case \BackDeployedAttributeArgumentsSyntax.colon: - return "colon" - case \BackDeployedAttributeArgumentsSyntax.unexpectedBetweenColonAndPlatforms: - return "unexpectedBetweenColonAndPlatforms" - case \BackDeployedAttributeArgumentsSyntax.platforms: - return "platforms" - case \BackDeployedAttributeArgumentsSyntax.unexpectedAfterPlatforms: - return "unexpectedAfterPlatforms" - case \BinaryOperatorExprSyntax.unexpectedBeforeOperator: - return "unexpectedBeforeOperator" - case \BinaryOperatorExprSyntax.operator: - return "operator" - case \BinaryOperatorExprSyntax.unexpectedAfterOperator: - return "unexpectedAfterOperator" - case \BooleanLiteralExprSyntax.unexpectedBeforeLiteral: - return "unexpectedBeforeLiteral" - case \BooleanLiteralExprSyntax.literal: - return "literal" - case \BooleanLiteralExprSyntax.unexpectedAfterLiteral: - return "unexpectedAfterLiteral" - case \BorrowExprSyntax.unexpectedBeforeBorrowKeyword: - return "unexpectedBeforeBorrowKeyword" - case \BorrowExprSyntax.borrowKeyword: - return "borrowKeyword" - case \BorrowExprSyntax.unexpectedBetweenBorrowKeywordAndExpression: - return "unexpectedBetweenBorrowKeywordAndExpression" - case \BorrowExprSyntax.expression: - return "expression" - case \BorrowExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \BreakStmtSyntax.unexpectedBeforeBreakKeyword: - return "unexpectedBeforeBreakKeyword" - case \BreakStmtSyntax.breakKeyword: - return "breakKeyword" - case \BreakStmtSyntax.unexpectedBetweenBreakKeywordAndLabel: - return "unexpectedBetweenBreakKeywordAndLabel" - case \BreakStmtSyntax.label: - return "label" - case \BreakStmtSyntax.unexpectedAfterLabel: - return "unexpectedAfterLabel" - case \_CanImportExprSyntax.unexpectedBeforeCanImportKeyword: - return "unexpectedBeforeCanImportKeyword" - case \_CanImportExprSyntax.canImportKeyword: - return "canImportKeyword" - case \_CanImportExprSyntax.unexpectedBetweenCanImportKeywordAndLeftParen: - return "unexpectedBetweenCanImportKeywordAndLeftParen" - case \_CanImportExprSyntax.leftParen: - return "leftParen" - case \_CanImportExprSyntax.unexpectedBetweenLeftParenAndImportPath: - return "unexpectedBetweenLeftParenAndImportPath" - case \_CanImportExprSyntax.importPath: - return "importPath" - case \_CanImportExprSyntax.unexpectedBetweenImportPathAndVersionInfo: - return "unexpectedBetweenImportPathAndVersionInfo" - case \_CanImportExprSyntax.versionInfo: - return "versionInfo" - case \_CanImportExprSyntax.unexpectedBetweenVersionInfoAndRightParen: - return "unexpectedBetweenVersionInfoAndRightParen" - case \_CanImportExprSyntax.rightParen: - return "rightParen" - case \_CanImportExprSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \_CanImportVersionInfoSyntax.unexpectedBeforeComma: - return "unexpectedBeforeComma" - case \_CanImportVersionInfoSyntax.comma: - return "comma" - case \_CanImportVersionInfoSyntax.unexpectedBetweenCommaAndLabel: - return "unexpectedBetweenCommaAndLabel" - case \_CanImportVersionInfoSyntax.label: - return "label" - case \_CanImportVersionInfoSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \_CanImportVersionInfoSyntax.colon: - return "colon" - case \_CanImportVersionInfoSyntax.unexpectedBetweenColonAndVersion: - return "unexpectedBetweenColonAndVersion" - case \_CanImportVersionInfoSyntax.version: - return "version" - case \_CanImportVersionInfoSyntax.unexpectedAfterVersion: - return "unexpectedAfterVersion" - case \CatchClauseSyntax.unexpectedBeforeCatchKeyword: - return "unexpectedBeforeCatchKeyword" - case \CatchClauseSyntax.catchKeyword: - return "catchKeyword" - case \CatchClauseSyntax.unexpectedBetweenCatchKeywordAndCatchItems: - return "unexpectedBetweenCatchKeywordAndCatchItems" - case \CatchClauseSyntax.catchItems: - return "catchItems" - case \CatchClauseSyntax.unexpectedBetweenCatchItemsAndBody: - return "unexpectedBetweenCatchItemsAndBody" - case \CatchClauseSyntax.body: - return "body" - case \CatchClauseSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \CatchItemSyntax.unexpectedBeforePattern: - return "unexpectedBeforePattern" - case \CatchItemSyntax.pattern: - return "pattern" - case \CatchItemSyntax.unexpectedBetweenPatternAndWhereClause: - return "unexpectedBetweenPatternAndWhereClause" - case \CatchItemSyntax.whereClause: - return "whereClause" - case \CatchItemSyntax.unexpectedBetweenWhereClauseAndTrailingComma: - return "unexpectedBetweenWhereClauseAndTrailingComma" - case \CatchItemSyntax.trailingComma: - return "trailingComma" - case \CatchItemSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \ClassDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \ClassDeclSyntax.attributes: - return "attributes" - case \ClassDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \ClassDeclSyntax.modifiers: - return "modifiers" - case \ClassDeclSyntax.unexpectedBetweenModifiersAndClassKeyword: - return "unexpectedBetweenModifiersAndClassKeyword" - case \ClassDeclSyntax.classKeyword: - return "classKeyword" - case \ClassDeclSyntax.unexpectedBetweenClassKeywordAndName: - return "unexpectedBetweenClassKeywordAndName" - case \ClassDeclSyntax.name: - return "name" - case \ClassDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: - return "unexpectedBetweenNameAndGenericParameterClause" - case \ClassDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \ClassDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: - return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \ClassDeclSyntax.inheritanceClause: - return "inheritanceClause" - case \ClassDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: - return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ClassDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \ClassDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" - case \ClassDeclSyntax.memberBlock: - return "memberBlock" - case \ClassDeclSyntax.unexpectedAfterMemberBlock: - return "unexpectedAfterMemberBlock" - case \ClassRestrictionTypeSyntax.unexpectedBeforeClassKeyword: - return "unexpectedBeforeClassKeyword" - case \ClassRestrictionTypeSyntax.classKeyword: - return "classKeyword" - case \ClassRestrictionTypeSyntax.unexpectedAfterClassKeyword: - return "unexpectedAfterClassKeyword" - case \ClosureCaptureClauseSyntax.unexpectedBeforeLeftSquare: - return "unexpectedBeforeLeftSquare" - case \ClosureCaptureClauseSyntax.leftSquare: - return "leftSquare" - case \ClosureCaptureClauseSyntax.unexpectedBetweenLeftSquareAndItems: - return "unexpectedBetweenLeftSquareAndItems" - case \ClosureCaptureClauseSyntax.items: - return "items" - case \ClosureCaptureClauseSyntax.unexpectedBetweenItemsAndRightSquare: - return "unexpectedBetweenItemsAndRightSquare" - case \ClosureCaptureClauseSyntax.rightSquare: - return "rightSquare" - case \ClosureCaptureClauseSyntax.unexpectedAfterRightSquare: - return "unexpectedAfterRightSquare" - case \ClosureCaptureSpecifierSyntax.unexpectedBeforeSpecifier: - return "unexpectedBeforeSpecifier" - case \ClosureCaptureSpecifierSyntax.specifier: - return "specifier" - case \ClosureCaptureSpecifierSyntax.unexpectedBetweenSpecifierAndLeftParen: - return "unexpectedBetweenSpecifierAndLeftParen" - case \ClosureCaptureSpecifierSyntax.leftParen: - return "leftParen" - case \ClosureCaptureSpecifierSyntax.unexpectedBetweenLeftParenAndDetail: - return "unexpectedBetweenLeftParenAndDetail" - case \ClosureCaptureSpecifierSyntax.detail: - return "detail" - case \ClosureCaptureSpecifierSyntax.unexpectedBetweenDetailAndRightParen: - return "unexpectedBetweenDetailAndRightParen" - case \ClosureCaptureSpecifierSyntax.rightParen: - return "rightParen" - case \ClosureCaptureSpecifierSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \ClosureCaptureSyntax.unexpectedBeforeSpecifier: - return "unexpectedBeforeSpecifier" - case \ClosureCaptureSyntax.specifier: - return "specifier" - case \ClosureCaptureSyntax.unexpectedBetweenSpecifierAndName: - return "unexpectedBetweenSpecifierAndName" - case \ClosureCaptureSyntax.name: - return "name" - case \ClosureCaptureSyntax.unexpectedBetweenNameAndInitializer: - return "unexpectedBetweenNameAndInitializer" - case \ClosureCaptureSyntax.initializer: - return "initializer" - case \ClosureCaptureSyntax.unexpectedBetweenInitializerAndTrailingComma: - return "unexpectedBetweenInitializerAndTrailingComma" - case \ClosureCaptureSyntax.trailingComma: - return "trailingComma" - case \ClosureCaptureSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \ClosureExprSyntax.unexpectedBeforeLeftBrace: - return "unexpectedBeforeLeftBrace" - case \ClosureExprSyntax.leftBrace: - return "leftBrace" - case \ClosureExprSyntax.unexpectedBetweenLeftBraceAndSignature: - return "unexpectedBetweenLeftBraceAndSignature" - case \ClosureExprSyntax.signature: - return "signature" - case \ClosureExprSyntax.unexpectedBetweenSignatureAndStatements: - return "unexpectedBetweenSignatureAndStatements" - case \ClosureExprSyntax.statements: - return "statements" - case \ClosureExprSyntax.unexpectedBetweenStatementsAndRightBrace: - return "unexpectedBetweenStatementsAndRightBrace" - case \ClosureExprSyntax.rightBrace: - return "rightBrace" - case \ClosureExprSyntax.unexpectedAfterRightBrace: - return "unexpectedAfterRightBrace" - case \ClosureParameterClauseSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \ClosureParameterClauseSyntax.leftParen: - return "leftParen" - case \ClosureParameterClauseSyntax.unexpectedBetweenLeftParenAndParameters: - return "unexpectedBetweenLeftParenAndParameters" - case \ClosureParameterClauseSyntax.parameters: - return "parameters" - case \ClosureParameterClauseSyntax.unexpectedBetweenParametersAndRightParen: - return "unexpectedBetweenParametersAndRightParen" - case \ClosureParameterClauseSyntax.rightParen: - return "rightParen" - case \ClosureParameterClauseSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \ClosureParameterSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \ClosureParameterSyntax.attributes: - return "attributes" - case \ClosureParameterSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \ClosureParameterSyntax.modifiers: - return "modifiers" - case \ClosureParameterSyntax.unexpectedBetweenModifiersAndFirstName: - return "unexpectedBetweenModifiersAndFirstName" - case \ClosureParameterSyntax.firstName: - return "firstName" - case \ClosureParameterSyntax.unexpectedBetweenFirstNameAndSecondName: - return "unexpectedBetweenFirstNameAndSecondName" - case \ClosureParameterSyntax.secondName: - return "secondName" - case \ClosureParameterSyntax.unexpectedBetweenSecondNameAndColon: - return "unexpectedBetweenSecondNameAndColon" - case \ClosureParameterSyntax.colon: - return "colon" - case \ClosureParameterSyntax.unexpectedBetweenColonAndType: - return "unexpectedBetweenColonAndType" - case \ClosureParameterSyntax.type: - return "type" - case \ClosureParameterSyntax.unexpectedBetweenTypeAndEllipsis: - return "unexpectedBetweenTypeAndEllipsis" - case \ClosureParameterSyntax.ellipsis: - return "ellipsis" - case \ClosureParameterSyntax.unexpectedBetweenEllipsisAndTrailingComma: - return "unexpectedBetweenEllipsisAndTrailingComma" - case \ClosureParameterSyntax.trailingComma: - return "trailingComma" - case \ClosureParameterSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \ClosureShorthandParameterSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \ClosureShorthandParameterSyntax.name: - return "name" - case \ClosureShorthandParameterSyntax.unexpectedBetweenNameAndTrailingComma: - return "unexpectedBetweenNameAndTrailingComma" - case \ClosureShorthandParameterSyntax.trailingComma: - return "trailingComma" - case \ClosureShorthandParameterSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \ClosureSignatureSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \ClosureSignatureSyntax.attributes: - return "attributes" - case \ClosureSignatureSyntax.unexpectedBetweenAttributesAndCapture: - return "unexpectedBetweenAttributesAndCapture" - case \ClosureSignatureSyntax.capture: - return "capture" - case \ClosureSignatureSyntax.unexpectedBetweenCaptureAndParameterClause: - return "unexpectedBetweenCaptureAndParameterClause" - case \ClosureSignatureSyntax.parameterClause: - return "parameterClause" - case \ClosureSignatureSyntax.unexpectedBetweenParameterClauseAndEffectSpecifiers: - return "unexpectedBetweenParameterClauseAndEffectSpecifiers" - case \ClosureSignatureSyntax.effectSpecifiers: - return "effectSpecifiers" - case \ClosureSignatureSyntax.unexpectedBetweenEffectSpecifiersAndReturnClause: - return "unexpectedBetweenEffectSpecifiersAndReturnClause" - case \ClosureSignatureSyntax.returnClause: - return "returnClause" - case \ClosureSignatureSyntax.unexpectedBetweenReturnClauseAndInKeyword: - return "unexpectedBetweenReturnClauseAndInKeyword" - case \ClosureSignatureSyntax.inKeyword: - return "inKeyword" - case \ClosureSignatureSyntax.unexpectedAfterInKeyword: - return "unexpectedAfterInKeyword" - case \CodeBlockItemSyntax.unexpectedBeforeItem: - return "unexpectedBeforeItem" - case \CodeBlockItemSyntax.item: - return "item" - case \CodeBlockItemSyntax.unexpectedBetweenItemAndSemicolon: - return "unexpectedBetweenItemAndSemicolon" - case \CodeBlockItemSyntax.semicolon: - return "semicolon" - case \CodeBlockItemSyntax.unexpectedAfterSemicolon: - return "unexpectedAfterSemicolon" - case \CodeBlockSyntax.unexpectedBeforeLeftBrace: - return "unexpectedBeforeLeftBrace" - case \CodeBlockSyntax.leftBrace: - return "leftBrace" - case \CodeBlockSyntax.unexpectedBetweenLeftBraceAndStatements: - return "unexpectedBetweenLeftBraceAndStatements" - case \CodeBlockSyntax.statements: - return "statements" - case \CodeBlockSyntax.unexpectedBetweenStatementsAndRightBrace: - return "unexpectedBetweenStatementsAndRightBrace" - case \CodeBlockSyntax.rightBrace: - return "rightBrace" - case \CodeBlockSyntax.unexpectedAfterRightBrace: - return "unexpectedAfterRightBrace" - case \CompositionTypeElementSyntax.unexpectedBeforeType: - return "unexpectedBeforeType" - case \CompositionTypeElementSyntax.type: - return "type" - case \CompositionTypeElementSyntax.unexpectedBetweenTypeAndAmpersand: - return "unexpectedBetweenTypeAndAmpersand" - case \CompositionTypeElementSyntax.ampersand: - return "ampersand" - case \CompositionTypeElementSyntax.unexpectedAfterAmpersand: - return "unexpectedAfterAmpersand" - case \CompositionTypeSyntax.unexpectedBeforeElements: - return "unexpectedBeforeElements" - case \CompositionTypeSyntax.elements: - return "elements" - case \CompositionTypeSyntax.unexpectedAfterElements: - return "unexpectedAfterElements" - case \ConditionElementSyntax.unexpectedBeforeCondition: - return "unexpectedBeforeCondition" - case \ConditionElementSyntax.condition: - return "condition" - case \ConditionElementSyntax.unexpectedBetweenConditionAndTrailingComma: - return "unexpectedBetweenConditionAndTrailingComma" - case \ConditionElementSyntax.trailingComma: - return "trailingComma" - case \ConditionElementSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \ConformanceRequirementSyntax.unexpectedBeforeLeftType: - return "unexpectedBeforeLeftType" - case \ConformanceRequirementSyntax.leftType: - return "leftType" - case \ConformanceRequirementSyntax.unexpectedBetweenLeftTypeAndColon: - return "unexpectedBetweenLeftTypeAndColon" - case \ConformanceRequirementSyntax.colon: - return "colon" - case \ConformanceRequirementSyntax.unexpectedBetweenColonAndRightType: - return "unexpectedBetweenColonAndRightType" - case \ConformanceRequirementSyntax.rightType: - return "rightType" - case \ConformanceRequirementSyntax.unexpectedAfterRightType: - return "unexpectedAfterRightType" - case \ConsumeExprSyntax.unexpectedBeforeConsumeKeyword: - return "unexpectedBeforeConsumeKeyword" - case \ConsumeExprSyntax.consumeKeyword: - return "consumeKeyword" - case \ConsumeExprSyntax.unexpectedBetweenConsumeKeywordAndExpression: - return "unexpectedBetweenConsumeKeywordAndExpression" - case \ConsumeExprSyntax.expression: - return "expression" - case \ConsumeExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \ContinueStmtSyntax.unexpectedBeforeContinueKeyword: - return "unexpectedBeforeContinueKeyword" - case \ContinueStmtSyntax.continueKeyword: - return "continueKeyword" - case \ContinueStmtSyntax.unexpectedBetweenContinueKeywordAndLabel: - return "unexpectedBetweenContinueKeywordAndLabel" - case \ContinueStmtSyntax.label: - return "label" - case \ContinueStmtSyntax.unexpectedAfterLabel: - return "unexpectedAfterLabel" - case \ConventionAttributeArgumentsSyntax.unexpectedBeforeConventionLabel: - return "unexpectedBeforeConventionLabel" - case \ConventionAttributeArgumentsSyntax.conventionLabel: - return "conventionLabel" - case \ConventionAttributeArgumentsSyntax.unexpectedBetweenConventionLabelAndComma: - return "unexpectedBetweenConventionLabelAndComma" - case \ConventionAttributeArgumentsSyntax.comma: - return "comma" - case \ConventionAttributeArgumentsSyntax.unexpectedBetweenCommaAndCTypeLabel: - return "unexpectedBetweenCommaAndCTypeLabel" - case \ConventionAttributeArgumentsSyntax.cTypeLabel: - return "cTypeLabel" - case \ConventionAttributeArgumentsSyntax.unexpectedBetweenCTypeLabelAndColon: - return "unexpectedBetweenCTypeLabelAndColon" - case \ConventionAttributeArgumentsSyntax.colon: - return "colon" - case \ConventionAttributeArgumentsSyntax.unexpectedBetweenColonAndCTypeString: - return "unexpectedBetweenColonAndCTypeString" - case \ConventionAttributeArgumentsSyntax.cTypeString: - return "cTypeString" - case \ConventionAttributeArgumentsSyntax.unexpectedAfterCTypeString: - return "unexpectedAfterCTypeString" - case \ConventionWitnessMethodAttributeArgumentsSyntax.unexpectedBeforeWitnessMethodLabel: - return "unexpectedBeforeWitnessMethodLabel" - case \ConventionWitnessMethodAttributeArgumentsSyntax.witnessMethodLabel: - return "witnessMethodLabel" - case \ConventionWitnessMethodAttributeArgumentsSyntax.unexpectedBetweenWitnessMethodLabelAndColon: - return "unexpectedBetweenWitnessMethodLabelAndColon" - case \ConventionWitnessMethodAttributeArgumentsSyntax.colon: - return "colon" - case \ConventionWitnessMethodAttributeArgumentsSyntax.unexpectedBetweenColonAndProtocolName: - return "unexpectedBetweenColonAndProtocolName" - case \ConventionWitnessMethodAttributeArgumentsSyntax.protocolName: - return "protocolName" - case \ConventionWitnessMethodAttributeArgumentsSyntax.unexpectedAfterProtocolName: - return "unexpectedAfterProtocolName" - case \CopyExprSyntax.unexpectedBeforeCopyKeyword: - return "unexpectedBeforeCopyKeyword" - case \CopyExprSyntax.copyKeyword: - return "copyKeyword" - case \CopyExprSyntax.unexpectedBetweenCopyKeywordAndExpression: - return "unexpectedBetweenCopyKeywordAndExpression" - case \CopyExprSyntax.expression: - return "expression" - case \CopyExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \DeclModifierDetailSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \DeclModifierDetailSyntax.leftParen: - return "leftParen" - case \DeclModifierDetailSyntax.unexpectedBetweenLeftParenAndDetail: - return "unexpectedBetweenLeftParenAndDetail" - case \DeclModifierDetailSyntax.detail: - return "detail" - case \DeclModifierDetailSyntax.unexpectedBetweenDetailAndRightParen: - return "unexpectedBetweenDetailAndRightParen" - case \DeclModifierDetailSyntax.rightParen: - return "rightParen" - case \DeclModifierDetailSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \DeclModifierSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \DeclModifierSyntax.name: - return "name" - case \DeclModifierSyntax.unexpectedBetweenNameAndDetail: - return "unexpectedBetweenNameAndDetail" - case \DeclModifierSyntax.detail: - return "detail" - case \DeclModifierSyntax.unexpectedAfterDetail: - return "unexpectedAfterDetail" - case \DeclNameArgumentSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \DeclNameArgumentSyntax.name: - return "name" - case \DeclNameArgumentSyntax.unexpectedBetweenNameAndColon: - return "unexpectedBetweenNameAndColon" - case \DeclNameArgumentSyntax.colon: - return "colon" - case \DeclNameArgumentSyntax.unexpectedAfterColon: - return "unexpectedAfterColon" - case \DeclNameArgumentsSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \DeclNameArgumentsSyntax.leftParen: - return "leftParen" - case \DeclNameArgumentsSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" - case \DeclNameArgumentsSyntax.arguments: - return "arguments" - case \DeclNameArgumentsSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \DeclNameArgumentsSyntax.rightParen: - return "rightParen" - case \DeclNameArgumentsSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \DeclReferenceExprSyntax.unexpectedBeforeBaseName: - return "unexpectedBeforeBaseName" - case \DeclReferenceExprSyntax.baseName: - return "baseName" - case \DeclReferenceExprSyntax.unexpectedBetweenBaseNameAndArgumentNames: - return "unexpectedBetweenBaseNameAndArgumentNames" - case \DeclReferenceExprSyntax.argumentNames: - return "argumentNames" - case \DeclReferenceExprSyntax.unexpectedAfterArgumentNames: - return "unexpectedAfterArgumentNames" - case \DeferStmtSyntax.unexpectedBeforeDeferKeyword: - return "unexpectedBeforeDeferKeyword" - case \DeferStmtSyntax.deferKeyword: - return "deferKeyword" - case \DeferStmtSyntax.unexpectedBetweenDeferKeywordAndBody: - return "unexpectedBetweenDeferKeywordAndBody" - case \DeferStmtSyntax.body: - return "body" - case \DeferStmtSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \DeinitializerDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \DeinitializerDeclSyntax.attributes: - return "attributes" - case \DeinitializerDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \DeinitializerDeclSyntax.modifiers: - return "modifiers" - case \DeinitializerDeclSyntax.unexpectedBetweenModifiersAndDeinitKeyword: - return "unexpectedBetweenModifiersAndDeinitKeyword" - case \DeinitializerDeclSyntax.deinitKeyword: - return "deinitKeyword" - case \DeinitializerDeclSyntax.unexpectedBetweenDeinitKeywordAndEffectSpecifiers: - return "unexpectedBetweenDeinitKeywordAndEffectSpecifiers" - case \DeinitializerDeclSyntax.effectSpecifiers: - return "effectSpecifiers" - case \DeinitializerDeclSyntax.unexpectedBetweenEffectSpecifiersAndBody: - return "unexpectedBetweenEffectSpecifiersAndBody" - case \DeinitializerDeclSyntax.body: - return "body" - case \DeinitializerDeclSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \DeinitializerEffectSpecifiersSyntax.unexpectedBeforeAsyncSpecifier: - return "unexpectedBeforeAsyncSpecifier" - case \DeinitializerEffectSpecifiersSyntax.asyncSpecifier: - return "asyncSpecifier" - case \DeinitializerEffectSpecifiersSyntax.unexpectedAfterAsyncSpecifier: - return "unexpectedAfterAsyncSpecifier" - case \DerivativeAttributeArgumentsSyntax.unexpectedBeforeOfLabel: - return "unexpectedBeforeOfLabel" - case \DerivativeAttributeArgumentsSyntax.ofLabel: - return "ofLabel" - case \DerivativeAttributeArgumentsSyntax.unexpectedBetweenOfLabelAndColon: - return "unexpectedBetweenOfLabelAndColon" - case \DerivativeAttributeArgumentsSyntax.colon: - return "colon" - case \DerivativeAttributeArgumentsSyntax.unexpectedBetweenColonAndOriginalDeclName: - return "unexpectedBetweenColonAndOriginalDeclName" - case \DerivativeAttributeArgumentsSyntax.originalDeclName: - return "originalDeclName" - case \DerivativeAttributeArgumentsSyntax.unexpectedBetweenOriginalDeclNameAndPeriod: - return "unexpectedBetweenOriginalDeclNameAndPeriod" - case \DerivativeAttributeArgumentsSyntax.period: - return "period" - case \DerivativeAttributeArgumentsSyntax.unexpectedBetweenPeriodAndAccessorSpecifier: - return "unexpectedBetweenPeriodAndAccessorSpecifier" - case \DerivativeAttributeArgumentsSyntax.accessorSpecifier: - return "accessorSpecifier" - case \DerivativeAttributeArgumentsSyntax.unexpectedBetweenAccessorSpecifierAndComma: - return "unexpectedBetweenAccessorSpecifierAndComma" - case \DerivativeAttributeArgumentsSyntax.comma: - return "comma" - case \DerivativeAttributeArgumentsSyntax.unexpectedBetweenCommaAndArguments: - return "unexpectedBetweenCommaAndArguments" - case \DerivativeAttributeArgumentsSyntax.arguments: - return "arguments" - case \DerivativeAttributeArgumentsSyntax.unexpectedAfterArguments: - return "unexpectedAfterArguments" - case \DesignatedTypeSyntax.unexpectedBeforeLeadingComma: - return "unexpectedBeforeLeadingComma" - case \DesignatedTypeSyntax.leadingComma: - return "leadingComma" - case \DesignatedTypeSyntax.unexpectedBetweenLeadingCommaAndName: - return "unexpectedBetweenLeadingCommaAndName" - case \DesignatedTypeSyntax.name: - return "name" - case \DesignatedTypeSyntax.unexpectedAfterName: - return "unexpectedAfterName" - case \DictionaryElementSyntax.unexpectedBeforeKey: - return "unexpectedBeforeKey" - case \DictionaryElementSyntax.key: - return "key" - case \DictionaryElementSyntax.unexpectedBetweenKeyAndColon: - return "unexpectedBetweenKeyAndColon" - case \DictionaryElementSyntax.colon: - return "colon" - case \DictionaryElementSyntax.unexpectedBetweenColonAndValue: - return "unexpectedBetweenColonAndValue" - case \DictionaryElementSyntax.value: - return "value" - case \DictionaryElementSyntax.unexpectedBetweenValueAndTrailingComma: - return "unexpectedBetweenValueAndTrailingComma" - case \DictionaryElementSyntax.trailingComma: - return "trailingComma" - case \DictionaryElementSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \DictionaryExprSyntax.unexpectedBeforeLeftSquare: - return "unexpectedBeforeLeftSquare" - case \DictionaryExprSyntax.leftSquare: - return "leftSquare" - case \DictionaryExprSyntax.unexpectedBetweenLeftSquareAndContent: - return "unexpectedBetweenLeftSquareAndContent" - case \DictionaryExprSyntax.content: - return "content" - case \DictionaryExprSyntax.unexpectedBetweenContentAndRightSquare: - return "unexpectedBetweenContentAndRightSquare" - case \DictionaryExprSyntax.rightSquare: - return "rightSquare" - case \DictionaryExprSyntax.unexpectedAfterRightSquare: - return "unexpectedAfterRightSquare" - case \DictionaryTypeSyntax.unexpectedBeforeLeftSquare: - return "unexpectedBeforeLeftSquare" - case \DictionaryTypeSyntax.leftSquare: - return "leftSquare" - case \DictionaryTypeSyntax.unexpectedBetweenLeftSquareAndKey: - return "unexpectedBetweenLeftSquareAndKey" - case \DictionaryTypeSyntax.key: - return "key" - case \DictionaryTypeSyntax.unexpectedBetweenKeyAndColon: - return "unexpectedBetweenKeyAndColon" - case \DictionaryTypeSyntax.colon: - return "colon" - case \DictionaryTypeSyntax.unexpectedBetweenColonAndValue: - return "unexpectedBetweenColonAndValue" - case \DictionaryTypeSyntax.value: - return "value" - case \DictionaryTypeSyntax.unexpectedBetweenValueAndRightSquare: - return "unexpectedBetweenValueAndRightSquare" - case \DictionaryTypeSyntax.rightSquare: - return "rightSquare" - case \DictionaryTypeSyntax.unexpectedAfterRightSquare: - return "unexpectedAfterRightSquare" - case \DifferentiabilityArgumentSyntax.unexpectedBeforeArgument: - return "unexpectedBeforeArgument" - case \DifferentiabilityArgumentSyntax.argument: - return "argument" - case \DifferentiabilityArgumentSyntax.unexpectedBetweenArgumentAndTrailingComma: - return "unexpectedBetweenArgumentAndTrailingComma" - case \DifferentiabilityArgumentSyntax.trailingComma: - return "trailingComma" - case \DifferentiabilityArgumentSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \DifferentiabilityArgumentsSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \DifferentiabilityArgumentsSyntax.leftParen: - return "leftParen" - case \DifferentiabilityArgumentsSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" - case \DifferentiabilityArgumentsSyntax.arguments: - return "arguments" - case \DifferentiabilityArgumentsSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \DifferentiabilityArgumentsSyntax.rightParen: - return "rightParen" - case \DifferentiabilityArgumentsSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \DifferentiabilityWithRespectToArgumentSyntax.unexpectedBeforeWrtLabel: - return "unexpectedBeforeWrtLabel" - case \DifferentiabilityWithRespectToArgumentSyntax.wrtLabel: - return "wrtLabel" - case \DifferentiabilityWithRespectToArgumentSyntax.unexpectedBetweenWrtLabelAndColon: - return "unexpectedBetweenWrtLabelAndColon" - case \DifferentiabilityWithRespectToArgumentSyntax.colon: - return "colon" - case \DifferentiabilityWithRespectToArgumentSyntax.unexpectedBetweenColonAndArguments: - return "unexpectedBetweenColonAndArguments" - case \DifferentiabilityWithRespectToArgumentSyntax.arguments: - return "arguments" - case \DifferentiabilityWithRespectToArgumentSyntax.unexpectedAfterArguments: - return "unexpectedAfterArguments" - case \DifferentiableAttributeArgumentsSyntax.unexpectedBeforeKindSpecifier: - return "unexpectedBeforeKindSpecifier" - case \DifferentiableAttributeArgumentsSyntax.kindSpecifier: - return "kindSpecifier" - case \DifferentiableAttributeArgumentsSyntax.unexpectedBetweenKindSpecifierAndKindSpecifierComma: - return "unexpectedBetweenKindSpecifierAndKindSpecifierComma" - case \DifferentiableAttributeArgumentsSyntax.kindSpecifierComma: - return "kindSpecifierComma" - case \DifferentiableAttributeArgumentsSyntax.unexpectedBetweenKindSpecifierCommaAndArguments: - return "unexpectedBetweenKindSpecifierCommaAndArguments" - case \DifferentiableAttributeArgumentsSyntax.arguments: - return "arguments" - case \DifferentiableAttributeArgumentsSyntax.unexpectedBetweenArgumentsAndArgumentsComma: - return "unexpectedBetweenArgumentsAndArgumentsComma" - case \DifferentiableAttributeArgumentsSyntax.argumentsComma: - return "argumentsComma" - case \DifferentiableAttributeArgumentsSyntax.unexpectedBetweenArgumentsCommaAndGenericWhereClause: - return "unexpectedBetweenArgumentsCommaAndGenericWhereClause" - case \DifferentiableAttributeArgumentsSyntax.genericWhereClause: - return "genericWhereClause" - case \DifferentiableAttributeArgumentsSyntax.unexpectedAfterGenericWhereClause: - return "unexpectedAfterGenericWhereClause" - case \DiscardAssignmentExprSyntax.unexpectedBeforeWildcard: - return "unexpectedBeforeWildcard" - case \DiscardAssignmentExprSyntax.wildcard: - return "wildcard" - case \DiscardAssignmentExprSyntax.unexpectedAfterWildcard: - return "unexpectedAfterWildcard" - case \DiscardStmtSyntax.unexpectedBeforeDiscardKeyword: - return "unexpectedBeforeDiscardKeyword" - case \DiscardStmtSyntax.discardKeyword: - return "discardKeyword" - case \DiscardStmtSyntax.unexpectedBetweenDiscardKeywordAndExpression: - return "unexpectedBetweenDiscardKeywordAndExpression" - case \DiscardStmtSyntax.expression: - return "expression" - case \DiscardStmtSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \DoExprSyntax.unexpectedBeforeDoKeyword: - return "unexpectedBeforeDoKeyword" - case \DoExprSyntax.doKeyword: - return "doKeyword" - case \DoExprSyntax.unexpectedBetweenDoKeywordAndBody: - return "unexpectedBetweenDoKeywordAndBody" - case \DoExprSyntax.body: - return "body" - case \DoExprSyntax.unexpectedBetweenBodyAndCatchClauses: - return "unexpectedBetweenBodyAndCatchClauses" - case \DoExprSyntax.catchClauses: - return "catchClauses" - case \DoExprSyntax.unexpectedAfterCatchClauses: - return "unexpectedAfterCatchClauses" - case \DoStmtSyntax.unexpectedBeforeDoKeyword: - return "unexpectedBeforeDoKeyword" - case \DoStmtSyntax.doKeyword: - return "doKeyword" - case \DoStmtSyntax.unexpectedBetweenDoKeywordAndThrowsClause: - return "unexpectedBetweenDoKeywordAndThrowsClause" - case \DoStmtSyntax.throwsClause: - return "throwsClause" - case \DoStmtSyntax.unexpectedBetweenThrowsClauseAndBody: - return "unexpectedBetweenThrowsClauseAndBody" - case \DoStmtSyntax.body: - return "body" - case \DoStmtSyntax.unexpectedBetweenBodyAndCatchClauses: - return "unexpectedBetweenBodyAndCatchClauses" - case \DoStmtSyntax.catchClauses: - return "catchClauses" - case \DoStmtSyntax.unexpectedAfterCatchClauses: - return "unexpectedAfterCatchClauses" - case \DocumentationAttributeArgumentSyntax.unexpectedBeforeLabel: - return "unexpectedBeforeLabel" - case \DocumentationAttributeArgumentSyntax.label: - return "label" - case \DocumentationAttributeArgumentSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \DocumentationAttributeArgumentSyntax.colon: - return "colon" - case \DocumentationAttributeArgumentSyntax.unexpectedBetweenColonAndValue: - return "unexpectedBetweenColonAndValue" - case \DocumentationAttributeArgumentSyntax.value: - return "value" - case \DocumentationAttributeArgumentSyntax.unexpectedBetweenValueAndTrailingComma: - return "unexpectedBetweenValueAndTrailingComma" - case \DocumentationAttributeArgumentSyntax.trailingComma: - return "trailingComma" - case \DocumentationAttributeArgumentSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \DynamicReplacementAttributeArgumentsSyntax.unexpectedBeforeForLabel: - return "unexpectedBeforeForLabel" - case \DynamicReplacementAttributeArgumentsSyntax.forLabel: - return "forLabel" - case \DynamicReplacementAttributeArgumentsSyntax.unexpectedBetweenForLabelAndColon: - return "unexpectedBetweenForLabelAndColon" - case \DynamicReplacementAttributeArgumentsSyntax.colon: - return "colon" - case \DynamicReplacementAttributeArgumentsSyntax.unexpectedBetweenColonAndDeclName: - return "unexpectedBetweenColonAndDeclName" - case \DynamicReplacementAttributeArgumentsSyntax.declName: - return "declName" - case \DynamicReplacementAttributeArgumentsSyntax.unexpectedAfterDeclName: - return "unexpectedAfterDeclName" - case \EditorPlaceholderDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \EditorPlaceholderDeclSyntax.attributes: - return "attributes" - case \EditorPlaceholderDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \EditorPlaceholderDeclSyntax.modifiers: - return "modifiers" - case \EditorPlaceholderDeclSyntax.unexpectedBetweenModifiersAndPlaceholder: - return "unexpectedBetweenModifiersAndPlaceholder" - case \EditorPlaceholderDeclSyntax.placeholder: - return "placeholder" - case \EditorPlaceholderDeclSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \EditorPlaceholderExprSyntax.unexpectedBeforePlaceholder: - return "unexpectedBeforePlaceholder" - case \EditorPlaceholderExprSyntax.placeholder: - return "placeholder" - case \EditorPlaceholderExprSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \EnumCaseDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \EnumCaseDeclSyntax.attributes: - return "attributes" - case \EnumCaseDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \EnumCaseDeclSyntax.modifiers: - return "modifiers" - case \EnumCaseDeclSyntax.unexpectedBetweenModifiersAndCaseKeyword: - return "unexpectedBetweenModifiersAndCaseKeyword" - case \EnumCaseDeclSyntax.caseKeyword: - return "caseKeyword" - case \EnumCaseDeclSyntax.unexpectedBetweenCaseKeywordAndElements: - return "unexpectedBetweenCaseKeywordAndElements" - case \EnumCaseDeclSyntax.elements: - return "elements" - case \EnumCaseDeclSyntax.unexpectedAfterElements: - return "unexpectedAfterElements" - case \EnumCaseElementSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \EnumCaseElementSyntax.name: - return "name" - case \EnumCaseElementSyntax.unexpectedBetweenNameAndParameterClause: - return "unexpectedBetweenNameAndParameterClause" - case \EnumCaseElementSyntax.parameterClause: - return "parameterClause" - case \EnumCaseElementSyntax.unexpectedBetweenParameterClauseAndRawValue: - return "unexpectedBetweenParameterClauseAndRawValue" - case \EnumCaseElementSyntax.rawValue: - return "rawValue" - case \EnumCaseElementSyntax.unexpectedBetweenRawValueAndTrailingComma: - return "unexpectedBetweenRawValueAndTrailingComma" - case \EnumCaseElementSyntax.trailingComma: - return "trailingComma" - case \EnumCaseElementSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \EnumCaseParameterClauseSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \EnumCaseParameterClauseSyntax.leftParen: - return "leftParen" - case \EnumCaseParameterClauseSyntax.unexpectedBetweenLeftParenAndParameters: - return "unexpectedBetweenLeftParenAndParameters" - case \EnumCaseParameterClauseSyntax.parameters: - return "parameters" - case \EnumCaseParameterClauseSyntax.unexpectedBetweenParametersAndRightParen: - return "unexpectedBetweenParametersAndRightParen" - case \EnumCaseParameterClauseSyntax.rightParen: - return "rightParen" - case \EnumCaseParameterClauseSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \EnumCaseParameterSyntax.unexpectedBeforeModifiers: - return "unexpectedBeforeModifiers" - case \EnumCaseParameterSyntax.modifiers: - return "modifiers" - case \EnumCaseParameterSyntax.unexpectedBetweenModifiersAndFirstName: - return "unexpectedBetweenModifiersAndFirstName" - case \EnumCaseParameterSyntax.firstName: - return "firstName" - case \EnumCaseParameterSyntax.unexpectedBetweenFirstNameAndSecondName: - return "unexpectedBetweenFirstNameAndSecondName" - case \EnumCaseParameterSyntax.secondName: - return "secondName" - case \EnumCaseParameterSyntax.unexpectedBetweenSecondNameAndColon: - return "unexpectedBetweenSecondNameAndColon" - case \EnumCaseParameterSyntax.colon: - return "colon" - case \EnumCaseParameterSyntax.unexpectedBetweenColonAndType: - return "unexpectedBetweenColonAndType" - case \EnumCaseParameterSyntax.type: - return "type" - case \EnumCaseParameterSyntax.unexpectedBetweenTypeAndDefaultValue: - return "unexpectedBetweenTypeAndDefaultValue" - case \EnumCaseParameterSyntax.defaultValue: - return "defaultValue" - case \EnumCaseParameterSyntax.unexpectedBetweenDefaultValueAndTrailingComma: - return "unexpectedBetweenDefaultValueAndTrailingComma" - case \EnumCaseParameterSyntax.trailingComma: - return "trailingComma" - case \EnumCaseParameterSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \EnumDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \EnumDeclSyntax.attributes: - return "attributes" - case \EnumDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \EnumDeclSyntax.modifiers: - return "modifiers" - case \EnumDeclSyntax.unexpectedBetweenModifiersAndEnumKeyword: - return "unexpectedBetweenModifiersAndEnumKeyword" - case \EnumDeclSyntax.enumKeyword: - return "enumKeyword" - case \EnumDeclSyntax.unexpectedBetweenEnumKeywordAndName: - return "unexpectedBetweenEnumKeywordAndName" - case \EnumDeclSyntax.name: - return "name" - case \EnumDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: - return "unexpectedBetweenNameAndGenericParameterClause" - case \EnumDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \EnumDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: - return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \EnumDeclSyntax.inheritanceClause: - return "inheritanceClause" - case \EnumDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: - return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \EnumDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \EnumDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" - case \EnumDeclSyntax.memberBlock: - return "memberBlock" - case \EnumDeclSyntax.unexpectedAfterMemberBlock: - return "unexpectedAfterMemberBlock" - case \ExposeAttributeArgumentsSyntax.unexpectedBeforeLanguage: - return "unexpectedBeforeLanguage" - case \ExposeAttributeArgumentsSyntax.language: - return "language" - case \ExposeAttributeArgumentsSyntax.unexpectedBetweenLanguageAndComma: - return "unexpectedBetweenLanguageAndComma" - case \ExposeAttributeArgumentsSyntax.comma: - return "comma" - case \ExposeAttributeArgumentsSyntax.unexpectedBetweenCommaAndCxxName: - return "unexpectedBetweenCommaAndCxxName" - case \ExposeAttributeArgumentsSyntax.cxxName: - return "cxxName" - case \ExposeAttributeArgumentsSyntax.unexpectedAfterCxxName: - return "unexpectedAfterCxxName" - case \ExpressionPatternSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \ExpressionPatternSyntax.expression: - return "expression" - case \ExpressionPatternSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \ExpressionSegmentSyntax.unexpectedBeforeBackslash: - return "unexpectedBeforeBackslash" - case \ExpressionSegmentSyntax.backslash: - return "backslash" - case \ExpressionSegmentSyntax.unexpectedBetweenBackslashAndPounds: - return "unexpectedBetweenBackslashAndPounds" - case \ExpressionSegmentSyntax.pounds: - return "pounds" - case \ExpressionSegmentSyntax.unexpectedBetweenPoundsAndLeftParen: - return "unexpectedBetweenPoundsAndLeftParen" - case \ExpressionSegmentSyntax.leftParen: - return "leftParen" - case \ExpressionSegmentSyntax.unexpectedBetweenLeftParenAndExpressions: - return "unexpectedBetweenLeftParenAndExpressions" - case \ExpressionSegmentSyntax.expressions: - return "expressions" - case \ExpressionSegmentSyntax.unexpectedBetweenExpressionsAndRightParen: - return "unexpectedBetweenExpressionsAndRightParen" - case \ExpressionSegmentSyntax.rightParen: - return "rightParen" - case \ExpressionSegmentSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \ExpressionStmtSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \ExpressionStmtSyntax.expression: - return "expression" - case \ExpressionStmtSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \ExtensionDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \ExtensionDeclSyntax.attributes: - return "attributes" - case \ExtensionDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \ExtensionDeclSyntax.modifiers: - return "modifiers" - case \ExtensionDeclSyntax.unexpectedBetweenModifiersAndExtensionKeyword: - return "unexpectedBetweenModifiersAndExtensionKeyword" - case \ExtensionDeclSyntax.extensionKeyword: - return "extensionKeyword" - case \ExtensionDeclSyntax.unexpectedBetweenExtensionKeywordAndExtendedType: - return "unexpectedBetweenExtensionKeywordAndExtendedType" - case \ExtensionDeclSyntax.extendedType: - return "extendedType" - case \ExtensionDeclSyntax.unexpectedBetweenExtendedTypeAndInheritanceClause: - return "unexpectedBetweenExtendedTypeAndInheritanceClause" - case \ExtensionDeclSyntax.inheritanceClause: - return "inheritanceClause" - case \ExtensionDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: - return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ExtensionDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \ExtensionDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" - case \ExtensionDeclSyntax.memberBlock: - return "memberBlock" - case \ExtensionDeclSyntax.unexpectedAfterMemberBlock: - return "unexpectedAfterMemberBlock" - case \FallThroughStmtSyntax.unexpectedBeforeFallthroughKeyword: - return "unexpectedBeforeFallthroughKeyword" - case \FallThroughStmtSyntax.fallthroughKeyword: - return "fallthroughKeyword" - case \FallThroughStmtSyntax.unexpectedAfterFallthroughKeyword: - return "unexpectedAfterFallthroughKeyword" - case \FloatLiteralExprSyntax.unexpectedBeforeLiteral: - return "unexpectedBeforeLiteral" - case \FloatLiteralExprSyntax.literal: - return "literal" - case \FloatLiteralExprSyntax.unexpectedAfterLiteral: - return "unexpectedAfterLiteral" - case \ForStmtSyntax.unexpectedBeforeForKeyword: - return "unexpectedBeforeForKeyword" - case \ForStmtSyntax.forKeyword: - return "forKeyword" - case \ForStmtSyntax.unexpectedBetweenForKeywordAndTryKeyword: - return "unexpectedBetweenForKeywordAndTryKeyword" - case \ForStmtSyntax.tryKeyword: - return "tryKeyword" - case \ForStmtSyntax.unexpectedBetweenTryKeywordAndAwaitKeyword: - return "unexpectedBetweenTryKeywordAndAwaitKeyword" - case \ForStmtSyntax.awaitKeyword: - return "awaitKeyword" - case \ForStmtSyntax.unexpectedBetweenAwaitKeywordAndCaseKeyword: - return "unexpectedBetweenAwaitKeywordAndCaseKeyword" - case \ForStmtSyntax.caseKeyword: - return "caseKeyword" - case \ForStmtSyntax.unexpectedBetweenCaseKeywordAndPattern: - return "unexpectedBetweenCaseKeywordAndPattern" - case \ForStmtSyntax.pattern: - return "pattern" - case \ForStmtSyntax.unexpectedBetweenPatternAndTypeAnnotation: - return "unexpectedBetweenPatternAndTypeAnnotation" - case \ForStmtSyntax.typeAnnotation: - return "typeAnnotation" - case \ForStmtSyntax.unexpectedBetweenTypeAnnotationAndInKeyword: - return "unexpectedBetweenTypeAnnotationAndInKeyword" - case \ForStmtSyntax.inKeyword: - return "inKeyword" - case \ForStmtSyntax.unexpectedBetweenInKeywordAndSequence: - return "unexpectedBetweenInKeywordAndSequence" - case \ForStmtSyntax.sequence: - return "sequence" - case \ForStmtSyntax.unexpectedBetweenSequenceAndWhereClause: - return "unexpectedBetweenSequenceAndWhereClause" - case \ForStmtSyntax.whereClause: - return "whereClause" - case \ForStmtSyntax.unexpectedBetweenWhereClauseAndBody: - return "unexpectedBetweenWhereClauseAndBody" - case \ForStmtSyntax.body: - return "body" - case \ForStmtSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \ForceUnwrapExprSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \ForceUnwrapExprSyntax.expression: - return "expression" - case \ForceUnwrapExprSyntax.unexpectedBetweenExpressionAndExclamationMark: - return "unexpectedBetweenExpressionAndExclamationMark" - case \ForceUnwrapExprSyntax.exclamationMark: - return "exclamationMark" - case \ForceUnwrapExprSyntax.unexpectedAfterExclamationMark: - return "unexpectedAfterExclamationMark" - case \FunctionCallExprSyntax.unexpectedBeforeCalledExpression: - return "unexpectedBeforeCalledExpression" - case \FunctionCallExprSyntax.calledExpression: - return "calledExpression" - case \FunctionCallExprSyntax.unexpectedBetweenCalledExpressionAndLeftParen: - return "unexpectedBetweenCalledExpressionAndLeftParen" - case \FunctionCallExprSyntax.leftParen: - return "leftParen" - case \FunctionCallExprSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" - case \FunctionCallExprSyntax.arguments: - return "arguments" - case \FunctionCallExprSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \FunctionCallExprSyntax.rightParen: - return "rightParen" - case \FunctionCallExprSyntax.unexpectedBetweenRightParenAndTrailingClosure: - return "unexpectedBetweenRightParenAndTrailingClosure" - case \FunctionCallExprSyntax.trailingClosure: - return "trailingClosure" - case \FunctionCallExprSyntax.unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: - return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" - case \FunctionCallExprSyntax.additionalTrailingClosures: - return "additionalTrailingClosures" - case \FunctionCallExprSyntax.unexpectedAfterAdditionalTrailingClosures: - return "unexpectedAfterAdditionalTrailingClosures" - case \FunctionDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \FunctionDeclSyntax.attributes: - return "attributes" - case \FunctionDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \FunctionDeclSyntax.modifiers: - return "modifiers" - case \FunctionDeclSyntax.unexpectedBetweenModifiersAndFuncKeyword: - return "unexpectedBetweenModifiersAndFuncKeyword" - case \FunctionDeclSyntax.funcKeyword: - return "funcKeyword" - case \FunctionDeclSyntax.unexpectedBetweenFuncKeywordAndName: - return "unexpectedBetweenFuncKeywordAndName" - case \FunctionDeclSyntax.name: - return "name" - case \FunctionDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: - return "unexpectedBetweenNameAndGenericParameterClause" - case \FunctionDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \FunctionDeclSyntax.unexpectedBetweenGenericParameterClauseAndSignature: - return "unexpectedBetweenGenericParameterClauseAndSignature" - case \FunctionDeclSyntax.signature: - return "signature" - case \FunctionDeclSyntax.unexpectedBetweenSignatureAndGenericWhereClause: - return "unexpectedBetweenSignatureAndGenericWhereClause" - case \FunctionDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \FunctionDeclSyntax.unexpectedBetweenGenericWhereClauseAndBody: - return "unexpectedBetweenGenericWhereClauseAndBody" - case \FunctionDeclSyntax.body: - return "body" - case \FunctionDeclSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \FunctionEffectSpecifiersSyntax.unexpectedBeforeAsyncSpecifier: - return "unexpectedBeforeAsyncSpecifier" - case \FunctionEffectSpecifiersSyntax.asyncSpecifier: - return "asyncSpecifier" - case \FunctionEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsClause: - return "unexpectedBetweenAsyncSpecifierAndThrowsClause" - case \FunctionEffectSpecifiersSyntax.throwsClause: - return "throwsClause" - case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrowsClause: - return "unexpectedAfterThrowsClause" - case \FunctionParameterClauseSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \FunctionParameterClauseSyntax.leftParen: - return "leftParen" - case \FunctionParameterClauseSyntax.unexpectedBetweenLeftParenAndParameters: - return "unexpectedBetweenLeftParenAndParameters" - case \FunctionParameterClauseSyntax.parameters: - return "parameters" - case \FunctionParameterClauseSyntax.unexpectedBetweenParametersAndRightParen: - return "unexpectedBetweenParametersAndRightParen" - case \FunctionParameterClauseSyntax.rightParen: - return "rightParen" - case \FunctionParameterClauseSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \FunctionParameterSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \FunctionParameterSyntax.attributes: - return "attributes" - case \FunctionParameterSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \FunctionParameterSyntax.modifiers: - return "modifiers" - case \FunctionParameterSyntax.unexpectedBetweenModifiersAndFirstName: - return "unexpectedBetweenModifiersAndFirstName" - case \FunctionParameterSyntax.firstName: - return "firstName" - case \FunctionParameterSyntax.unexpectedBetweenFirstNameAndSecondName: - return "unexpectedBetweenFirstNameAndSecondName" - case \FunctionParameterSyntax.secondName: - return "secondName" - case \FunctionParameterSyntax.unexpectedBetweenSecondNameAndColon: - return "unexpectedBetweenSecondNameAndColon" - case \FunctionParameterSyntax.colon: - return "colon" - case \FunctionParameterSyntax.unexpectedBetweenColonAndType: - return "unexpectedBetweenColonAndType" - case \FunctionParameterSyntax.type: - return "type" - case \FunctionParameterSyntax.unexpectedBetweenTypeAndEllipsis: - return "unexpectedBetweenTypeAndEllipsis" - case \FunctionParameterSyntax.ellipsis: - return "ellipsis" - case \FunctionParameterSyntax.unexpectedBetweenEllipsisAndDefaultValue: - return "unexpectedBetweenEllipsisAndDefaultValue" - case \FunctionParameterSyntax.defaultValue: - return "defaultValue" - case \FunctionParameterSyntax.unexpectedBetweenDefaultValueAndTrailingComma: - return "unexpectedBetweenDefaultValueAndTrailingComma" - case \FunctionParameterSyntax.trailingComma: - return "trailingComma" - case \FunctionParameterSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \FunctionSignatureSyntax.unexpectedBeforeParameterClause: - return "unexpectedBeforeParameterClause" - case \FunctionSignatureSyntax.parameterClause: - return "parameterClause" - case \FunctionSignatureSyntax.unexpectedBetweenParameterClauseAndEffectSpecifiers: - return "unexpectedBetweenParameterClauseAndEffectSpecifiers" - case \FunctionSignatureSyntax.effectSpecifiers: - return "effectSpecifiers" - case \FunctionSignatureSyntax.unexpectedBetweenEffectSpecifiersAndReturnClause: - return "unexpectedBetweenEffectSpecifiersAndReturnClause" - case \FunctionSignatureSyntax.returnClause: - return "returnClause" - case \FunctionSignatureSyntax.unexpectedAfterReturnClause: - return "unexpectedAfterReturnClause" - case \FunctionTypeSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \FunctionTypeSyntax.leftParen: - return "leftParen" - case \FunctionTypeSyntax.unexpectedBetweenLeftParenAndParameters: - return "unexpectedBetweenLeftParenAndParameters" - case \FunctionTypeSyntax.parameters: - return "parameters" - case \FunctionTypeSyntax.unexpectedBetweenParametersAndRightParen: - return "unexpectedBetweenParametersAndRightParen" - case \FunctionTypeSyntax.rightParen: - return "rightParen" - case \FunctionTypeSyntax.unexpectedBetweenRightParenAndEffectSpecifiers: - return "unexpectedBetweenRightParenAndEffectSpecifiers" - case \FunctionTypeSyntax.effectSpecifiers: - return "effectSpecifiers" - case \FunctionTypeSyntax.unexpectedBetweenEffectSpecifiersAndReturnClause: - return "unexpectedBetweenEffectSpecifiersAndReturnClause" - case \FunctionTypeSyntax.returnClause: - return "returnClause" - case \FunctionTypeSyntax.unexpectedAfterReturnClause: - return "unexpectedAfterReturnClause" - case \GenericArgumentClauseSyntax.unexpectedBeforeLeftAngle: - return "unexpectedBeforeLeftAngle" - case \GenericArgumentClauseSyntax.leftAngle: - return "leftAngle" - case \GenericArgumentClauseSyntax.unexpectedBetweenLeftAngleAndArguments: - return "unexpectedBetweenLeftAngleAndArguments" - case \GenericArgumentClauseSyntax.arguments: - return "arguments" - case \GenericArgumentClauseSyntax.unexpectedBetweenArgumentsAndRightAngle: - return "unexpectedBetweenArgumentsAndRightAngle" - case \GenericArgumentClauseSyntax.rightAngle: - return "rightAngle" - case \GenericArgumentClauseSyntax.unexpectedAfterRightAngle: - return "unexpectedAfterRightAngle" - case \GenericArgumentSyntax.unexpectedBeforeArgument: - return "unexpectedBeforeArgument" - case \GenericArgumentSyntax.argument: - return "argument" - case \GenericArgumentSyntax.unexpectedBetweenArgumentAndTrailingComma: - return "unexpectedBetweenArgumentAndTrailingComma" - case \GenericArgumentSyntax.trailingComma: - return "trailingComma" - case \GenericArgumentSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \GenericParameterClauseSyntax.unexpectedBeforeLeftAngle: - return "unexpectedBeforeLeftAngle" - case \GenericParameterClauseSyntax.leftAngle: - return "leftAngle" - case \GenericParameterClauseSyntax.unexpectedBetweenLeftAngleAndParameters: - return "unexpectedBetweenLeftAngleAndParameters" - case \GenericParameterClauseSyntax.parameters: - return "parameters" - case \GenericParameterClauseSyntax.unexpectedBetweenParametersAndGenericWhereClause: - return "unexpectedBetweenParametersAndGenericWhereClause" - case \GenericParameterClauseSyntax.genericWhereClause: - return "genericWhereClause" - case \GenericParameterClauseSyntax.unexpectedBetweenGenericWhereClauseAndRightAngle: - return "unexpectedBetweenGenericWhereClauseAndRightAngle" - case \GenericParameterClauseSyntax.rightAngle: - return "rightAngle" - case \GenericParameterClauseSyntax.unexpectedAfterRightAngle: - return "unexpectedAfterRightAngle" - case \GenericParameterSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \GenericParameterSyntax.attributes: - return "attributes" - case \GenericParameterSyntax.unexpectedBetweenAttributesAndSpecifier: - return "unexpectedBetweenAttributesAndSpecifier" - case \GenericParameterSyntax.specifier: - return "specifier" - case \GenericParameterSyntax.unexpectedBetweenSpecifierAndName: - return "unexpectedBetweenSpecifierAndName" - case \GenericParameterSyntax.name: - return "name" - case \GenericParameterSyntax.unexpectedBetweenNameAndColon: - return "unexpectedBetweenNameAndColon" - case \GenericParameterSyntax.colon: - return "colon" - case \GenericParameterSyntax.unexpectedBetweenColonAndInheritedType: - return "unexpectedBetweenColonAndInheritedType" - case \GenericParameterSyntax.inheritedType: - return "inheritedType" - case \GenericParameterSyntax.unexpectedBetweenInheritedTypeAndTrailingComma: - return "unexpectedBetweenInheritedTypeAndTrailingComma" - case \GenericParameterSyntax.trailingComma: - return "trailingComma" - case \GenericParameterSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \GenericRequirementSyntax.unexpectedBeforeRequirement: - return "unexpectedBeforeRequirement" - case \GenericRequirementSyntax.requirement: - return "requirement" - case \GenericRequirementSyntax.unexpectedBetweenRequirementAndTrailingComma: - return "unexpectedBetweenRequirementAndTrailingComma" - case \GenericRequirementSyntax.trailingComma: - return "trailingComma" - case \GenericRequirementSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \GenericSpecializationExprSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \GenericSpecializationExprSyntax.expression: - return "expression" - case \GenericSpecializationExprSyntax.unexpectedBetweenExpressionAndGenericArgumentClause: - return "unexpectedBetweenExpressionAndGenericArgumentClause" - case \GenericSpecializationExprSyntax.genericArgumentClause: - return "genericArgumentClause" - case \GenericSpecializationExprSyntax.unexpectedAfterGenericArgumentClause: - return "unexpectedAfterGenericArgumentClause" - case \GenericWhereClauseSyntax.unexpectedBeforeWhereKeyword: - return "unexpectedBeforeWhereKeyword" - case \GenericWhereClauseSyntax.whereKeyword: - return "whereKeyword" - case \GenericWhereClauseSyntax.unexpectedBetweenWhereKeywordAndRequirements: - return "unexpectedBetweenWhereKeywordAndRequirements" - case \GenericWhereClauseSyntax.requirements: - return "requirements" - case \GenericWhereClauseSyntax.unexpectedAfterRequirements: - return "unexpectedAfterRequirements" - case \GuardStmtSyntax.unexpectedBeforeGuardKeyword: - return "unexpectedBeforeGuardKeyword" - case \GuardStmtSyntax.guardKeyword: - return "guardKeyword" - case \GuardStmtSyntax.unexpectedBetweenGuardKeywordAndConditions: - return "unexpectedBetweenGuardKeywordAndConditions" - case \GuardStmtSyntax.conditions: - return "conditions" - case \GuardStmtSyntax.unexpectedBetweenConditionsAndElseKeyword: - return "unexpectedBetweenConditionsAndElseKeyword" - case \GuardStmtSyntax.elseKeyword: - return "elseKeyword" - case \GuardStmtSyntax.unexpectedBetweenElseKeywordAndBody: - return "unexpectedBetweenElseKeywordAndBody" - case \GuardStmtSyntax.body: - return "body" - case \GuardStmtSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \IdentifierPatternSyntax.unexpectedBeforeIdentifier: - return "unexpectedBeforeIdentifier" - case \IdentifierPatternSyntax.identifier: - return "identifier" - case \IdentifierPatternSyntax.unexpectedAfterIdentifier: - return "unexpectedAfterIdentifier" - case \IdentifierTypeSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \IdentifierTypeSyntax.name: - return "name" - case \IdentifierTypeSyntax.unexpectedBetweenNameAndGenericArgumentClause: - return "unexpectedBetweenNameAndGenericArgumentClause" - case \IdentifierTypeSyntax.genericArgumentClause: - return "genericArgumentClause" - case \IdentifierTypeSyntax.unexpectedAfterGenericArgumentClause: - return "unexpectedAfterGenericArgumentClause" - case \IfConfigClauseSyntax.unexpectedBeforePoundKeyword: - return "unexpectedBeforePoundKeyword" - case \IfConfigClauseSyntax.poundKeyword: - return "poundKeyword" - case \IfConfigClauseSyntax.unexpectedBetweenPoundKeywordAndCondition: - return "unexpectedBetweenPoundKeywordAndCondition" - case \IfConfigClauseSyntax.condition: - return "condition" - case \IfConfigClauseSyntax.unexpectedBetweenConditionAndElements: - return "unexpectedBetweenConditionAndElements" - case \IfConfigClauseSyntax.elements: - return "elements" - case \IfConfigClauseSyntax.unexpectedAfterElements: - return "unexpectedAfterElements" - case \IfConfigDeclSyntax.unexpectedBeforeClauses: - return "unexpectedBeforeClauses" - case \IfConfigDeclSyntax.clauses: - return "clauses" - case \IfConfigDeclSyntax.unexpectedBetweenClausesAndPoundEndif: - return "unexpectedBetweenClausesAndPoundEndif" - case \IfConfigDeclSyntax.poundEndif: - return "poundEndif" - case \IfConfigDeclSyntax.unexpectedAfterPoundEndif: - return "unexpectedAfterPoundEndif" - case \IfExprSyntax.unexpectedBeforeIfKeyword: - return "unexpectedBeforeIfKeyword" - case \IfExprSyntax.ifKeyword: - return "ifKeyword" - case \IfExprSyntax.unexpectedBetweenIfKeywordAndConditions: - return "unexpectedBetweenIfKeywordAndConditions" - case \IfExprSyntax.conditions: - return "conditions" - case \IfExprSyntax.unexpectedBetweenConditionsAndBody: - return "unexpectedBetweenConditionsAndBody" - case \IfExprSyntax.body: - return "body" - case \IfExprSyntax.unexpectedBetweenBodyAndElseKeyword: - return "unexpectedBetweenBodyAndElseKeyword" - case \IfExprSyntax.elseKeyword: - return "elseKeyword" - case \IfExprSyntax.unexpectedBetweenElseKeywordAndElseBody: - return "unexpectedBetweenElseKeywordAndElseBody" - case \IfExprSyntax.elseBody: - return "elseBody" - case \IfExprSyntax.unexpectedAfterElseBody: - return "unexpectedAfterElseBody" - case \ImplementsAttributeArgumentsSyntax.unexpectedBeforeType: - return "unexpectedBeforeType" - case \ImplementsAttributeArgumentsSyntax.type: - return "type" - case \ImplementsAttributeArgumentsSyntax.unexpectedBetweenTypeAndComma: - return "unexpectedBetweenTypeAndComma" - case \ImplementsAttributeArgumentsSyntax.comma: - return "comma" - case \ImplementsAttributeArgumentsSyntax.unexpectedBetweenCommaAndDeclName: - return "unexpectedBetweenCommaAndDeclName" - case \ImplementsAttributeArgumentsSyntax.declName: - return "declName" - case \ImplementsAttributeArgumentsSyntax.unexpectedAfterDeclName: - return "unexpectedAfterDeclName" - case \ImplicitlyUnwrappedOptionalTypeSyntax.unexpectedBeforeWrappedType: - return "unexpectedBeforeWrappedType" - case \ImplicitlyUnwrappedOptionalTypeSyntax.wrappedType: - return "wrappedType" - case \ImplicitlyUnwrappedOptionalTypeSyntax.unexpectedBetweenWrappedTypeAndExclamationMark: - return "unexpectedBetweenWrappedTypeAndExclamationMark" - case \ImplicitlyUnwrappedOptionalTypeSyntax.exclamationMark: - return "exclamationMark" - case \ImplicitlyUnwrappedOptionalTypeSyntax.unexpectedAfterExclamationMark: - return "unexpectedAfterExclamationMark" - case \ImportDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \ImportDeclSyntax.attributes: - return "attributes" - case \ImportDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \ImportDeclSyntax.modifiers: - return "modifiers" - case \ImportDeclSyntax.unexpectedBetweenModifiersAndImportKeyword: - return "unexpectedBetweenModifiersAndImportKeyword" - case \ImportDeclSyntax.importKeyword: - return "importKeyword" - case \ImportDeclSyntax.unexpectedBetweenImportKeywordAndImportKindSpecifier: - return "unexpectedBetweenImportKeywordAndImportKindSpecifier" - case \ImportDeclSyntax.importKindSpecifier: - return "importKindSpecifier" - case \ImportDeclSyntax.unexpectedBetweenImportKindSpecifierAndPath: - return "unexpectedBetweenImportKindSpecifierAndPath" - case \ImportDeclSyntax.path: - return "path" - case \ImportDeclSyntax.unexpectedAfterPath: - return "unexpectedAfterPath" - case \ImportPathComponentSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \ImportPathComponentSyntax.name: - return "name" - case \ImportPathComponentSyntax.unexpectedBetweenNameAndTrailingPeriod: - return "unexpectedBetweenNameAndTrailingPeriod" - case \ImportPathComponentSyntax.trailingPeriod: - return "trailingPeriod" - case \ImportPathComponentSyntax.unexpectedAfterTrailingPeriod: - return "unexpectedAfterTrailingPeriod" - case \InOutExprSyntax.unexpectedBeforeAmpersand: - return "unexpectedBeforeAmpersand" - case \InOutExprSyntax.ampersand: - return "ampersand" - case \InOutExprSyntax.unexpectedBetweenAmpersandAndExpression: - return "unexpectedBetweenAmpersandAndExpression" - case \InOutExprSyntax.expression: - return "expression" - case \InOutExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \InfixOperatorExprSyntax.unexpectedBeforeLeftOperand: - return "unexpectedBeforeLeftOperand" - case \InfixOperatorExprSyntax.leftOperand: - return "leftOperand" - case \InfixOperatorExprSyntax.unexpectedBetweenLeftOperandAndOperator: - return "unexpectedBetweenLeftOperandAndOperator" - case \InfixOperatorExprSyntax.operator: - return "operator" - case \InfixOperatorExprSyntax.unexpectedBetweenOperatorAndRightOperand: - return "unexpectedBetweenOperatorAndRightOperand" - case \InfixOperatorExprSyntax.rightOperand: - return "rightOperand" - case \InfixOperatorExprSyntax.unexpectedAfterRightOperand: - return "unexpectedAfterRightOperand" - case \InheritanceClauseSyntax.unexpectedBeforeColon: - return "unexpectedBeforeColon" - case \InheritanceClauseSyntax.colon: - return "colon" - case \InheritanceClauseSyntax.unexpectedBetweenColonAndInheritedTypes: - return "unexpectedBetweenColonAndInheritedTypes" - case \InheritanceClauseSyntax.inheritedTypes: - return "inheritedTypes" - case \InheritanceClauseSyntax.unexpectedAfterInheritedTypes: - return "unexpectedAfterInheritedTypes" - case \InheritedTypeSyntax.unexpectedBeforeType: - return "unexpectedBeforeType" - case \InheritedTypeSyntax.type: - return "type" - case \InheritedTypeSyntax.unexpectedBetweenTypeAndTrailingComma: - return "unexpectedBetweenTypeAndTrailingComma" - case \InheritedTypeSyntax.trailingComma: - return "trailingComma" - case \InheritedTypeSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \InitializerClauseSyntax.unexpectedBeforeEqual: - return "unexpectedBeforeEqual" - case \InitializerClauseSyntax.equal: - return "equal" - case \InitializerClauseSyntax.unexpectedBetweenEqualAndValue: - return "unexpectedBetweenEqualAndValue" - case \InitializerClauseSyntax.value: - return "value" - case \InitializerClauseSyntax.unexpectedAfterValue: - return "unexpectedAfterValue" - case \InitializerDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \InitializerDeclSyntax.attributes: - return "attributes" - case \InitializerDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \InitializerDeclSyntax.modifiers: - return "modifiers" - case \InitializerDeclSyntax.unexpectedBetweenModifiersAndInitKeyword: - return "unexpectedBetweenModifiersAndInitKeyword" - case \InitializerDeclSyntax.initKeyword: - return "initKeyword" - case \InitializerDeclSyntax.unexpectedBetweenInitKeywordAndOptionalMark: - return "unexpectedBetweenInitKeywordAndOptionalMark" - case \InitializerDeclSyntax.optionalMark: - return "optionalMark" - case \InitializerDeclSyntax.unexpectedBetweenOptionalMarkAndGenericParameterClause: - return "unexpectedBetweenOptionalMarkAndGenericParameterClause" - case \InitializerDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \InitializerDeclSyntax.unexpectedBetweenGenericParameterClauseAndSignature: - return "unexpectedBetweenGenericParameterClauseAndSignature" - case \InitializerDeclSyntax.signature: - return "signature" - case \InitializerDeclSyntax.unexpectedBetweenSignatureAndGenericWhereClause: - return "unexpectedBetweenSignatureAndGenericWhereClause" - case \InitializerDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \InitializerDeclSyntax.unexpectedBetweenGenericWhereClauseAndBody: - return "unexpectedBetweenGenericWhereClauseAndBody" - case \InitializerDeclSyntax.body: - return "body" - case \InitializerDeclSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \IntegerLiteralExprSyntax.unexpectedBeforeLiteral: - return "unexpectedBeforeLiteral" - case \IntegerLiteralExprSyntax.literal: - return "literal" - case \IntegerLiteralExprSyntax.unexpectedAfterLiteral: - return "unexpectedAfterLiteral" - case \IsExprSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \IsExprSyntax.expression: - return "expression" - case \IsExprSyntax.unexpectedBetweenExpressionAndIsKeyword: - return "unexpectedBetweenExpressionAndIsKeyword" - case \IsExprSyntax.isKeyword: - return "isKeyword" - case \IsExprSyntax.unexpectedBetweenIsKeywordAndType: - return "unexpectedBetweenIsKeywordAndType" - case \IsExprSyntax.type: - return "type" - case \IsExprSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \IsTypePatternSyntax.unexpectedBeforeIsKeyword: - return "unexpectedBeforeIsKeyword" - case \IsTypePatternSyntax.isKeyword: - return "isKeyword" - case \IsTypePatternSyntax.unexpectedBetweenIsKeywordAndType: - return "unexpectedBetweenIsKeywordAndType" - case \IsTypePatternSyntax.type: - return "type" - case \IsTypePatternSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \KeyPathComponentSyntax.unexpectedBeforePeriod: - return "unexpectedBeforePeriod" - case \KeyPathComponentSyntax.period: - return "period" - case \KeyPathComponentSyntax.unexpectedBetweenPeriodAndComponent: - return "unexpectedBetweenPeriodAndComponent" - case \KeyPathComponentSyntax.component: - return "component" - case \KeyPathComponentSyntax.unexpectedAfterComponent: - return "unexpectedAfterComponent" - case \KeyPathExprSyntax.unexpectedBeforeBackslash: - return "unexpectedBeforeBackslash" - case \KeyPathExprSyntax.backslash: - return "backslash" - case \KeyPathExprSyntax.unexpectedBetweenBackslashAndRoot: - return "unexpectedBetweenBackslashAndRoot" - case \KeyPathExprSyntax.root: - return "root" - case \KeyPathExprSyntax.unexpectedBetweenRootAndComponents: - return "unexpectedBetweenRootAndComponents" - case \KeyPathExprSyntax.components: - return "components" - case \KeyPathExprSyntax.unexpectedAfterComponents: - return "unexpectedAfterComponents" - case \KeyPathOptionalComponentSyntax.unexpectedBeforeQuestionOrExclamationMark: - return "unexpectedBeforeQuestionOrExclamationMark" - case \KeyPathOptionalComponentSyntax.questionOrExclamationMark: - return "questionOrExclamationMark" - case \KeyPathOptionalComponentSyntax.unexpectedAfterQuestionOrExclamationMark: - return "unexpectedAfterQuestionOrExclamationMark" - case \KeyPathPropertyComponentSyntax.unexpectedBeforeDeclName: - return "unexpectedBeforeDeclName" - case \KeyPathPropertyComponentSyntax.declName: - return "declName" - case \KeyPathPropertyComponentSyntax.unexpectedBetweenDeclNameAndGenericArgumentClause: - return "unexpectedBetweenDeclNameAndGenericArgumentClause" - case \KeyPathPropertyComponentSyntax.genericArgumentClause: - return "genericArgumentClause" - case \KeyPathPropertyComponentSyntax.unexpectedAfterGenericArgumentClause: - return "unexpectedAfterGenericArgumentClause" - case \KeyPathSubscriptComponentSyntax.unexpectedBeforeLeftSquare: - return "unexpectedBeforeLeftSquare" - case \KeyPathSubscriptComponentSyntax.leftSquare: - return "leftSquare" - case \KeyPathSubscriptComponentSyntax.unexpectedBetweenLeftSquareAndArguments: - return "unexpectedBetweenLeftSquareAndArguments" - case \KeyPathSubscriptComponentSyntax.arguments: - return "arguments" - case \KeyPathSubscriptComponentSyntax.unexpectedBetweenArgumentsAndRightSquare: - return "unexpectedBetweenArgumentsAndRightSquare" - case \KeyPathSubscriptComponentSyntax.rightSquare: - return "rightSquare" - case \KeyPathSubscriptComponentSyntax.unexpectedAfterRightSquare: - return "unexpectedAfterRightSquare" - case \LabeledExprSyntax.unexpectedBeforeLabel: - return "unexpectedBeforeLabel" - case \LabeledExprSyntax.label: - return "label" - case \LabeledExprSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \LabeledExprSyntax.colon: - return "colon" - case \LabeledExprSyntax.unexpectedBetweenColonAndExpression: - return "unexpectedBetweenColonAndExpression" - case \LabeledExprSyntax.expression: - return "expression" - case \LabeledExprSyntax.unexpectedBetweenExpressionAndTrailingComma: - return "unexpectedBetweenExpressionAndTrailingComma" - case \LabeledExprSyntax.trailingComma: - return "trailingComma" - case \LabeledExprSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \LabeledSpecializeArgumentSyntax.unexpectedBeforeLabel: - return "unexpectedBeforeLabel" - case \LabeledSpecializeArgumentSyntax.label: - return "label" - case \LabeledSpecializeArgumentSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \LabeledSpecializeArgumentSyntax.colon: - return "colon" - case \LabeledSpecializeArgumentSyntax.unexpectedBetweenColonAndValue: - return "unexpectedBetweenColonAndValue" - case \LabeledSpecializeArgumentSyntax.value: - return "value" - case \LabeledSpecializeArgumentSyntax.unexpectedBetweenValueAndTrailingComma: - return "unexpectedBetweenValueAndTrailingComma" - case \LabeledSpecializeArgumentSyntax.trailingComma: - return "trailingComma" - case \LabeledSpecializeArgumentSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \LabeledStmtSyntax.unexpectedBeforeLabel: - return "unexpectedBeforeLabel" - case \LabeledStmtSyntax.label: - return "label" - case \LabeledStmtSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \LabeledStmtSyntax.colon: - return "colon" - case \LabeledStmtSyntax.unexpectedBetweenColonAndStatement: - return "unexpectedBetweenColonAndStatement" - case \LabeledStmtSyntax.statement: - return "statement" - case \LabeledStmtSyntax.unexpectedAfterStatement: - return "unexpectedAfterStatement" - case \LayoutRequirementSyntax.unexpectedBeforeType: - return "unexpectedBeforeType" - case \LayoutRequirementSyntax.type: - return "type" - case \LayoutRequirementSyntax.unexpectedBetweenTypeAndColon: - return "unexpectedBetweenTypeAndColon" - case \LayoutRequirementSyntax.colon: - return "colon" - case \LayoutRequirementSyntax.unexpectedBetweenColonAndLayoutSpecifier: - return "unexpectedBetweenColonAndLayoutSpecifier" - case \LayoutRequirementSyntax.layoutSpecifier: - return "layoutSpecifier" - case \LayoutRequirementSyntax.unexpectedBetweenLayoutSpecifierAndLeftParen: - return "unexpectedBetweenLayoutSpecifierAndLeftParen" - case \LayoutRequirementSyntax.leftParen: - return "leftParen" - case \LayoutRequirementSyntax.unexpectedBetweenLeftParenAndSize: - return "unexpectedBetweenLeftParenAndSize" - case \LayoutRequirementSyntax.size: - return "size" - case \LayoutRequirementSyntax.unexpectedBetweenSizeAndComma: - return "unexpectedBetweenSizeAndComma" - case \LayoutRequirementSyntax.comma: - return "comma" - case \LayoutRequirementSyntax.unexpectedBetweenCommaAndAlignment: - return "unexpectedBetweenCommaAndAlignment" - case \LayoutRequirementSyntax.alignment: - return "alignment" - case \LayoutRequirementSyntax.unexpectedBetweenAlignmentAndRightParen: - return "unexpectedBetweenAlignmentAndRightParen" - case \LayoutRequirementSyntax.rightParen: - return "rightParen" - case \LayoutRequirementSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \LifetimeSpecifierArgumentSyntax.unexpectedBeforeParameter: - return "unexpectedBeforeParameter" - case \LifetimeSpecifierArgumentSyntax.parameter: - return "parameter" - case \LifetimeSpecifierArgumentSyntax.unexpectedBetweenParameterAndTrailingComma: - return "unexpectedBetweenParameterAndTrailingComma" - case \LifetimeSpecifierArgumentSyntax.trailingComma: - return "trailingComma" - case \LifetimeSpecifierArgumentSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \LifetimeTypeSpecifierSyntax.unexpectedBeforeDependsOnKeyword: - return "unexpectedBeforeDependsOnKeyword" - case \LifetimeTypeSpecifierSyntax.dependsOnKeyword: - return "dependsOnKeyword" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenDependsOnKeywordAndLeftParen: - return "unexpectedBetweenDependsOnKeywordAndLeftParen" - case \LifetimeTypeSpecifierSyntax.leftParen: - return "leftParen" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenLeftParenAndScopedKeyword: - return "unexpectedBetweenLeftParenAndScopedKeyword" - case \LifetimeTypeSpecifierSyntax.scopedKeyword: - return "scopedKeyword" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenScopedKeywordAndArguments: - return "unexpectedBetweenScopedKeywordAndArguments" - case \LifetimeTypeSpecifierSyntax.arguments: - return "arguments" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \LifetimeTypeSpecifierSyntax.rightParen: - return "rightParen" - case \LifetimeTypeSpecifierSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \MacroDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \MacroDeclSyntax.attributes: - return "attributes" - case \MacroDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \MacroDeclSyntax.modifiers: - return "modifiers" - case \MacroDeclSyntax.unexpectedBetweenModifiersAndMacroKeyword: - return "unexpectedBetweenModifiersAndMacroKeyword" - case \MacroDeclSyntax.macroKeyword: - return "macroKeyword" - case \MacroDeclSyntax.unexpectedBetweenMacroKeywordAndName: - return "unexpectedBetweenMacroKeywordAndName" - case \MacroDeclSyntax.name: - return "name" - case \MacroDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: - return "unexpectedBetweenNameAndGenericParameterClause" - case \MacroDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \MacroDeclSyntax.unexpectedBetweenGenericParameterClauseAndSignature: - return "unexpectedBetweenGenericParameterClauseAndSignature" - case \MacroDeclSyntax.signature: - return "signature" - case \MacroDeclSyntax.unexpectedBetweenSignatureAndDefinition: - return "unexpectedBetweenSignatureAndDefinition" - case \MacroDeclSyntax.definition: - return "definition" - case \MacroDeclSyntax.unexpectedBetweenDefinitionAndGenericWhereClause: - return "unexpectedBetweenDefinitionAndGenericWhereClause" - case \MacroDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \MacroDeclSyntax.unexpectedAfterGenericWhereClause: - return "unexpectedAfterGenericWhereClause" - case \MacroExpansionDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \MacroExpansionDeclSyntax.attributes: - return "attributes" - case \MacroExpansionDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \MacroExpansionDeclSyntax.modifiers: - return "modifiers" - case \MacroExpansionDeclSyntax.unexpectedBetweenModifiersAndPound: - return "unexpectedBetweenModifiersAndPound" - case \MacroExpansionDeclSyntax.pound: - return "pound" - case \MacroExpansionDeclSyntax.unexpectedBetweenPoundAndMacroName: - return "unexpectedBetweenPoundAndMacroName" - case \MacroExpansionDeclSyntax.macroName: - return "macroName" - case \MacroExpansionDeclSyntax.unexpectedBetweenMacroNameAndGenericArgumentClause: - return "unexpectedBetweenMacroNameAndGenericArgumentClause" - case \MacroExpansionDeclSyntax.genericArgumentClause: - return "genericArgumentClause" - case \MacroExpansionDeclSyntax.unexpectedBetweenGenericArgumentClauseAndLeftParen: - return "unexpectedBetweenGenericArgumentClauseAndLeftParen" - case \MacroExpansionDeclSyntax.leftParen: - return "leftParen" - case \MacroExpansionDeclSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" - case \MacroExpansionDeclSyntax.arguments: - return "arguments" - case \MacroExpansionDeclSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \MacroExpansionDeclSyntax.rightParen: - return "rightParen" - case \MacroExpansionDeclSyntax.unexpectedBetweenRightParenAndTrailingClosure: - return "unexpectedBetweenRightParenAndTrailingClosure" - case \MacroExpansionDeclSyntax.trailingClosure: - return "trailingClosure" - case \MacroExpansionDeclSyntax.unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: - return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" - case \MacroExpansionDeclSyntax.additionalTrailingClosures: - return "additionalTrailingClosures" - case \MacroExpansionDeclSyntax.unexpectedAfterAdditionalTrailingClosures: - return "unexpectedAfterAdditionalTrailingClosures" - case \MacroExpansionExprSyntax.unexpectedBeforePound: - return "unexpectedBeforePound" - case \MacroExpansionExprSyntax.pound: - return "pound" - case \MacroExpansionExprSyntax.unexpectedBetweenPoundAndMacroName: - return "unexpectedBetweenPoundAndMacroName" - case \MacroExpansionExprSyntax.macroName: - return "macroName" - case \MacroExpansionExprSyntax.unexpectedBetweenMacroNameAndGenericArgumentClause: - return "unexpectedBetweenMacroNameAndGenericArgumentClause" - case \MacroExpansionExprSyntax.genericArgumentClause: - return "genericArgumentClause" - case \MacroExpansionExprSyntax.unexpectedBetweenGenericArgumentClauseAndLeftParen: - return "unexpectedBetweenGenericArgumentClauseAndLeftParen" - case \MacroExpansionExprSyntax.leftParen: - return "leftParen" - case \MacroExpansionExprSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" - case \MacroExpansionExprSyntax.arguments: - return "arguments" - case \MacroExpansionExprSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \MacroExpansionExprSyntax.rightParen: - return "rightParen" - case \MacroExpansionExprSyntax.unexpectedBetweenRightParenAndTrailingClosure: - return "unexpectedBetweenRightParenAndTrailingClosure" - case \MacroExpansionExprSyntax.trailingClosure: - return "trailingClosure" - case \MacroExpansionExprSyntax.unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: - return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" - case \MacroExpansionExprSyntax.additionalTrailingClosures: - return "additionalTrailingClosures" - case \MacroExpansionExprSyntax.unexpectedAfterAdditionalTrailingClosures: - return "unexpectedAfterAdditionalTrailingClosures" - case \MatchingPatternConditionSyntax.unexpectedBeforeCaseKeyword: - return "unexpectedBeforeCaseKeyword" - case \MatchingPatternConditionSyntax.caseKeyword: - return "caseKeyword" - case \MatchingPatternConditionSyntax.unexpectedBetweenCaseKeywordAndPattern: - return "unexpectedBetweenCaseKeywordAndPattern" - case \MatchingPatternConditionSyntax.pattern: - return "pattern" - case \MatchingPatternConditionSyntax.unexpectedBetweenPatternAndTypeAnnotation: - return "unexpectedBetweenPatternAndTypeAnnotation" - case \MatchingPatternConditionSyntax.typeAnnotation: - return "typeAnnotation" - case \MatchingPatternConditionSyntax.unexpectedBetweenTypeAnnotationAndInitializer: - return "unexpectedBetweenTypeAnnotationAndInitializer" - case \MatchingPatternConditionSyntax.initializer: - return "initializer" - case \MatchingPatternConditionSyntax.unexpectedAfterInitializer: - return "unexpectedAfterInitializer" - case \MemberAccessExprSyntax.unexpectedBeforeBase: - return "unexpectedBeforeBase" - case \MemberAccessExprSyntax.base: - return "base" - case \MemberAccessExprSyntax.unexpectedBetweenBaseAndPeriod: - return "unexpectedBetweenBaseAndPeriod" - case \MemberAccessExprSyntax.period: - return "period" - case \MemberAccessExprSyntax.unexpectedBetweenPeriodAndDeclName: - return "unexpectedBetweenPeriodAndDeclName" - case \MemberAccessExprSyntax.declName: - return "declName" - case \MemberAccessExprSyntax.unexpectedAfterDeclName: - return "unexpectedAfterDeclName" - case \MemberBlockItemSyntax.unexpectedBeforeDecl: - return "unexpectedBeforeDecl" - case \MemberBlockItemSyntax.decl: - return "decl" - case \MemberBlockItemSyntax.unexpectedBetweenDeclAndSemicolon: - return "unexpectedBetweenDeclAndSemicolon" - case \MemberBlockItemSyntax.semicolon: - return "semicolon" - case \MemberBlockItemSyntax.unexpectedAfterSemicolon: - return "unexpectedAfterSemicolon" - case \MemberBlockSyntax.unexpectedBeforeLeftBrace: - return "unexpectedBeforeLeftBrace" - case \MemberBlockSyntax.leftBrace: - return "leftBrace" - case \MemberBlockSyntax.unexpectedBetweenLeftBraceAndMembers: - return "unexpectedBetweenLeftBraceAndMembers" - case \MemberBlockSyntax.members: - return "members" - case \MemberBlockSyntax.unexpectedBetweenMembersAndRightBrace: - return "unexpectedBetweenMembersAndRightBrace" - case \MemberBlockSyntax.rightBrace: - return "rightBrace" - case \MemberBlockSyntax.unexpectedAfterRightBrace: - return "unexpectedAfterRightBrace" - case \MemberTypeSyntax.unexpectedBeforeBaseType: - return "unexpectedBeforeBaseType" - case \MemberTypeSyntax.baseType: - return "baseType" - case \MemberTypeSyntax.unexpectedBetweenBaseTypeAndPeriod: - return "unexpectedBetweenBaseTypeAndPeriod" - case \MemberTypeSyntax.period: - return "period" - case \MemberTypeSyntax.unexpectedBetweenPeriodAndName: - return "unexpectedBetweenPeriodAndName" - case \MemberTypeSyntax.name: - return "name" - case \MemberTypeSyntax.unexpectedBetweenNameAndGenericArgumentClause: - return "unexpectedBetweenNameAndGenericArgumentClause" - case \MemberTypeSyntax.genericArgumentClause: - return "genericArgumentClause" - case \MemberTypeSyntax.unexpectedAfterGenericArgumentClause: - return "unexpectedAfterGenericArgumentClause" - case \MetatypeTypeSyntax.unexpectedBeforeBaseType: - return "unexpectedBeforeBaseType" - case \MetatypeTypeSyntax.baseType: - return "baseType" - case \MetatypeTypeSyntax.unexpectedBetweenBaseTypeAndPeriod: - return "unexpectedBetweenBaseTypeAndPeriod" - case \MetatypeTypeSyntax.period: - return "period" - case \MetatypeTypeSyntax.unexpectedBetweenPeriodAndMetatypeSpecifier: - return "unexpectedBetweenPeriodAndMetatypeSpecifier" - case \MetatypeTypeSyntax.metatypeSpecifier: - return "metatypeSpecifier" - case \MetatypeTypeSyntax.unexpectedAfterMetatypeSpecifier: - return "unexpectedAfterMetatypeSpecifier" - case \MissingDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \MissingDeclSyntax.attributes: - return "attributes" - case \MissingDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \MissingDeclSyntax.modifiers: - return "modifiers" - case \MissingDeclSyntax.unexpectedBetweenModifiersAndPlaceholder: - return "unexpectedBetweenModifiersAndPlaceholder" - case \MissingDeclSyntax.placeholder: - return "placeholder" - case \MissingDeclSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \MissingExprSyntax.unexpectedBeforePlaceholder: - return "unexpectedBeforePlaceholder" - case \MissingExprSyntax.placeholder: - return "placeholder" - case \MissingExprSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \MissingPatternSyntax.unexpectedBeforePlaceholder: - return "unexpectedBeforePlaceholder" - case \MissingPatternSyntax.placeholder: - return "placeholder" - case \MissingPatternSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \MissingStmtSyntax.unexpectedBeforePlaceholder: - return "unexpectedBeforePlaceholder" - case \MissingStmtSyntax.placeholder: - return "placeholder" - case \MissingStmtSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \MissingSyntax.unexpectedBeforePlaceholder: - return "unexpectedBeforePlaceholder" - case \MissingSyntax.placeholder: - return "placeholder" - case \MissingSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \MissingTypeSyntax.unexpectedBeforePlaceholder: - return "unexpectedBeforePlaceholder" - case \MissingTypeSyntax.placeholder: - return "placeholder" - case \MissingTypeSyntax.unexpectedAfterPlaceholder: - return "unexpectedAfterPlaceholder" - case \MultipleTrailingClosureElementSyntax.unexpectedBeforeLabel: - return "unexpectedBeforeLabel" - case \MultipleTrailingClosureElementSyntax.label: - return "label" - case \MultipleTrailingClosureElementSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \MultipleTrailingClosureElementSyntax.colon: - return "colon" - case \MultipleTrailingClosureElementSyntax.unexpectedBetweenColonAndClosure: - return "unexpectedBetweenColonAndClosure" - case \MultipleTrailingClosureElementSyntax.closure: - return "closure" - case \MultipleTrailingClosureElementSyntax.unexpectedAfterClosure: - return "unexpectedAfterClosure" - case \NamedOpaqueReturnTypeSyntax.unexpectedBeforeGenericParameterClause: - return "unexpectedBeforeGenericParameterClause" - case \NamedOpaqueReturnTypeSyntax.genericParameterClause: - return "genericParameterClause" - case \NamedOpaqueReturnTypeSyntax.unexpectedBetweenGenericParameterClauseAndType: - return "unexpectedBetweenGenericParameterClauseAndType" - case \NamedOpaqueReturnTypeSyntax.type: - return "type" - case \NamedOpaqueReturnTypeSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \NilLiteralExprSyntax.unexpectedBeforeNilKeyword: - return "unexpectedBeforeNilKeyword" - case \NilLiteralExprSyntax.nilKeyword: - return "nilKeyword" - case \NilLiteralExprSyntax.unexpectedAfterNilKeyword: - return "unexpectedAfterNilKeyword" - case \ObjCSelectorPieceSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \ObjCSelectorPieceSyntax.name: - return "name" - case \ObjCSelectorPieceSyntax.unexpectedBetweenNameAndColon: - return "unexpectedBetweenNameAndColon" - case \ObjCSelectorPieceSyntax.colon: - return "colon" - case \ObjCSelectorPieceSyntax.unexpectedAfterColon: - return "unexpectedAfterColon" - case \OpaqueReturnTypeOfAttributeArgumentsSyntax.unexpectedBeforeMangledName: - return "unexpectedBeforeMangledName" - case \OpaqueReturnTypeOfAttributeArgumentsSyntax.mangledName: - return "mangledName" - case \OpaqueReturnTypeOfAttributeArgumentsSyntax.unexpectedBetweenMangledNameAndComma: - return "unexpectedBetweenMangledNameAndComma" - case \OpaqueReturnTypeOfAttributeArgumentsSyntax.comma: - return "comma" - case \OpaqueReturnTypeOfAttributeArgumentsSyntax.unexpectedBetweenCommaAndOrdinal: - return "unexpectedBetweenCommaAndOrdinal" - case \OpaqueReturnTypeOfAttributeArgumentsSyntax.ordinal: - return "ordinal" - case \OpaqueReturnTypeOfAttributeArgumentsSyntax.unexpectedAfterOrdinal: - return "unexpectedAfterOrdinal" - case \OperatorDeclSyntax.unexpectedBeforeFixitySpecifier: - return "unexpectedBeforeFixitySpecifier" - case \OperatorDeclSyntax.fixitySpecifier: - return "fixitySpecifier" - case \OperatorDeclSyntax.unexpectedBetweenFixitySpecifierAndOperatorKeyword: - return "unexpectedBetweenFixitySpecifierAndOperatorKeyword" - case \OperatorDeclSyntax.operatorKeyword: - return "operatorKeyword" - case \OperatorDeclSyntax.unexpectedBetweenOperatorKeywordAndName: - return "unexpectedBetweenOperatorKeywordAndName" - case \OperatorDeclSyntax.name: - return "name" - case \OperatorDeclSyntax.unexpectedBetweenNameAndOperatorPrecedenceAndTypes: - return "unexpectedBetweenNameAndOperatorPrecedenceAndTypes" - case \OperatorDeclSyntax.operatorPrecedenceAndTypes: - return "operatorPrecedenceAndTypes" - case \OperatorDeclSyntax.unexpectedAfterOperatorPrecedenceAndTypes: - return "unexpectedAfterOperatorPrecedenceAndTypes" - case \OperatorPrecedenceAndTypesSyntax.unexpectedBeforeColon: - return "unexpectedBeforeColon" - case \OperatorPrecedenceAndTypesSyntax.colon: - return "colon" - case \OperatorPrecedenceAndTypesSyntax.unexpectedBetweenColonAndPrecedenceGroup: - return "unexpectedBetweenColonAndPrecedenceGroup" - case \OperatorPrecedenceAndTypesSyntax.precedenceGroup: - return "precedenceGroup" - case \OperatorPrecedenceAndTypesSyntax.unexpectedBetweenPrecedenceGroupAndDesignatedTypes: - return "unexpectedBetweenPrecedenceGroupAndDesignatedTypes" - case \OperatorPrecedenceAndTypesSyntax.designatedTypes: - return "designatedTypes" - case \OperatorPrecedenceAndTypesSyntax.unexpectedAfterDesignatedTypes: - return "unexpectedAfterDesignatedTypes" - case \OptionalBindingConditionSyntax.unexpectedBeforeBindingSpecifier: - return "unexpectedBeforeBindingSpecifier" - case \OptionalBindingConditionSyntax.bindingSpecifier: - return "bindingSpecifier" - case \OptionalBindingConditionSyntax.unexpectedBetweenBindingSpecifierAndPattern: - return "unexpectedBetweenBindingSpecifierAndPattern" - case \OptionalBindingConditionSyntax.pattern: - return "pattern" - case \OptionalBindingConditionSyntax.unexpectedBetweenPatternAndTypeAnnotation: - return "unexpectedBetweenPatternAndTypeAnnotation" - case \OptionalBindingConditionSyntax.typeAnnotation: - return "typeAnnotation" - case \OptionalBindingConditionSyntax.unexpectedBetweenTypeAnnotationAndInitializer: - return "unexpectedBetweenTypeAnnotationAndInitializer" - case \OptionalBindingConditionSyntax.initializer: - return "initializer" - case \OptionalBindingConditionSyntax.unexpectedAfterInitializer: - return "unexpectedAfterInitializer" - case \OptionalChainingExprSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \OptionalChainingExprSyntax.expression: - return "expression" - case \OptionalChainingExprSyntax.unexpectedBetweenExpressionAndQuestionMark: - return "unexpectedBetweenExpressionAndQuestionMark" - case \OptionalChainingExprSyntax.questionMark: - return "questionMark" - case \OptionalChainingExprSyntax.unexpectedAfterQuestionMark: - return "unexpectedAfterQuestionMark" - case \OptionalTypeSyntax.unexpectedBeforeWrappedType: - return "unexpectedBeforeWrappedType" - case \OptionalTypeSyntax.wrappedType: - return "wrappedType" - case \OptionalTypeSyntax.unexpectedBetweenWrappedTypeAndQuestionMark: - return "unexpectedBetweenWrappedTypeAndQuestionMark" - case \OptionalTypeSyntax.questionMark: - return "questionMark" - case \OptionalTypeSyntax.unexpectedAfterQuestionMark: - return "unexpectedAfterQuestionMark" - case \OriginallyDefinedInAttributeArgumentsSyntax.unexpectedBeforeModuleLabel: - return "unexpectedBeforeModuleLabel" - case \OriginallyDefinedInAttributeArgumentsSyntax.moduleLabel: - return "moduleLabel" - case \OriginallyDefinedInAttributeArgumentsSyntax.unexpectedBetweenModuleLabelAndColon: - return "unexpectedBetweenModuleLabelAndColon" - case \OriginallyDefinedInAttributeArgumentsSyntax.colon: - return "colon" - case \OriginallyDefinedInAttributeArgumentsSyntax.unexpectedBetweenColonAndModuleName: - return "unexpectedBetweenColonAndModuleName" - case \OriginallyDefinedInAttributeArgumentsSyntax.moduleName: - return "moduleName" - case \OriginallyDefinedInAttributeArgumentsSyntax.unexpectedBetweenModuleNameAndComma: - return "unexpectedBetweenModuleNameAndComma" - case \OriginallyDefinedInAttributeArgumentsSyntax.comma: - return "comma" - case \OriginallyDefinedInAttributeArgumentsSyntax.unexpectedBetweenCommaAndPlatforms: - return "unexpectedBetweenCommaAndPlatforms" - case \OriginallyDefinedInAttributeArgumentsSyntax.platforms: - return "platforms" - case \OriginallyDefinedInAttributeArgumentsSyntax.unexpectedAfterPlatforms: - return "unexpectedAfterPlatforms" - case \PackElementExprSyntax.unexpectedBeforeEachKeyword: - return "unexpectedBeforeEachKeyword" - case \PackElementExprSyntax.eachKeyword: - return "eachKeyword" - case \PackElementExprSyntax.unexpectedBetweenEachKeywordAndPack: - return "unexpectedBetweenEachKeywordAndPack" - case \PackElementExprSyntax.pack: - return "pack" - case \PackElementExprSyntax.unexpectedAfterPack: - return "unexpectedAfterPack" - case \PackElementTypeSyntax.unexpectedBeforeEachKeyword: - return "unexpectedBeforeEachKeyword" - case \PackElementTypeSyntax.eachKeyword: - return "eachKeyword" - case \PackElementTypeSyntax.unexpectedBetweenEachKeywordAndPack: - return "unexpectedBetweenEachKeywordAndPack" - case \PackElementTypeSyntax.pack: - return "pack" - case \PackElementTypeSyntax.unexpectedAfterPack: - return "unexpectedAfterPack" - case \PackExpansionExprSyntax.unexpectedBeforeRepeatKeyword: - return "unexpectedBeforeRepeatKeyword" - case \PackExpansionExprSyntax.repeatKeyword: - return "repeatKeyword" - case \PackExpansionExprSyntax.unexpectedBetweenRepeatKeywordAndRepetitionPattern: - return "unexpectedBetweenRepeatKeywordAndRepetitionPattern" - case \PackExpansionExprSyntax.repetitionPattern: - return "repetitionPattern" - case \PackExpansionExprSyntax.unexpectedAfterRepetitionPattern: - return "unexpectedAfterRepetitionPattern" - case \PackExpansionTypeSyntax.unexpectedBeforeRepeatKeyword: - return "unexpectedBeforeRepeatKeyword" - case \PackExpansionTypeSyntax.repeatKeyword: - return "repeatKeyword" - case \PackExpansionTypeSyntax.unexpectedBetweenRepeatKeywordAndRepetitionPattern: - return "unexpectedBetweenRepeatKeywordAndRepetitionPattern" - case \PackExpansionTypeSyntax.repetitionPattern: - return "repetitionPattern" - case \PackExpansionTypeSyntax.unexpectedAfterRepetitionPattern: - return "unexpectedAfterRepetitionPattern" - case \PatternBindingSyntax.unexpectedBeforePattern: - return "unexpectedBeforePattern" - case \PatternBindingSyntax.pattern: - return "pattern" - case \PatternBindingSyntax.unexpectedBetweenPatternAndTypeAnnotation: - return "unexpectedBetweenPatternAndTypeAnnotation" - case \PatternBindingSyntax.typeAnnotation: - return "typeAnnotation" - case \PatternBindingSyntax.unexpectedBetweenTypeAnnotationAndInitializer: - return "unexpectedBetweenTypeAnnotationAndInitializer" - case \PatternBindingSyntax.initializer: - return "initializer" - case \PatternBindingSyntax.unexpectedBetweenInitializerAndAccessorBlock: - return "unexpectedBetweenInitializerAndAccessorBlock" - case \PatternBindingSyntax.accessorBlock: - return "accessorBlock" - case \PatternBindingSyntax.unexpectedBetweenAccessorBlockAndTrailingComma: - return "unexpectedBetweenAccessorBlockAndTrailingComma" - case \PatternBindingSyntax.trailingComma: - return "trailingComma" - case \PatternBindingSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \PatternExprSyntax.unexpectedBeforePattern: - return "unexpectedBeforePattern" - case \PatternExprSyntax.pattern: - return "pattern" - case \PatternExprSyntax.unexpectedAfterPattern: - return "unexpectedAfterPattern" - case \PlatformVersionItemSyntax.unexpectedBeforePlatformVersion: - return "unexpectedBeforePlatformVersion" - case \PlatformVersionItemSyntax.platformVersion: - return "platformVersion" - case \PlatformVersionItemSyntax.unexpectedBetweenPlatformVersionAndTrailingComma: - return "unexpectedBetweenPlatformVersionAndTrailingComma" - case \PlatformVersionItemSyntax.trailingComma: - return "trailingComma" - case \PlatformVersionItemSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \PlatformVersionSyntax.unexpectedBeforePlatform: - return "unexpectedBeforePlatform" - case \PlatformVersionSyntax.platform: - return "platform" - case \PlatformVersionSyntax.unexpectedBetweenPlatformAndVersion: - return "unexpectedBetweenPlatformAndVersion" - case \PlatformVersionSyntax.version: - return "version" - case \PlatformVersionSyntax.unexpectedAfterVersion: - return "unexpectedAfterVersion" - case \PostfixIfConfigExprSyntax.unexpectedBeforeBase: - return "unexpectedBeforeBase" - case \PostfixIfConfigExprSyntax.base: - return "base" - case \PostfixIfConfigExprSyntax.unexpectedBetweenBaseAndConfig: - return "unexpectedBetweenBaseAndConfig" - case \PostfixIfConfigExprSyntax.config: - return "config" - case \PostfixIfConfigExprSyntax.unexpectedAfterConfig: - return "unexpectedAfterConfig" - case \PostfixOperatorExprSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \PostfixOperatorExprSyntax.expression: - return "expression" - case \PostfixOperatorExprSyntax.unexpectedBetweenExpressionAndOperator: - return "unexpectedBetweenExpressionAndOperator" - case \PostfixOperatorExprSyntax.operator: - return "operator" - case \PostfixOperatorExprSyntax.unexpectedAfterOperator: - return "unexpectedAfterOperator" - case \PoundSourceLocationArgumentsSyntax.unexpectedBeforeFileLabel: - return "unexpectedBeforeFileLabel" - case \PoundSourceLocationArgumentsSyntax.fileLabel: - return "fileLabel" - case \PoundSourceLocationArgumentsSyntax.unexpectedBetweenFileLabelAndFileColon: - return "unexpectedBetweenFileLabelAndFileColon" - case \PoundSourceLocationArgumentsSyntax.fileColon: - return "fileColon" - case \PoundSourceLocationArgumentsSyntax.unexpectedBetweenFileColonAndFileName: - return "unexpectedBetweenFileColonAndFileName" - case \PoundSourceLocationArgumentsSyntax.fileName: - return "fileName" - case \PoundSourceLocationArgumentsSyntax.unexpectedBetweenFileNameAndComma: - return "unexpectedBetweenFileNameAndComma" - case \PoundSourceLocationArgumentsSyntax.comma: - return "comma" - case \PoundSourceLocationArgumentsSyntax.unexpectedBetweenCommaAndLineLabel: - return "unexpectedBetweenCommaAndLineLabel" - case \PoundSourceLocationArgumentsSyntax.lineLabel: - return "lineLabel" - case \PoundSourceLocationArgumentsSyntax.unexpectedBetweenLineLabelAndLineColon: - return "unexpectedBetweenLineLabelAndLineColon" - case \PoundSourceLocationArgumentsSyntax.lineColon: - return "lineColon" - case \PoundSourceLocationArgumentsSyntax.unexpectedBetweenLineColonAndLineNumber: - return "unexpectedBetweenLineColonAndLineNumber" - case \PoundSourceLocationArgumentsSyntax.lineNumber: - return "lineNumber" - case \PoundSourceLocationArgumentsSyntax.unexpectedAfterLineNumber: - return "unexpectedAfterLineNumber" - case \PoundSourceLocationSyntax.unexpectedBeforePoundSourceLocation: - return "unexpectedBeforePoundSourceLocation" - case \PoundSourceLocationSyntax.poundSourceLocation: - return "poundSourceLocation" - case \PoundSourceLocationSyntax.unexpectedBetweenPoundSourceLocationAndLeftParen: - return "unexpectedBetweenPoundSourceLocationAndLeftParen" - case \PoundSourceLocationSyntax.leftParen: - return "leftParen" - case \PoundSourceLocationSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" - case \PoundSourceLocationSyntax.arguments: - return "arguments" - case \PoundSourceLocationSyntax.unexpectedBetweenArgumentsAndRightParen: - return "unexpectedBetweenArgumentsAndRightParen" - case \PoundSourceLocationSyntax.rightParen: - return "rightParen" - case \PoundSourceLocationSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \PrecedenceGroupAssignmentSyntax.unexpectedBeforeAssignmentLabel: - return "unexpectedBeforeAssignmentLabel" - case \PrecedenceGroupAssignmentSyntax.assignmentLabel: - return "assignmentLabel" - case \PrecedenceGroupAssignmentSyntax.unexpectedBetweenAssignmentLabelAndColon: - return "unexpectedBetweenAssignmentLabelAndColon" - case \PrecedenceGroupAssignmentSyntax.colon: - return "colon" - case \PrecedenceGroupAssignmentSyntax.unexpectedBetweenColonAndValue: - return "unexpectedBetweenColonAndValue" - case \PrecedenceGroupAssignmentSyntax.value: - return "value" - case \PrecedenceGroupAssignmentSyntax.unexpectedAfterValue: - return "unexpectedAfterValue" - case \PrecedenceGroupAssociativitySyntax.unexpectedBeforeAssociativityLabel: - return "unexpectedBeforeAssociativityLabel" - case \PrecedenceGroupAssociativitySyntax.associativityLabel: - return "associativityLabel" - case \PrecedenceGroupAssociativitySyntax.unexpectedBetweenAssociativityLabelAndColon: - return "unexpectedBetweenAssociativityLabelAndColon" - case \PrecedenceGroupAssociativitySyntax.colon: - return "colon" - case \PrecedenceGroupAssociativitySyntax.unexpectedBetweenColonAndValue: - return "unexpectedBetweenColonAndValue" - case \PrecedenceGroupAssociativitySyntax.value: - return "value" - case \PrecedenceGroupAssociativitySyntax.unexpectedAfterValue: - return "unexpectedAfterValue" - case \PrecedenceGroupDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \PrecedenceGroupDeclSyntax.attributes: - return "attributes" - case \PrecedenceGroupDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \PrecedenceGroupDeclSyntax.modifiers: - return "modifiers" - case \PrecedenceGroupDeclSyntax.unexpectedBetweenModifiersAndPrecedencegroupKeyword: - return "unexpectedBetweenModifiersAndPrecedencegroupKeyword" - case \PrecedenceGroupDeclSyntax.precedencegroupKeyword: - return "precedencegroupKeyword" - case \PrecedenceGroupDeclSyntax.unexpectedBetweenPrecedencegroupKeywordAndName: - return "unexpectedBetweenPrecedencegroupKeywordAndName" - case \PrecedenceGroupDeclSyntax.name: - return "name" - case \PrecedenceGroupDeclSyntax.unexpectedBetweenNameAndLeftBrace: - return "unexpectedBetweenNameAndLeftBrace" - case \PrecedenceGroupDeclSyntax.leftBrace: - return "leftBrace" - case \PrecedenceGroupDeclSyntax.unexpectedBetweenLeftBraceAndGroupAttributes: - return "unexpectedBetweenLeftBraceAndGroupAttributes" - case \PrecedenceGroupDeclSyntax.groupAttributes: - return "groupAttributes" - case \PrecedenceGroupDeclSyntax.unexpectedBetweenGroupAttributesAndRightBrace: - return "unexpectedBetweenGroupAttributesAndRightBrace" - case \PrecedenceGroupDeclSyntax.rightBrace: - return "rightBrace" - case \PrecedenceGroupDeclSyntax.unexpectedAfterRightBrace: - return "unexpectedAfterRightBrace" - case \PrecedenceGroupNameSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \PrecedenceGroupNameSyntax.name: - return "name" - case \PrecedenceGroupNameSyntax.unexpectedBetweenNameAndTrailingComma: - return "unexpectedBetweenNameAndTrailingComma" - case \PrecedenceGroupNameSyntax.trailingComma: - return "trailingComma" - case \PrecedenceGroupNameSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \PrecedenceGroupRelationSyntax.unexpectedBeforeHigherThanOrLowerThanLabel: - return "unexpectedBeforeHigherThanOrLowerThanLabel" - case \PrecedenceGroupRelationSyntax.higherThanOrLowerThanLabel: - return "higherThanOrLowerThanLabel" - case \PrecedenceGroupRelationSyntax.unexpectedBetweenHigherThanOrLowerThanLabelAndColon: - return "unexpectedBetweenHigherThanOrLowerThanLabelAndColon" - case \PrecedenceGroupRelationSyntax.colon: - return "colon" - case \PrecedenceGroupRelationSyntax.unexpectedBetweenColonAndPrecedenceGroups: - return "unexpectedBetweenColonAndPrecedenceGroups" - case \PrecedenceGroupRelationSyntax.precedenceGroups: - return "precedenceGroups" - case \PrecedenceGroupRelationSyntax.unexpectedAfterPrecedenceGroups: - return "unexpectedAfterPrecedenceGroups" - case \PrefixOperatorExprSyntax.unexpectedBeforeOperator: - return "unexpectedBeforeOperator" - case \PrefixOperatorExprSyntax.operator: - return "operator" - case \PrefixOperatorExprSyntax.unexpectedBetweenOperatorAndExpression: - return "unexpectedBetweenOperatorAndExpression" - case \PrefixOperatorExprSyntax.expression: - return "expression" - case \PrefixOperatorExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \PrimaryAssociatedTypeClauseSyntax.unexpectedBeforeLeftAngle: - return "unexpectedBeforeLeftAngle" - case \PrimaryAssociatedTypeClauseSyntax.leftAngle: - return "leftAngle" - case \PrimaryAssociatedTypeClauseSyntax.unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes: - return "unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes" - case \PrimaryAssociatedTypeClauseSyntax.primaryAssociatedTypes: - return "primaryAssociatedTypes" - case \PrimaryAssociatedTypeClauseSyntax.unexpectedBetweenPrimaryAssociatedTypesAndRightAngle: - return "unexpectedBetweenPrimaryAssociatedTypesAndRightAngle" - case \PrimaryAssociatedTypeClauseSyntax.rightAngle: - return "rightAngle" - case \PrimaryAssociatedTypeClauseSyntax.unexpectedAfterRightAngle: - return "unexpectedAfterRightAngle" - case \PrimaryAssociatedTypeSyntax.unexpectedBeforeName: - return "unexpectedBeforeName" - case \PrimaryAssociatedTypeSyntax.name: - return "name" - case \PrimaryAssociatedTypeSyntax.unexpectedBetweenNameAndTrailingComma: - return "unexpectedBetweenNameAndTrailingComma" - case \PrimaryAssociatedTypeSyntax.trailingComma: - return "trailingComma" - case \PrimaryAssociatedTypeSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \ProtocolDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \ProtocolDeclSyntax.attributes: - return "attributes" - case \ProtocolDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \ProtocolDeclSyntax.modifiers: - return "modifiers" - case \ProtocolDeclSyntax.unexpectedBetweenModifiersAndProtocolKeyword: - return "unexpectedBetweenModifiersAndProtocolKeyword" - case \ProtocolDeclSyntax.protocolKeyword: - return "protocolKeyword" - case \ProtocolDeclSyntax.unexpectedBetweenProtocolKeywordAndName: - return "unexpectedBetweenProtocolKeywordAndName" - case \ProtocolDeclSyntax.name: - return "name" - case \ProtocolDeclSyntax.unexpectedBetweenNameAndPrimaryAssociatedTypeClause: - return "unexpectedBetweenNameAndPrimaryAssociatedTypeClause" - case \ProtocolDeclSyntax.primaryAssociatedTypeClause: - return "primaryAssociatedTypeClause" - case \ProtocolDeclSyntax.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: - return "unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause" - case \ProtocolDeclSyntax.inheritanceClause: - return "inheritanceClause" - case \ProtocolDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: - return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ProtocolDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \ProtocolDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" - case \ProtocolDeclSyntax.memberBlock: - return "memberBlock" - case \ProtocolDeclSyntax.unexpectedAfterMemberBlock: - return "unexpectedAfterMemberBlock" - case \RegexLiteralExprSyntax.unexpectedBeforeOpeningPounds: - return "unexpectedBeforeOpeningPounds" - case \RegexLiteralExprSyntax.openingPounds: - return "openingPounds" - case \RegexLiteralExprSyntax.unexpectedBetweenOpeningPoundsAndOpeningSlash: - return "unexpectedBetweenOpeningPoundsAndOpeningSlash" - case \RegexLiteralExprSyntax.openingSlash: - return "openingSlash" - case \RegexLiteralExprSyntax.unexpectedBetweenOpeningSlashAndRegex: - return "unexpectedBetweenOpeningSlashAndRegex" - case \RegexLiteralExprSyntax.regex: - return "regex" - case \RegexLiteralExprSyntax.unexpectedBetweenRegexAndClosingSlash: - return "unexpectedBetweenRegexAndClosingSlash" - case \RegexLiteralExprSyntax.closingSlash: - return "closingSlash" - case \RegexLiteralExprSyntax.unexpectedBetweenClosingSlashAndClosingPounds: - return "unexpectedBetweenClosingSlashAndClosingPounds" - case \RegexLiteralExprSyntax.closingPounds: - return "closingPounds" - case \RegexLiteralExprSyntax.unexpectedAfterClosingPounds: - return "unexpectedAfterClosingPounds" - case \RepeatStmtSyntax.unexpectedBeforeRepeatKeyword: - return "unexpectedBeforeRepeatKeyword" - case \RepeatStmtSyntax.repeatKeyword: - return "repeatKeyword" - case \RepeatStmtSyntax.unexpectedBetweenRepeatKeywordAndBody: - return "unexpectedBetweenRepeatKeywordAndBody" - case \RepeatStmtSyntax.body: - return "body" - case \RepeatStmtSyntax.unexpectedBetweenBodyAndWhileKeyword: - return "unexpectedBetweenBodyAndWhileKeyword" - case \RepeatStmtSyntax.whileKeyword: - return "whileKeyword" - case \RepeatStmtSyntax.unexpectedBetweenWhileKeywordAndCondition: - return "unexpectedBetweenWhileKeywordAndCondition" - case \RepeatStmtSyntax.condition: - return "condition" - case \RepeatStmtSyntax.unexpectedAfterCondition: - return "unexpectedAfterCondition" - case \ReturnClauseSyntax.unexpectedBeforeArrow: - return "unexpectedBeforeArrow" - case \ReturnClauseSyntax.arrow: - return "arrow" - case \ReturnClauseSyntax.unexpectedBetweenArrowAndType: - return "unexpectedBetweenArrowAndType" - case \ReturnClauseSyntax.type: - return "type" - case \ReturnClauseSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \ReturnStmtSyntax.unexpectedBeforeReturnKeyword: - return "unexpectedBeforeReturnKeyword" - case \ReturnStmtSyntax.returnKeyword: - return "returnKeyword" - case \ReturnStmtSyntax.unexpectedBetweenReturnKeywordAndExpression: - return "unexpectedBetweenReturnKeywordAndExpression" - case \ReturnStmtSyntax.expression: - return "expression" - case \ReturnStmtSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \SameTypeRequirementSyntax.unexpectedBeforeLeftType: - return "unexpectedBeforeLeftType" - case \SameTypeRequirementSyntax.leftType: - return "leftType" - case \SameTypeRequirementSyntax.unexpectedBetweenLeftTypeAndEqual: - return "unexpectedBetweenLeftTypeAndEqual" - case \SameTypeRequirementSyntax.equal: - return "equal" - case \SameTypeRequirementSyntax.unexpectedBetweenEqualAndRightType: - return "unexpectedBetweenEqualAndRightType" - case \SameTypeRequirementSyntax.rightType: - return "rightType" - case \SameTypeRequirementSyntax.unexpectedAfterRightType: - return "unexpectedAfterRightType" - case \SequenceExprSyntax.unexpectedBeforeElements: - return "unexpectedBeforeElements" - case \SequenceExprSyntax.elements: - return "elements" - case \SequenceExprSyntax.unexpectedAfterElements: - return "unexpectedAfterElements" - case \SimpleStringLiteralExprSyntax.unexpectedBeforeOpeningQuote: - return "unexpectedBeforeOpeningQuote" - case \SimpleStringLiteralExprSyntax.openingQuote: - return "openingQuote" - case \SimpleStringLiteralExprSyntax.unexpectedBetweenOpeningQuoteAndSegments: - return "unexpectedBetweenOpeningQuoteAndSegments" - case \SimpleStringLiteralExprSyntax.segments: - return "segments" - case \SimpleStringLiteralExprSyntax.unexpectedBetweenSegmentsAndClosingQuote: - return "unexpectedBetweenSegmentsAndClosingQuote" - case \SimpleStringLiteralExprSyntax.closingQuote: - return "closingQuote" - case \SimpleStringLiteralExprSyntax.unexpectedAfterClosingQuote: - return "unexpectedAfterClosingQuote" - case \SimpleTypeSpecifierSyntax.unexpectedBeforeSpecifier: - return "unexpectedBeforeSpecifier" - case \SimpleTypeSpecifierSyntax.specifier: - return "specifier" - case \SimpleTypeSpecifierSyntax.unexpectedAfterSpecifier: - return "unexpectedAfterSpecifier" - case \SomeOrAnyTypeSyntax.unexpectedBeforeSomeOrAnySpecifier: - return "unexpectedBeforeSomeOrAnySpecifier" - case \SomeOrAnyTypeSyntax.someOrAnySpecifier: - return "someOrAnySpecifier" - case \SomeOrAnyTypeSyntax.unexpectedBetweenSomeOrAnySpecifierAndConstraint: - return "unexpectedBetweenSomeOrAnySpecifierAndConstraint" - case \SomeOrAnyTypeSyntax.constraint: - return "constraint" - case \SomeOrAnyTypeSyntax.unexpectedAfterConstraint: - return "unexpectedAfterConstraint" - case \SourceFileSyntax.unexpectedBeforeShebang: - return "unexpectedBeforeShebang" - case \SourceFileSyntax.shebang: - return "shebang" - case \SourceFileSyntax.unexpectedBetweenShebangAndStatements: - return "unexpectedBetweenShebangAndStatements" - case \SourceFileSyntax.statements: - return "statements" - case \SourceFileSyntax.unexpectedBetweenStatementsAndEndOfFileToken: - return "unexpectedBetweenStatementsAndEndOfFileToken" - case \SourceFileSyntax.endOfFileToken: - return "endOfFileToken" - case \SourceFileSyntax.unexpectedAfterEndOfFileToken: - return "unexpectedAfterEndOfFileToken" - case \SpecializeAvailabilityArgumentSyntax.unexpectedBeforeAvailabilityLabel: - return "unexpectedBeforeAvailabilityLabel" - case \SpecializeAvailabilityArgumentSyntax.availabilityLabel: - return "availabilityLabel" - case \SpecializeAvailabilityArgumentSyntax.unexpectedBetweenAvailabilityLabelAndColon: - return "unexpectedBetweenAvailabilityLabelAndColon" - case \SpecializeAvailabilityArgumentSyntax.colon: - return "colon" - case \SpecializeAvailabilityArgumentSyntax.unexpectedBetweenColonAndAvailabilityArguments: - return "unexpectedBetweenColonAndAvailabilityArguments" - case \SpecializeAvailabilityArgumentSyntax.availabilityArguments: - return "availabilityArguments" - case \SpecializeAvailabilityArgumentSyntax.unexpectedBetweenAvailabilityArgumentsAndSemicolon: - return "unexpectedBetweenAvailabilityArgumentsAndSemicolon" - case \SpecializeAvailabilityArgumentSyntax.semicolon: - return "semicolon" - case \SpecializeAvailabilityArgumentSyntax.unexpectedAfterSemicolon: - return "unexpectedAfterSemicolon" - case \SpecializeTargetFunctionArgumentSyntax.unexpectedBeforeTargetLabel: - return "unexpectedBeforeTargetLabel" - case \SpecializeTargetFunctionArgumentSyntax.targetLabel: - return "targetLabel" - case \SpecializeTargetFunctionArgumentSyntax.unexpectedBetweenTargetLabelAndColon: - return "unexpectedBetweenTargetLabelAndColon" - case \SpecializeTargetFunctionArgumentSyntax.colon: - return "colon" - case \SpecializeTargetFunctionArgumentSyntax.unexpectedBetweenColonAndDeclName: - return "unexpectedBetweenColonAndDeclName" - case \SpecializeTargetFunctionArgumentSyntax.declName: - return "declName" - case \SpecializeTargetFunctionArgumentSyntax.unexpectedBetweenDeclNameAndTrailingComma: - return "unexpectedBetweenDeclNameAndTrailingComma" - case \SpecializeTargetFunctionArgumentSyntax.trailingComma: - return "trailingComma" - case \SpecializeTargetFunctionArgumentSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \StringLiteralExprSyntax.unexpectedBeforeOpeningPounds: - return "unexpectedBeforeOpeningPounds" - case \StringLiteralExprSyntax.openingPounds: - return "openingPounds" - case \StringLiteralExprSyntax.unexpectedBetweenOpeningPoundsAndOpeningQuote: - return "unexpectedBetweenOpeningPoundsAndOpeningQuote" - case \StringLiteralExprSyntax.openingQuote: - return "openingQuote" - case \StringLiteralExprSyntax.unexpectedBetweenOpeningQuoteAndSegments: - return "unexpectedBetweenOpeningQuoteAndSegments" - case \StringLiteralExprSyntax.segments: - return "segments" - case \StringLiteralExprSyntax.unexpectedBetweenSegmentsAndClosingQuote: - return "unexpectedBetweenSegmentsAndClosingQuote" - case \StringLiteralExprSyntax.closingQuote: - return "closingQuote" - case \StringLiteralExprSyntax.unexpectedBetweenClosingQuoteAndClosingPounds: - return "unexpectedBetweenClosingQuoteAndClosingPounds" - case \StringLiteralExprSyntax.closingPounds: - return "closingPounds" - case \StringLiteralExprSyntax.unexpectedAfterClosingPounds: - return "unexpectedAfterClosingPounds" - case \StringSegmentSyntax.unexpectedBeforeContent: - return "unexpectedBeforeContent" - case \StringSegmentSyntax.content: - return "content" - case \StringSegmentSyntax.unexpectedAfterContent: - return "unexpectedAfterContent" - case \StructDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \StructDeclSyntax.attributes: - return "attributes" - case \StructDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \StructDeclSyntax.modifiers: - return "modifiers" - case \StructDeclSyntax.unexpectedBetweenModifiersAndStructKeyword: - return "unexpectedBetweenModifiersAndStructKeyword" - case \StructDeclSyntax.structKeyword: - return "structKeyword" - case \StructDeclSyntax.unexpectedBetweenStructKeywordAndName: - return "unexpectedBetweenStructKeywordAndName" - case \StructDeclSyntax.name: - return "name" - case \StructDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: - return "unexpectedBetweenNameAndGenericParameterClause" - case \StructDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \StructDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: - return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \StructDeclSyntax.inheritanceClause: - return "inheritanceClause" - case \StructDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: - return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \StructDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \StructDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" - case \StructDeclSyntax.memberBlock: - return "memberBlock" - case \StructDeclSyntax.unexpectedAfterMemberBlock: - return "unexpectedAfterMemberBlock" - case \SubscriptCallExprSyntax.unexpectedBeforeCalledExpression: - return "unexpectedBeforeCalledExpression" - case \SubscriptCallExprSyntax.calledExpression: - return "calledExpression" - case \SubscriptCallExprSyntax.unexpectedBetweenCalledExpressionAndLeftSquare: - return "unexpectedBetweenCalledExpressionAndLeftSquare" - case \SubscriptCallExprSyntax.leftSquare: - return "leftSquare" - case \SubscriptCallExprSyntax.unexpectedBetweenLeftSquareAndArguments: - return "unexpectedBetweenLeftSquareAndArguments" - case \SubscriptCallExprSyntax.arguments: - return "arguments" - case \SubscriptCallExprSyntax.unexpectedBetweenArgumentsAndRightSquare: - return "unexpectedBetweenArgumentsAndRightSquare" - case \SubscriptCallExprSyntax.rightSquare: - return "rightSquare" - case \SubscriptCallExprSyntax.unexpectedBetweenRightSquareAndTrailingClosure: - return "unexpectedBetweenRightSquareAndTrailingClosure" - case \SubscriptCallExprSyntax.trailingClosure: - return "trailingClosure" - case \SubscriptCallExprSyntax.unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: - return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" - case \SubscriptCallExprSyntax.additionalTrailingClosures: - return "additionalTrailingClosures" - case \SubscriptCallExprSyntax.unexpectedAfterAdditionalTrailingClosures: - return "unexpectedAfterAdditionalTrailingClosures" - case \SubscriptDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \SubscriptDeclSyntax.attributes: - return "attributes" - case \SubscriptDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \SubscriptDeclSyntax.modifiers: - return "modifiers" - case \SubscriptDeclSyntax.unexpectedBetweenModifiersAndSubscriptKeyword: - return "unexpectedBetweenModifiersAndSubscriptKeyword" - case \SubscriptDeclSyntax.subscriptKeyword: - return "subscriptKeyword" - case \SubscriptDeclSyntax.unexpectedBetweenSubscriptKeywordAndGenericParameterClause: - return "unexpectedBetweenSubscriptKeywordAndGenericParameterClause" - case \SubscriptDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \SubscriptDeclSyntax.unexpectedBetweenGenericParameterClauseAndParameterClause: - return "unexpectedBetweenGenericParameterClauseAndParameterClause" - case \SubscriptDeclSyntax.parameterClause: - return "parameterClause" - case \SubscriptDeclSyntax.unexpectedBetweenParameterClauseAndReturnClause: - return "unexpectedBetweenParameterClauseAndReturnClause" - case \SubscriptDeclSyntax.returnClause: - return "returnClause" - case \SubscriptDeclSyntax.unexpectedBetweenReturnClauseAndGenericWhereClause: - return "unexpectedBetweenReturnClauseAndGenericWhereClause" - case \SubscriptDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \SubscriptDeclSyntax.unexpectedBetweenGenericWhereClauseAndAccessorBlock: - return "unexpectedBetweenGenericWhereClauseAndAccessorBlock" - case \SubscriptDeclSyntax.accessorBlock: - return "accessorBlock" - case \SubscriptDeclSyntax.unexpectedAfterAccessorBlock: - return "unexpectedAfterAccessorBlock" - case \SuperExprSyntax.unexpectedBeforeSuperKeyword: - return "unexpectedBeforeSuperKeyword" - case \SuperExprSyntax.superKeyword: - return "superKeyword" - case \SuperExprSyntax.unexpectedAfterSuperKeyword: - return "unexpectedAfterSuperKeyword" - case \SuppressedTypeSyntax.unexpectedBeforeWithoutTilde: - return "unexpectedBeforeWithoutTilde" - case \SuppressedTypeSyntax.withoutTilde: - return "withoutTilde" - case \SuppressedTypeSyntax.unexpectedBetweenWithoutTildeAndType: - return "unexpectedBetweenWithoutTildeAndType" - case \SuppressedTypeSyntax.type: - return "type" - case \SuppressedTypeSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \SwitchCaseItemSyntax.unexpectedBeforePattern: - return "unexpectedBeforePattern" - case \SwitchCaseItemSyntax.pattern: - return "pattern" - case \SwitchCaseItemSyntax.unexpectedBetweenPatternAndWhereClause: - return "unexpectedBetweenPatternAndWhereClause" - case \SwitchCaseItemSyntax.whereClause: - return "whereClause" - case \SwitchCaseItemSyntax.unexpectedBetweenWhereClauseAndTrailingComma: - return "unexpectedBetweenWhereClauseAndTrailingComma" - case \SwitchCaseItemSyntax.trailingComma: - return "trailingComma" - case \SwitchCaseItemSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \SwitchCaseLabelSyntax.unexpectedBeforeCaseKeyword: - return "unexpectedBeforeCaseKeyword" - case \SwitchCaseLabelSyntax.caseKeyword: - return "caseKeyword" - case \SwitchCaseLabelSyntax.unexpectedBetweenCaseKeywordAndCaseItems: - return "unexpectedBetweenCaseKeywordAndCaseItems" - case \SwitchCaseLabelSyntax.caseItems: - return "caseItems" - case \SwitchCaseLabelSyntax.unexpectedBetweenCaseItemsAndColon: - return "unexpectedBetweenCaseItemsAndColon" - case \SwitchCaseLabelSyntax.colon: - return "colon" - case \SwitchCaseLabelSyntax.unexpectedAfterColon: - return "unexpectedAfterColon" - case \SwitchCaseSyntax.unexpectedBeforeAttribute: - return "unexpectedBeforeAttribute" - case \SwitchCaseSyntax.attribute: - return "attribute" - case \SwitchCaseSyntax.unexpectedBetweenAttributeAndLabel: - return "unexpectedBetweenAttributeAndLabel" - case \SwitchCaseSyntax.label: - return "label" - case \SwitchCaseSyntax.unexpectedBetweenLabelAndStatements: - return "unexpectedBetweenLabelAndStatements" - case \SwitchCaseSyntax.statements: - return "statements" - case \SwitchCaseSyntax.unexpectedAfterStatements: - return "unexpectedAfterStatements" - case \SwitchDefaultLabelSyntax.unexpectedBeforeDefaultKeyword: - return "unexpectedBeforeDefaultKeyword" - case \SwitchDefaultLabelSyntax.defaultKeyword: - return "defaultKeyword" - case \SwitchDefaultLabelSyntax.unexpectedBetweenDefaultKeywordAndColon: - return "unexpectedBetweenDefaultKeywordAndColon" - case \SwitchDefaultLabelSyntax.colon: - return "colon" - case \SwitchDefaultLabelSyntax.unexpectedAfterColon: - return "unexpectedAfterColon" - case \SwitchExprSyntax.unexpectedBeforeSwitchKeyword: - return "unexpectedBeforeSwitchKeyword" - case \SwitchExprSyntax.switchKeyword: - return "switchKeyword" - case \SwitchExprSyntax.unexpectedBetweenSwitchKeywordAndSubject: - return "unexpectedBetweenSwitchKeywordAndSubject" - case \SwitchExprSyntax.subject: - return "subject" - case \SwitchExprSyntax.unexpectedBetweenSubjectAndLeftBrace: - return "unexpectedBetweenSubjectAndLeftBrace" - case \SwitchExprSyntax.leftBrace: - return "leftBrace" - case \SwitchExprSyntax.unexpectedBetweenLeftBraceAndCases: - return "unexpectedBetweenLeftBraceAndCases" - case \SwitchExprSyntax.cases: - return "cases" - case \SwitchExprSyntax.unexpectedBetweenCasesAndRightBrace: - return "unexpectedBetweenCasesAndRightBrace" - case \SwitchExprSyntax.rightBrace: - return "rightBrace" - case \SwitchExprSyntax.unexpectedAfterRightBrace: - return "unexpectedAfterRightBrace" - case \TernaryExprSyntax.unexpectedBeforeCondition: - return "unexpectedBeforeCondition" - case \TernaryExprSyntax.condition: - return "condition" - case \TernaryExprSyntax.unexpectedBetweenConditionAndQuestionMark: - return "unexpectedBetweenConditionAndQuestionMark" - case \TernaryExprSyntax.questionMark: - return "questionMark" - case \TernaryExprSyntax.unexpectedBetweenQuestionMarkAndThenExpression: - return "unexpectedBetweenQuestionMarkAndThenExpression" - case \TernaryExprSyntax.thenExpression: - return "thenExpression" - case \TernaryExprSyntax.unexpectedBetweenThenExpressionAndColon: - return "unexpectedBetweenThenExpressionAndColon" - case \TernaryExprSyntax.colon: - return "colon" - case \TernaryExprSyntax.unexpectedBetweenColonAndElseExpression: - return "unexpectedBetweenColonAndElseExpression" - case \TernaryExprSyntax.elseExpression: - return "elseExpression" - case \TernaryExprSyntax.unexpectedAfterElseExpression: - return "unexpectedAfterElseExpression" - case \ThenStmtSyntax.unexpectedBeforeThenKeyword: - return "unexpectedBeforeThenKeyword" - case \ThenStmtSyntax.thenKeyword: - return "thenKeyword" - case \ThenStmtSyntax.unexpectedBetweenThenKeywordAndExpression: - return "unexpectedBetweenThenKeywordAndExpression" - case \ThenStmtSyntax.expression: - return "expression" - case \ThenStmtSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \ThrowStmtSyntax.unexpectedBeforeThrowKeyword: - return "unexpectedBeforeThrowKeyword" - case \ThrowStmtSyntax.throwKeyword: - return "throwKeyword" - case \ThrowStmtSyntax.unexpectedBetweenThrowKeywordAndExpression: - return "unexpectedBetweenThrowKeywordAndExpression" - case \ThrowStmtSyntax.expression: - return "expression" - case \ThrowStmtSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \ThrowsClauseSyntax.unexpectedBeforeThrowsSpecifier: - return "unexpectedBeforeThrowsSpecifier" - case \ThrowsClauseSyntax.throwsSpecifier: - return "throwsSpecifier" - case \ThrowsClauseSyntax.unexpectedBetweenThrowsSpecifierAndLeftParen: - return "unexpectedBetweenThrowsSpecifierAndLeftParen" - case \ThrowsClauseSyntax.leftParen: - return "leftParen" - case \ThrowsClauseSyntax.unexpectedBetweenLeftParenAndType: - return "unexpectedBetweenLeftParenAndType" - case \ThrowsClauseSyntax.type: - return "type" - case \ThrowsClauseSyntax.unexpectedBetweenTypeAndRightParen: - return "unexpectedBetweenTypeAndRightParen" - case \ThrowsClauseSyntax.rightParen: - return "rightParen" - case \ThrowsClauseSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \TryExprSyntax.unexpectedBeforeTryKeyword: - return "unexpectedBeforeTryKeyword" - case \TryExprSyntax.tryKeyword: - return "tryKeyword" - case \TryExprSyntax.unexpectedBetweenTryKeywordAndQuestionOrExclamationMark: - return "unexpectedBetweenTryKeywordAndQuestionOrExclamationMark" - case \TryExprSyntax.questionOrExclamationMark: - return "questionOrExclamationMark" - case \TryExprSyntax.unexpectedBetweenQuestionOrExclamationMarkAndExpression: - return "unexpectedBetweenQuestionOrExclamationMarkAndExpression" - case \TryExprSyntax.expression: - return "expression" - case \TryExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \TupleExprSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \TupleExprSyntax.leftParen: - return "leftParen" - case \TupleExprSyntax.unexpectedBetweenLeftParenAndElements: - return "unexpectedBetweenLeftParenAndElements" - case \TupleExprSyntax.elements: - return "elements" - case \TupleExprSyntax.unexpectedBetweenElementsAndRightParen: - return "unexpectedBetweenElementsAndRightParen" - case \TupleExprSyntax.rightParen: - return "rightParen" - case \TupleExprSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \TuplePatternElementSyntax.unexpectedBeforeLabel: - return "unexpectedBeforeLabel" - case \TuplePatternElementSyntax.label: - return "label" - case \TuplePatternElementSyntax.unexpectedBetweenLabelAndColon: - return "unexpectedBetweenLabelAndColon" - case \TuplePatternElementSyntax.colon: - return "colon" - case \TuplePatternElementSyntax.unexpectedBetweenColonAndPattern: - return "unexpectedBetweenColonAndPattern" - case \TuplePatternElementSyntax.pattern: - return "pattern" - case \TuplePatternElementSyntax.unexpectedBetweenPatternAndTrailingComma: - return "unexpectedBetweenPatternAndTrailingComma" - case \TuplePatternElementSyntax.trailingComma: - return "trailingComma" - case \TuplePatternElementSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \TuplePatternSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \TuplePatternSyntax.leftParen: - return "leftParen" - case \TuplePatternSyntax.unexpectedBetweenLeftParenAndElements: - return "unexpectedBetweenLeftParenAndElements" - case \TuplePatternSyntax.elements: - return "elements" - case \TuplePatternSyntax.unexpectedBetweenElementsAndRightParen: - return "unexpectedBetweenElementsAndRightParen" - case \TuplePatternSyntax.rightParen: - return "rightParen" - case \TuplePatternSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \TupleTypeElementSyntax.unexpectedBeforeInoutKeyword: - return "unexpectedBeforeInoutKeyword" - case \TupleTypeElementSyntax.inoutKeyword: - return "inoutKeyword" - case \TupleTypeElementSyntax.unexpectedBetweenInoutKeywordAndFirstName: - return "unexpectedBetweenInoutKeywordAndFirstName" - case \TupleTypeElementSyntax.firstName: - return "firstName" - case \TupleTypeElementSyntax.unexpectedBetweenFirstNameAndSecondName: - return "unexpectedBetweenFirstNameAndSecondName" - case \TupleTypeElementSyntax.secondName: - return "secondName" - case \TupleTypeElementSyntax.unexpectedBetweenSecondNameAndColon: - return "unexpectedBetweenSecondNameAndColon" - case \TupleTypeElementSyntax.colon: - return "colon" - case \TupleTypeElementSyntax.unexpectedBetweenColonAndType: - return "unexpectedBetweenColonAndType" - case \TupleTypeElementSyntax.type: - return "type" - case \TupleTypeElementSyntax.unexpectedBetweenTypeAndEllipsis: - return "unexpectedBetweenTypeAndEllipsis" - case \TupleTypeElementSyntax.ellipsis: - return "ellipsis" - case \TupleTypeElementSyntax.unexpectedBetweenEllipsisAndTrailingComma: - return "unexpectedBetweenEllipsisAndTrailingComma" - case \TupleTypeElementSyntax.trailingComma: - return "trailingComma" - case \TupleTypeElementSyntax.unexpectedAfterTrailingComma: - return "unexpectedAfterTrailingComma" - case \TupleTypeSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \TupleTypeSyntax.leftParen: - return "leftParen" - case \TupleTypeSyntax.unexpectedBetweenLeftParenAndElements: - return "unexpectedBetweenLeftParenAndElements" - case \TupleTypeSyntax.elements: - return "elements" - case \TupleTypeSyntax.unexpectedBetweenElementsAndRightParen: - return "unexpectedBetweenElementsAndRightParen" - case \TupleTypeSyntax.rightParen: - return "rightParen" - case \TupleTypeSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - case \TypeAliasDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \TypeAliasDeclSyntax.attributes: - return "attributes" - case \TypeAliasDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \TypeAliasDeclSyntax.modifiers: - return "modifiers" - case \TypeAliasDeclSyntax.unexpectedBetweenModifiersAndTypealiasKeyword: - return "unexpectedBetweenModifiersAndTypealiasKeyword" - case \TypeAliasDeclSyntax.typealiasKeyword: - return "typealiasKeyword" - case \TypeAliasDeclSyntax.unexpectedBetweenTypealiasKeywordAndName: - return "unexpectedBetweenTypealiasKeywordAndName" - case \TypeAliasDeclSyntax.name: - return "name" - case \TypeAliasDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: - return "unexpectedBetweenNameAndGenericParameterClause" - case \TypeAliasDeclSyntax.genericParameterClause: - return "genericParameterClause" - case \TypeAliasDeclSyntax.unexpectedBetweenGenericParameterClauseAndInitializer: - return "unexpectedBetweenGenericParameterClauseAndInitializer" - case \TypeAliasDeclSyntax.initializer: - return "initializer" - case \TypeAliasDeclSyntax.unexpectedBetweenInitializerAndGenericWhereClause: - return "unexpectedBetweenInitializerAndGenericWhereClause" - case \TypeAliasDeclSyntax.genericWhereClause: - return "genericWhereClause" - case \TypeAliasDeclSyntax.unexpectedAfterGenericWhereClause: - return "unexpectedAfterGenericWhereClause" - case \TypeAnnotationSyntax.unexpectedBeforeColon: - return "unexpectedBeforeColon" - case \TypeAnnotationSyntax.colon: - return "colon" - case \TypeAnnotationSyntax.unexpectedBetweenColonAndType: - return "unexpectedBetweenColonAndType" - case \TypeAnnotationSyntax.type: - return "type" - case \TypeAnnotationSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \TypeEffectSpecifiersSyntax.unexpectedBeforeAsyncSpecifier: - return "unexpectedBeforeAsyncSpecifier" - case \TypeEffectSpecifiersSyntax.asyncSpecifier: - return "asyncSpecifier" - case \TypeEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsClause: - return "unexpectedBetweenAsyncSpecifierAndThrowsClause" - case \TypeEffectSpecifiersSyntax.throwsClause: - return "throwsClause" - case \TypeEffectSpecifiersSyntax.unexpectedAfterThrowsClause: - return "unexpectedAfterThrowsClause" - case \TypeExprSyntax.unexpectedBeforeType: - return "unexpectedBeforeType" - case \TypeExprSyntax.type: - return "type" - case \TypeExprSyntax.unexpectedAfterType: - return "unexpectedAfterType" - case \TypeInitializerClauseSyntax.unexpectedBeforeEqual: - return "unexpectedBeforeEqual" - case \TypeInitializerClauseSyntax.equal: - return "equal" - case \TypeInitializerClauseSyntax.unexpectedBetweenEqualAndValue: - return "unexpectedBetweenEqualAndValue" - case \TypeInitializerClauseSyntax.value: - return "value" - case \TypeInitializerClauseSyntax.unexpectedAfterValue: - return "unexpectedAfterValue" - case \UnavailableFromAsyncAttributeArgumentsSyntax.unexpectedBeforeMessageLabel: - return "unexpectedBeforeMessageLabel" - case \UnavailableFromAsyncAttributeArgumentsSyntax.messageLabel: - return "messageLabel" - case \UnavailableFromAsyncAttributeArgumentsSyntax.unexpectedBetweenMessageLabelAndColon: - return "unexpectedBetweenMessageLabelAndColon" - case \UnavailableFromAsyncAttributeArgumentsSyntax.colon: - return "colon" - case \UnavailableFromAsyncAttributeArgumentsSyntax.unexpectedBetweenColonAndMessage: - return "unexpectedBetweenColonAndMessage" - case \UnavailableFromAsyncAttributeArgumentsSyntax.message: - return "message" - case \UnavailableFromAsyncAttributeArgumentsSyntax.unexpectedAfterMessage: - return "unexpectedAfterMessage" - case \UnderscorePrivateAttributeArgumentsSyntax.unexpectedBeforeSourceFileLabel: - return "unexpectedBeforeSourceFileLabel" - case \UnderscorePrivateAttributeArgumentsSyntax.sourceFileLabel: - return "sourceFileLabel" - case \UnderscorePrivateAttributeArgumentsSyntax.unexpectedBetweenSourceFileLabelAndColon: - return "unexpectedBetweenSourceFileLabelAndColon" - case \UnderscorePrivateAttributeArgumentsSyntax.colon: - return "colon" - case \UnderscorePrivateAttributeArgumentsSyntax.unexpectedBetweenColonAndFilename: - return "unexpectedBetweenColonAndFilename" - case \UnderscorePrivateAttributeArgumentsSyntax.filename: - return "filename" - case \UnderscorePrivateAttributeArgumentsSyntax.unexpectedAfterFilename: - return "unexpectedAfterFilename" - case \UnresolvedAsExprSyntax.unexpectedBeforeAsKeyword: - return "unexpectedBeforeAsKeyword" - case \UnresolvedAsExprSyntax.asKeyword: - return "asKeyword" - case \UnresolvedAsExprSyntax.unexpectedBetweenAsKeywordAndQuestionOrExclamationMark: - return "unexpectedBetweenAsKeywordAndQuestionOrExclamationMark" - case \UnresolvedAsExprSyntax.questionOrExclamationMark: - return "questionOrExclamationMark" - case \UnresolvedAsExprSyntax.unexpectedAfterQuestionOrExclamationMark: - return "unexpectedAfterQuestionOrExclamationMark" - case \UnresolvedIsExprSyntax.unexpectedBeforeIsKeyword: - return "unexpectedBeforeIsKeyword" - case \UnresolvedIsExprSyntax.isKeyword: - return "isKeyword" - case \UnresolvedIsExprSyntax.unexpectedAfterIsKeyword: - return "unexpectedAfterIsKeyword" - case \UnresolvedTernaryExprSyntax.unexpectedBeforeQuestionMark: - return "unexpectedBeforeQuestionMark" - case \UnresolvedTernaryExprSyntax.questionMark: - return "questionMark" - case \UnresolvedTernaryExprSyntax.unexpectedBetweenQuestionMarkAndThenExpression: - return "unexpectedBetweenQuestionMarkAndThenExpression" - case \UnresolvedTernaryExprSyntax.thenExpression: - return "thenExpression" - case \UnresolvedTernaryExprSyntax.unexpectedBetweenThenExpressionAndColon: - return "unexpectedBetweenThenExpressionAndColon" - case \UnresolvedTernaryExprSyntax.colon: - return "colon" - case \UnresolvedTernaryExprSyntax.unexpectedAfterColon: - return "unexpectedAfterColon" - case \UnsafeExprSyntax.unexpectedBeforeUnsafeKeyword: - return "unexpectedBeforeUnsafeKeyword" - case \UnsafeExprSyntax.unsafeKeyword: - return "unsafeKeyword" - case \UnsafeExprSyntax.unexpectedBetweenUnsafeKeywordAndExpression: - return "unexpectedBetweenUnsafeKeywordAndExpression" - case \UnsafeExprSyntax.expression: - return "expression" - case \UnsafeExprSyntax.unexpectedAfterExpression: - return "unexpectedAfterExpression" - case \ValueBindingPatternSyntax.unexpectedBeforeBindingSpecifier: - return "unexpectedBeforeBindingSpecifier" - case \ValueBindingPatternSyntax.bindingSpecifier: - return "bindingSpecifier" - case \ValueBindingPatternSyntax.unexpectedBetweenBindingSpecifierAndPattern: - return "unexpectedBetweenBindingSpecifierAndPattern" - case \ValueBindingPatternSyntax.pattern: - return "pattern" - case \ValueBindingPatternSyntax.unexpectedAfterPattern: - return "unexpectedAfterPattern" - case \VariableDeclSyntax.unexpectedBeforeAttributes: - return "unexpectedBeforeAttributes" - case \VariableDeclSyntax.attributes: - return "attributes" - case \VariableDeclSyntax.unexpectedBetweenAttributesAndModifiers: - return "unexpectedBetweenAttributesAndModifiers" - case \VariableDeclSyntax.modifiers: - return "modifiers" - case \VariableDeclSyntax.unexpectedBetweenModifiersAndBindingSpecifier: - return "unexpectedBetweenModifiersAndBindingSpecifier" - case \VariableDeclSyntax.bindingSpecifier: - return "bindingSpecifier" - case \VariableDeclSyntax.unexpectedBetweenBindingSpecifierAndBindings: - return "unexpectedBetweenBindingSpecifierAndBindings" - case \VariableDeclSyntax.bindings: - return "bindings" - case \VariableDeclSyntax.unexpectedAfterBindings: - return "unexpectedAfterBindings" - case \VersionComponentSyntax.unexpectedBeforePeriod: - return "unexpectedBeforePeriod" - case \VersionComponentSyntax.period: - return "period" - case \VersionComponentSyntax.unexpectedBetweenPeriodAndNumber: - return "unexpectedBetweenPeriodAndNumber" - case \VersionComponentSyntax.number: - return "number" - case \VersionComponentSyntax.unexpectedAfterNumber: - return "unexpectedAfterNumber" - case \VersionTupleSyntax.unexpectedBeforeMajor: - return "unexpectedBeforeMajor" - case \VersionTupleSyntax.major: - return "major" - case \VersionTupleSyntax.unexpectedBetweenMajorAndComponents: - return "unexpectedBetweenMajorAndComponents" - case \VersionTupleSyntax.components: - return "components" - case \VersionTupleSyntax.unexpectedAfterComponents: - return "unexpectedAfterComponents" - case \WhereClauseSyntax.unexpectedBeforeWhereKeyword: - return "unexpectedBeforeWhereKeyword" - case \WhereClauseSyntax.whereKeyword: - return "whereKeyword" - case \WhereClauseSyntax.unexpectedBetweenWhereKeywordAndCondition: - return "unexpectedBetweenWhereKeywordAndCondition" - case \WhereClauseSyntax.condition: - return "condition" - case \WhereClauseSyntax.unexpectedAfterCondition: - return "unexpectedAfterCondition" - case \WhileStmtSyntax.unexpectedBeforeWhileKeyword: - return "unexpectedBeforeWhileKeyword" - case \WhileStmtSyntax.whileKeyword: - return "whileKeyword" - case \WhileStmtSyntax.unexpectedBetweenWhileKeywordAndConditions: - return "unexpectedBetweenWhileKeywordAndConditions" - case \WhileStmtSyntax.conditions: - return "conditions" - case \WhileStmtSyntax.unexpectedBetweenConditionsAndBody: - return "unexpectedBetweenConditionsAndBody" - case \WhileStmtSyntax.body: - return "body" - case \WhileStmtSyntax.unexpectedAfterBody: - return "unexpectedAfterBody" - case \WildcardPatternSyntax.unexpectedBeforeWildcard: - return "unexpectedBeforeWildcard" - case \WildcardPatternSyntax.wildcard: - return "wildcard" - case \WildcardPatternSyntax.unexpectedAfterWildcard: - return "unexpectedAfterWildcard" - case \YieldStmtSyntax.unexpectedBeforeYieldKeyword: - return "unexpectedBeforeYieldKeyword" - case \YieldStmtSyntax.yieldKeyword: - return "yieldKeyword" - case \YieldStmtSyntax.unexpectedBetweenYieldKeywordAndYieldedExpressions: - return "unexpectedBetweenYieldKeywordAndYieldedExpressions" - case \YieldStmtSyntax.yieldedExpressions: - return "yieldedExpressions" - case \YieldStmtSyntax.unexpectedAfterYieldedExpressions: - return "unexpectedAfterYieldedExpressions" - case \YieldedExpressionSyntax.unexpectedBeforeExpression: - return "unexpectedBeforeExpression" - case \YieldedExpressionSyntax.expression: - return "expression" - case \YieldedExpressionSyntax.unexpectedBetweenExpressionAndComma: - return "unexpectedBetweenExpressionAndComma" - case \YieldedExpressionSyntax.comma: - return "comma" - case \YieldedExpressionSyntax.unexpectedAfterComma: - return "unexpectedAfterComma" - case \YieldedExpressionsClauseSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \YieldedExpressionsClauseSyntax.leftParen: - return "leftParen" - case \YieldedExpressionsClauseSyntax.unexpectedBetweenLeftParenAndElements: - return "unexpectedBetweenLeftParenAndElements" - case \YieldedExpressionsClauseSyntax.elements: - return "elements" - case \YieldedExpressionsClauseSyntax.unexpectedBetweenElementsAndRightParen: - return "unexpectedBetweenElementsAndRightParen" - case \YieldedExpressionsClauseSyntax.rightParen: - return "rightParen" - case \YieldedExpressionsClauseSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" - default: - return nil - } -} diff --git a/Sources/SwiftSyntax/generated/ConcreteSyntaxProperty.swift b/Sources/SwiftSyntax/generated/ConcreteSyntaxProperty.swift new file mode 100644 index 00000000000..c777c05af9a --- /dev/null +++ b/Sources/SwiftSyntax/generated/ConcreteSyntaxProperty.swift @@ -0,0 +1,7489 @@ +//// Automatically generated by generate-swift-syntax +//// Do not edit directly! +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +extension ConcreteSyntaxProperty { + fileprivate init(_ index: Int) { + self.index = .init(index) + } +} + +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +extension ConcreteSyntaxProperty where Base == ABIAttributeArgumentsSyntax { + public static var unexpectedBeforeProvider: ConcreteSyntaxProperty { + .init(0) + } + + public static var provider: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterProvider: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == AccessorBlockSyntax { + public static var unexpectedBeforeLeftBrace: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftBrace: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftBraceAndAccessors: ConcreteSyntaxProperty { + .init(2) + } + + public static var accessors: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenAccessorsAndRightBrace: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightBrace: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightBrace: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == AccessorDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifier: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifier: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifierAndAccessorSpecifier: ConcreteSyntaxProperty { + .init(4) + } + + public static var accessorSpecifier: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenAccessorSpecifierAndParameters: ConcreteSyntaxProperty { + .init(6) + } + + public static var parameters: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenParametersAndEffectSpecifiers: ConcreteSyntaxProperty { + .init(8) + } + + public static var effectSpecifiers: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenEffectSpecifiersAndBody: ConcreteSyntaxProperty { + .init(10) + } + + public static var body: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(12) + } +} + +extension ConcreteSyntaxProperty where Base == AccessorEffectSpecifiersSyntax { + public static var unexpectedBeforeAsyncSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var asyncSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAsyncSpecifierAndThrowsClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var throwsClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterThrowsClause: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == AccessorParametersSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndName: ConcreteSyntaxProperty { + .init(2) + } + + public static var name: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenNameAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ActorDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndActorKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var actorKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenActorKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndInheritanceClause: ConcreteSyntaxProperty { + .init(10) + } + + public static var inheritanceClause: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenInheritanceClauseAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndMemberBlock: ConcreteSyntaxProperty { + .init(14) + } + + public static var memberBlock: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterMemberBlock: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == ArrayElementSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ArrayExprSyntax { + public static var unexpectedBeforeLeftSquare: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftSquare: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftSquareAndElements: ConcreteSyntaxProperty { + .init(2) + } + + public static var elements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenElementsAndRightSquare: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightSquare: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightSquare: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ArrayTypeSyntax { + public static var unexpectedBeforeLeftSquare: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftSquare: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftSquareAndElement: ConcreteSyntaxProperty { + .init(2) + } + + public static var element: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenElementAndRightSquare: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightSquare: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightSquare: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ArrowExprSyntax { + public static var unexpectedBeforeEffectSpecifiers: ConcreteSyntaxProperty { + .init(0) + } + + public static var effectSpecifiers: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenEffectSpecifiersAndArrow: ConcreteSyntaxProperty { + .init(2) + } + + public static var arrow: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterArrow: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == AsExprSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndAsKeyword: ConcreteSyntaxProperty { + .init(2) + } + + public static var asKeyword: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenAsKeywordAndQuestionOrExclamationMark: ConcreteSyntaxProperty { + .init(4) + } + + public static var questionOrExclamationMark: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenQuestionOrExclamationMarkAndType: ConcreteSyntaxProperty { + .init(6) + } + + public static var type: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == AssignmentExprSyntax { + public static var unexpectedBeforeEqual: ConcreteSyntaxProperty { + .init(0) + } + + public static var equal: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterEqual: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == AssociatedTypeDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndAssociatedtypeKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var associatedtypeKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenAssociatedtypeKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndInheritanceClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var inheritanceClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenInheritanceClauseAndInitializer: ConcreteSyntaxProperty { + .init(10) + } + + public static var initializer: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenInitializerAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterGenericWhereClause: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == AttributeSyntax { + public static var unexpectedBeforeAtSign: ConcreteSyntaxProperty { + .init(0) + } + + public static var atSign: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAtSignAndAttributeName: ConcreteSyntaxProperty { + .init(2) + } + + public static var attributeName: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenAttributeNameAndLeftParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenLeftParenAndArguments: ConcreteSyntaxProperty { + .init(6) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(8) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == AttributedTypeSyntax { + public static var unexpectedBeforeSpecifiers: ConcreteSyntaxProperty { + .init(0) + } + + public static var specifiers: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenSpecifiersAndAttributes: ConcreteSyntaxProperty { + .init(2) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenAttributesAndBaseType: ConcreteSyntaxProperty { + .init(4) + } + + public static var baseType: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterBaseType: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == AvailabilityArgumentSyntax { + public static var unexpectedBeforeArgument: ConcreteSyntaxProperty { + .init(0) + } + + public static var argument: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenArgumentAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == AvailabilityConditionSyntax { + public static var unexpectedBeforeAvailabilityKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var availabilityKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAvailabilityKeywordAndLeftParen: ConcreteSyntaxProperty { + .init(2) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLeftParenAndAvailabilityArguments: ConcreteSyntaxProperty { + .init(4) + } + + public static var availabilityArguments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenAvailabilityArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == AvailabilityLabeledArgumentSyntax { + public static var unexpectedBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var label: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndValue: ConcreteSyntaxProperty { + .init(4) + } + + public static var value: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterValue: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == AwaitExprSyntax { + public static var unexpectedBeforeAwaitKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var awaitKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAwaitKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == BackDeployedAttributeArgumentsSyntax { + public static var unexpectedBeforeBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var beforeLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBeforeLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndPlatforms: ConcreteSyntaxProperty { + .init(4) + } + + public static var platforms: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterPlatforms: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == BinaryOperatorExprSyntax { + public static var unexpectedBeforeOperator: ConcreteSyntaxProperty { + .init(0) + } + + public static var `operator`: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterOperator: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == BooleanLiteralExprSyntax { + public static var unexpectedBeforeLiteral: ConcreteSyntaxProperty { + .init(0) + } + + public static var literal: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterLiteral: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == BorrowExprSyntax { + public static var unexpectedBeforeBorrowKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var borrowKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBorrowKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == BreakStmtSyntax { + public static var unexpectedBeforeBreakKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var breakKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBreakKeywordAndLabel: ConcreteSyntaxProperty { + .init(2) + } + + public static var label: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterLabel: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == _CanImportExprSyntax { + public static var unexpectedBeforeCanImportKeyword: ConcreteSyntaxProperty<_CanImportExprSyntax, UnexpectedNodesSyntax?> { + .init(0) + } + + public static var canImportKeyword: ConcreteSyntaxProperty<_CanImportExprSyntax, TokenSyntax> { + .init(1) + } + + public static var unexpectedBetweenCanImportKeywordAndLeftParen: ConcreteSyntaxProperty<_CanImportExprSyntax, UnexpectedNodesSyntax?> { + .init(2) + } + + public static var leftParen: ConcreteSyntaxProperty<_CanImportExprSyntax, TokenSyntax> { + .init(3) + } + + public static var unexpectedBetweenLeftParenAndImportPath: ConcreteSyntaxProperty<_CanImportExprSyntax, UnexpectedNodesSyntax?> { + .init(4) + } + + public static var importPath: ConcreteSyntaxProperty<_CanImportExprSyntax, TokenSyntax> { + .init(5) + } + + public static var unexpectedBetweenImportPathAndVersionInfo: ConcreteSyntaxProperty<_CanImportExprSyntax, UnexpectedNodesSyntax?> { + .init(6) + } + + public static var versionInfo: ConcreteSyntaxProperty<_CanImportExprSyntax, _CanImportVersionInfoSyntax?> { + .init(7) + } + + public static var unexpectedBetweenVersionInfoAndRightParen: ConcreteSyntaxProperty<_CanImportExprSyntax, UnexpectedNodesSyntax?> { + .init(8) + } + + public static var rightParen: ConcreteSyntaxProperty<_CanImportExprSyntax, TokenSyntax> { + .init(9) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty<_CanImportExprSyntax, UnexpectedNodesSyntax?> { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == _CanImportVersionInfoSyntax { + public static var unexpectedBeforeComma: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, UnexpectedNodesSyntax?> { + .init(0) + } + + public static var comma: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, TokenSyntax> { + .init(1) + } + + public static var unexpectedBetweenCommaAndLabel: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, UnexpectedNodesSyntax?> { + .init(2) + } + + public static var label: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, TokenSyntax> { + .init(3) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, UnexpectedNodesSyntax?> { + .init(4) + } + + public static var colon: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, TokenSyntax> { + .init(5) + } + + public static var unexpectedBetweenColonAndVersion: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, UnexpectedNodesSyntax?> { + .init(6) + } + + public static var version: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, VersionTupleSyntax> { + .init(7) + } + + public static var unexpectedAfterVersion: ConcreteSyntaxProperty<_CanImportVersionInfoSyntax, UnexpectedNodesSyntax?> { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == CatchClauseSyntax { + public static var unexpectedBeforeCatchKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var catchKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenCatchKeywordAndCatchItems: ConcreteSyntaxProperty { + .init(2) + } + + public static var catchItems: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenCatchItemsAndBody: ConcreteSyntaxProperty { + .init(4) + } + + public static var body: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == CatchItemSyntax { + public static var unexpectedBeforePattern: ConcreteSyntaxProperty { + .init(0) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPatternAndWhereClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var whereClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenWhereClauseAndTrailingComma: ConcreteSyntaxProperty { + .init(4) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ClassDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndClassKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var classKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenClassKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndInheritanceClause: ConcreteSyntaxProperty { + .init(10) + } + + public static var inheritanceClause: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenInheritanceClauseAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndMemberBlock: ConcreteSyntaxProperty { + .init(14) + } + + public static var memberBlock: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterMemberBlock: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == ClassRestrictionTypeSyntax { + public static var unexpectedBeforeClassKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var classKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterClassKeyword: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureCaptureClauseSyntax { + public static var unexpectedBeforeLeftSquare: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftSquare: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftSquareAndItems: ConcreteSyntaxProperty { + .init(2) + } + + public static var items: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenItemsAndRightSquare: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightSquare: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightSquare: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureCaptureSpecifierSyntax { + public static var unexpectedBeforeSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var specifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenSpecifierAndLeftParen: ConcreteSyntaxProperty { + .init(2) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLeftParenAndDetail: ConcreteSyntaxProperty { + .init(4) + } + + public static var detail: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenDetailAndRightParen: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureCaptureSyntax { + public static var unexpectedBeforeSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var specifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenSpecifierAndName: ConcreteSyntaxProperty { + .init(2) + } + + public static var name: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenNameAndInitializer: ConcreteSyntaxProperty { + .init(4) + } + + public static var initializer: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenInitializerAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureExprSyntax { + public static var unexpectedBeforeLeftBrace: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftBrace: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftBraceAndSignature: ConcreteSyntaxProperty { + .init(2) + } + + public static var signature: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenSignatureAndStatements: ConcreteSyntaxProperty { + .init(4) + } + + public static var statements: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenStatementsAndRightBrace: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightBrace: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterRightBrace: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureParameterClauseSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndParameters: ConcreteSyntaxProperty { + .init(2) + } + + public static var parameters: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenParametersAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureParameterSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndFirstName: ConcreteSyntaxProperty { + .init(4) + } + + public static var firstName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenFirstNameAndSecondName: ConcreteSyntaxProperty { + .init(6) + } + + public static var secondName: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenSecondNameAndColon: ConcreteSyntaxProperty { + .init(8) + } + + public static var colon: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenColonAndType: ConcreteSyntaxProperty { + .init(10) + } + + public static var type: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenTypeAndEllipsis: ConcreteSyntaxProperty { + .init(12) + } + + public static var ellipsis: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenEllipsisAndTrailingComma: ConcreteSyntaxProperty { + .init(14) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureShorthandParameterSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ClosureSignatureSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndCapture: ConcreteSyntaxProperty { + .init(2) + } + + public static var capture: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenCaptureAndParameterClause: ConcreteSyntaxProperty { + .init(4) + } + + public static var parameterClause: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenParameterClauseAndEffectSpecifiers: ConcreteSyntaxProperty { + .init(6) + } + + public static var effectSpecifiers: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenEffectSpecifiersAndReturnClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var returnClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenReturnClauseAndInKeyword: ConcreteSyntaxProperty { + .init(10) + } + + public static var inKeyword: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedAfterInKeyword: ConcreteSyntaxProperty { + .init(12) + } +} + +extension ConcreteSyntaxProperty where Base == CodeBlockItemSyntax { + public static var unexpectedBeforeItem: ConcreteSyntaxProperty { + .init(0) + } + + public static var item: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenItemAndSemicolon: ConcreteSyntaxProperty { + .init(2) + } + + public static var semicolon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterSemicolon: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == CodeBlockSyntax { + public static var unexpectedBeforeLeftBrace: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftBrace: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftBraceAndStatements: ConcreteSyntaxProperty { + .init(2) + } + + public static var statements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenStatementsAndRightBrace: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightBrace: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightBrace: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == CompositionTypeElementSyntax { + public static var unexpectedBeforeType: ConcreteSyntaxProperty { + .init(0) + } + + public static var type: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenTypeAndAmpersand: ConcreteSyntaxProperty { + .init(2) + } + + public static var ampersand: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterAmpersand: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == CompositionTypeSyntax { + public static var unexpectedBeforeElements: ConcreteSyntaxProperty { + .init(0) + } + + public static var elements: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterElements: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == ConditionElementSyntax { + public static var unexpectedBeforeCondition: ConcreteSyntaxProperty { + .init(0) + } + + public static var condition: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenConditionAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ConformanceRequirementSyntax { + public static var unexpectedBeforeLeftType: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftType: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftTypeAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndRightType: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightType: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightType: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ConsumeExprSyntax { + public static var unexpectedBeforeConsumeKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var consumeKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenConsumeKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ContinueStmtSyntax { + public static var unexpectedBeforeContinueKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var continueKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenContinueKeywordAndLabel: ConcreteSyntaxProperty { + .init(2) + } + + public static var label: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterLabel: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ConventionAttributeArgumentsSyntax { + public static var unexpectedBeforeConventionLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var conventionLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenConventionLabelAndComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var comma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenCommaAndCTypeLabel: ConcreteSyntaxProperty { + .init(4) + } + + public static var cTypeLabel: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenCTypeLabelAndColon: ConcreteSyntaxProperty { + .init(6) + } + + public static var colon: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenColonAndCTypeString: ConcreteSyntaxProperty { + .init(8) + } + + public static var cTypeString: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterCTypeString: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == ConventionWitnessMethodAttributeArgumentsSyntax { + public static var unexpectedBeforeWitnessMethodLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var witnessMethodLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWitnessMethodLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndProtocolName: ConcreteSyntaxProperty { + .init(4) + } + + public static var protocolName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterProtocolName: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == CopyExprSyntax { + public static var unexpectedBeforeCopyKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var copyKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenCopyKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == DeclModifierDetailSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndDetail: ConcreteSyntaxProperty { + .init(2) + } + + public static var detail: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenDetailAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == DeclModifierSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndDetail: ConcreteSyntaxProperty { + .init(2) + } + + public static var detail: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterDetail: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == DeclNameArgumentSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterColon: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == DeclNameArgumentsSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndArguments: ConcreteSyntaxProperty { + .init(2) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == DeclReferenceExprSyntax { + public static var unexpectedBeforeBaseName: ConcreteSyntaxProperty { + .init(0) + } + + public static var baseName: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBaseNameAndArgumentNames: ConcreteSyntaxProperty { + .init(2) + } + + public static var argumentNames: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterArgumentNames: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == DeferStmtSyntax { + public static var unexpectedBeforeDeferKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var deferKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDeferKeywordAndBody: ConcreteSyntaxProperty { + .init(2) + } + + public static var body: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == DeinitializerDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndDeinitKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var deinitKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenDeinitKeywordAndEffectSpecifiers: ConcreteSyntaxProperty { + .init(6) + } + + public static var effectSpecifiers: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenEffectSpecifiersAndBody: ConcreteSyntaxProperty { + .init(8) + } + + public static var body: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == DeinitializerEffectSpecifiersSyntax { + public static var unexpectedBeforeAsyncSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var asyncSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterAsyncSpecifier: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == DerivativeAttributeArgumentsSyntax { + public static var unexpectedBeforeOfLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var ofLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenOfLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndOriginalDeclName: ConcreteSyntaxProperty { + .init(4) + } + + public static var originalDeclName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenOriginalDeclNameAndPeriod: ConcreteSyntaxProperty { + .init(6) + } + + public static var period: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenPeriodAndAccessorSpecifier: ConcreteSyntaxProperty { + .init(8) + } + + public static var accessorSpecifier: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenAccessorSpecifierAndComma: ConcreteSyntaxProperty { + .init(10) + } + + public static var comma: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenCommaAndArguments: ConcreteSyntaxProperty { + .init(12) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterArguments: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == DesignatedTypeSyntax { + public static var unexpectedBeforeLeadingComma: ConcreteSyntaxProperty { + .init(0) + } + + public static var leadingComma: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeadingCommaAndName: ConcreteSyntaxProperty { + .init(2) + } + + public static var name: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterName: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == DictionaryElementSyntax { + public static var unexpectedBeforeKey: ConcreteSyntaxProperty { + .init(0) + } + + public static var key: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenKeyAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndValue: ConcreteSyntaxProperty { + .init(4) + } + + public static var value: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenValueAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == DictionaryExprSyntax { + public static var unexpectedBeforeLeftSquare: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftSquare: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftSquareAndContent: ConcreteSyntaxProperty { + .init(2) + } + + public static var content: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenContentAndRightSquare: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightSquare: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightSquare: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == DictionaryTypeSyntax { + public static var unexpectedBeforeLeftSquare: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftSquare: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftSquareAndKey: ConcreteSyntaxProperty { + .init(2) + } + + public static var key: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenKeyAndColon: ConcreteSyntaxProperty { + .init(4) + } + + public static var colon: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenColonAndValue: ConcreteSyntaxProperty { + .init(6) + } + + public static var value: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenValueAndRightSquare: ConcreteSyntaxProperty { + .init(8) + } + + public static var rightSquare: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterRightSquare: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == DifferentiabilityArgumentSyntax { + public static var unexpectedBeforeArgument: ConcreteSyntaxProperty { + .init(0) + } + + public static var argument: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenArgumentAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == DifferentiabilityArgumentsSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndArguments: ConcreteSyntaxProperty { + .init(2) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == DifferentiabilityWithRespectToArgumentSyntax { + public static var unexpectedBeforeWrtLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var wrtLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWrtLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndArguments: ConcreteSyntaxProperty { + .init(4) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterArguments: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == DifferentiableAttributeArgumentsSyntax { + public static var unexpectedBeforeKindSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var kindSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenKindSpecifierAndKindSpecifierComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var kindSpecifierComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenKindSpecifierCommaAndArguments: ConcreteSyntaxProperty { + .init(4) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenArgumentsAndArgumentsComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var argumentsComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenArgumentsCommaAndGenericWhereClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterGenericWhereClause: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == DiscardAssignmentExprSyntax { + public static var unexpectedBeforeWildcard: ConcreteSyntaxProperty { + .init(0) + } + + public static var wildcard: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterWildcard: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == DiscardStmtSyntax { + public static var unexpectedBeforeDiscardKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var discardKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDiscardKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +extension ConcreteSyntaxProperty where Base == DoExprSyntax { + public static var unexpectedBeforeDoKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var doKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDoKeywordAndBody: ConcreteSyntaxProperty { + .init(2) + } + + public static var body: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenBodyAndCatchClauses: ConcreteSyntaxProperty { + .init(4) + } + + public static var catchClauses: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterCatchClauses: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == DoStmtSyntax { + public static var unexpectedBeforeDoKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var doKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDoKeywordAndThrowsClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var throwsClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenThrowsClauseAndBody: ConcreteSyntaxProperty { + .init(4) + } + + public static var body: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenBodyAndCatchClauses: ConcreteSyntaxProperty { + .init(6) + } + + public static var catchClauses: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterCatchClauses: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == DocumentationAttributeArgumentSyntax { + public static var unexpectedBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var label: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndValue: ConcreteSyntaxProperty { + .init(4) + } + + public static var value: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenValueAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == DynamicReplacementAttributeArgumentsSyntax { + public static var unexpectedBeforeForLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var forLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenForLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndDeclName: ConcreteSyntaxProperty { + .init(4) + } + + public static var declName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterDeclName: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == EditorPlaceholderDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndPlaceholder: ConcreteSyntaxProperty { + .init(4) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == EditorPlaceholderExprSyntax { + public static var unexpectedBeforePlaceholder: ConcreteSyntaxProperty { + .init(0) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == EnumCaseDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndCaseKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var caseKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenCaseKeywordAndElements: ConcreteSyntaxProperty { + .init(6) + } + + public static var elements: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterElements: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == EnumCaseElementSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndParameterClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var parameterClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenParameterClauseAndRawValue: ConcreteSyntaxProperty { + .init(4) + } + + public static var rawValue: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenRawValueAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == EnumCaseParameterClauseSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndParameters: ConcreteSyntaxProperty { + .init(2) + } + + public static var parameters: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenParametersAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == EnumCaseParameterSyntax { + public static var unexpectedBeforeModifiers: ConcreteSyntaxProperty { + .init(0) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenModifiersAndFirstName: ConcreteSyntaxProperty { + .init(2) + } + + public static var firstName: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenFirstNameAndSecondName: ConcreteSyntaxProperty { + .init(4) + } + + public static var secondName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenSecondNameAndColon: ConcreteSyntaxProperty { + .init(6) + } + + public static var colon: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenColonAndType: ConcreteSyntaxProperty { + .init(8) + } + + public static var type: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenTypeAndDefaultValue: ConcreteSyntaxProperty { + .init(10) + } + + public static var defaultValue: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenDefaultValueAndTrailingComma: ConcreteSyntaxProperty { + .init(12) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == EnumDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndEnumKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var enumKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenEnumKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndInheritanceClause: ConcreteSyntaxProperty { + .init(10) + } + + public static var inheritanceClause: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenInheritanceClauseAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndMemberBlock: ConcreteSyntaxProperty { + .init(14) + } + + public static var memberBlock: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterMemberBlock: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == ExposeAttributeArgumentsSyntax { + public static var unexpectedBeforeLanguage: ConcreteSyntaxProperty { + .init(0) + } + + public static var language: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLanguageAndComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var comma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenCommaAndCxxName: ConcreteSyntaxProperty { + .init(4) + } + + public static var cxxName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterCxxName: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ExpressionPatternSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == ExpressionSegmentSyntax { + public static var unexpectedBeforeBackslash: ConcreteSyntaxProperty { + .init(0) + } + + public static var backslash: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBackslashAndPounds: ConcreteSyntaxProperty { + .init(2) + } + + public static var pounds: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPoundsAndLeftParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenLeftParenAndExpressions: ConcreteSyntaxProperty { + .init(6) + } + + public static var expressions: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenExpressionsAndRightParen: ConcreteSyntaxProperty { + .init(8) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == ExpressionStmtSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == ExtensionDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndExtensionKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var extensionKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenExtensionKeywordAndExtendedType: ConcreteSyntaxProperty { + .init(6) + } + + public static var extendedType: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenExtendedTypeAndInheritanceClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var inheritanceClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenInheritanceClauseAndGenericWhereClause: ConcreteSyntaxProperty { + .init(10) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenGenericWhereClauseAndMemberBlock: ConcreteSyntaxProperty { + .init(12) + } + + public static var memberBlock: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterMemberBlock: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == FallThroughStmtSyntax { + public static var unexpectedBeforeFallthroughKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var fallthroughKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterFallthroughKeyword: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == FloatLiteralExprSyntax { + public static var unexpectedBeforeLiteral: ConcreteSyntaxProperty { + .init(0) + } + + public static var literal: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterLiteral: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == ForStmtSyntax { + public static var unexpectedBeforeForKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var forKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenForKeywordAndTryKeyword: ConcreteSyntaxProperty { + .init(2) + } + + public static var tryKeyword: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenTryKeywordAndAwaitKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var awaitKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenAwaitKeywordAndCaseKeyword: ConcreteSyntaxProperty { + .init(6) + } + + public static var caseKeyword: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenCaseKeywordAndPattern: ConcreteSyntaxProperty { + .init(8) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenPatternAndTypeAnnotation: ConcreteSyntaxProperty { + .init(10) + } + + public static var typeAnnotation: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenTypeAnnotationAndInKeyword: ConcreteSyntaxProperty { + .init(12) + } + + public static var inKeyword: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenInKeywordAndSequence: ConcreteSyntaxProperty { + .init(14) + } + + public static var sequence: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedBetweenSequenceAndWhereClause: ConcreteSyntaxProperty { + .init(16) + } + + public static var whereClause: ConcreteSyntaxProperty { + .init(17) + } + + public static var unexpectedBetweenWhereClauseAndBody: ConcreteSyntaxProperty { + .init(18) + } + + public static var body: ConcreteSyntaxProperty { + .init(19) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(20) + } +} + +extension ConcreteSyntaxProperty where Base == ForceUnwrapExprSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndExclamationMark: ConcreteSyntaxProperty { + .init(2) + } + + public static var exclamationMark: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExclamationMark: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == FunctionCallExprSyntax { + public static var unexpectedBeforeCalledExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var calledExpression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenCalledExpressionAndLeftParen: ConcreteSyntaxProperty { + .init(2) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLeftParenAndArguments: ConcreteSyntaxProperty { + .init(4) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenRightParenAndTrailingClosure: ConcreteSyntaxProperty { + .init(8) + } + + public static var trailingClosure: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(10) + } + + public static var additionalTrailingClosures: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedAfterAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(12) + } +} + +extension ConcreteSyntaxProperty where Base == FunctionDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndFuncKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var funcKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenFuncKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndSignature: ConcreteSyntaxProperty { + .init(10) + } + + public static var signature: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenSignatureAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndBody: ConcreteSyntaxProperty { + .init(14) + } + + public static var body: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == FunctionEffectSpecifiersSyntax { + public static var unexpectedBeforeAsyncSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var asyncSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAsyncSpecifierAndThrowsClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var throwsClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterThrowsClause: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == FunctionParameterClauseSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndParameters: ConcreteSyntaxProperty { + .init(2) + } + + public static var parameters: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenParametersAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == FunctionParameterSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndFirstName: ConcreteSyntaxProperty { + .init(4) + } + + public static var firstName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenFirstNameAndSecondName: ConcreteSyntaxProperty { + .init(6) + } + + public static var secondName: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenSecondNameAndColon: ConcreteSyntaxProperty { + .init(8) + } + + public static var colon: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenColonAndType: ConcreteSyntaxProperty { + .init(10) + } + + public static var type: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenTypeAndEllipsis: ConcreteSyntaxProperty { + .init(12) + } + + public static var ellipsis: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenEllipsisAndDefaultValue: ConcreteSyntaxProperty { + .init(14) + } + + public static var defaultValue: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedBetweenDefaultValueAndTrailingComma: ConcreteSyntaxProperty { + .init(16) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(17) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(18) + } +} + +extension ConcreteSyntaxProperty where Base == FunctionSignatureSyntax { + public static var unexpectedBeforeParameterClause: ConcreteSyntaxProperty { + .init(0) + } + + public static var parameterClause: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenParameterClauseAndEffectSpecifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var effectSpecifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenEffectSpecifiersAndReturnClause: ConcreteSyntaxProperty { + .init(4) + } + + public static var returnClause: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterReturnClause: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == FunctionTypeSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndParameters: ConcreteSyntaxProperty { + .init(2) + } + + public static var parameters: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenParametersAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenRightParenAndEffectSpecifiers: ConcreteSyntaxProperty { + .init(6) + } + + public static var effectSpecifiers: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenEffectSpecifiersAndReturnClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var returnClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterReturnClause: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == GenericArgumentClauseSyntax { + public static var unexpectedBeforeLeftAngle: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftAngle: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftAngleAndArguments: ConcreteSyntaxProperty { + .init(2) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenArgumentsAndRightAngle: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightAngle: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightAngle: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == GenericArgumentSyntax { + public static var unexpectedBeforeArgument: ConcreteSyntaxProperty { + .init(0) + } + + public static var argument: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenArgumentAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == GenericParameterClauseSyntax { + public static var unexpectedBeforeLeftAngle: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftAngle: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftAngleAndParameters: ConcreteSyntaxProperty { + .init(2) + } + + public static var parameters: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenParametersAndGenericWhereClause: ConcreteSyntaxProperty { + .init(4) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenGenericWhereClauseAndRightAngle: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightAngle: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterRightAngle: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == GenericParameterSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndSpecifier: ConcreteSyntaxProperty { + .init(2) + } + + public static var specifier: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenSpecifierAndName: ConcreteSyntaxProperty { + .init(4) + } + + public static var name: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenNameAndColon: ConcreteSyntaxProperty { + .init(6) + } + + public static var colon: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenColonAndInheritedType: ConcreteSyntaxProperty { + .init(8) + } + + public static var inheritedType: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenInheritedTypeAndTrailingComma: ConcreteSyntaxProperty { + .init(10) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(12) + } +} + +extension ConcreteSyntaxProperty where Base == GenericRequirementSyntax { + public static var unexpectedBeforeRequirement: ConcreteSyntaxProperty { + .init(0) + } + + public static var requirement: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenRequirementAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == GenericSpecializationExprSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndGenericArgumentClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var genericArgumentClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterGenericArgumentClause: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == GenericWhereClauseSyntax { + public static var unexpectedBeforeWhereKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var whereKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWhereKeywordAndRequirements: ConcreteSyntaxProperty { + .init(2) + } + + public static var requirements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterRequirements: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == GuardStmtSyntax { + public static var unexpectedBeforeGuardKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var guardKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenGuardKeywordAndConditions: ConcreteSyntaxProperty { + .init(2) + } + + public static var conditions: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenConditionsAndElseKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var elseKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenElseKeywordAndBody: ConcreteSyntaxProperty { + .init(6) + } + + public static var body: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == IdentifierPatternSyntax { + public static var unexpectedBeforeIdentifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var identifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterIdentifier: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == IdentifierTypeSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndGenericArgumentClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var genericArgumentClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterGenericArgumentClause: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == IfConfigClauseSyntax { + public static var unexpectedBeforePoundKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var poundKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPoundKeywordAndCondition: ConcreteSyntaxProperty { + .init(2) + } + + public static var condition: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenConditionAndElements: ConcreteSyntaxProperty { + .init(4) + } + + public static var elements: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterElements: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == IfConfigDeclSyntax { + public static var unexpectedBeforeClauses: ConcreteSyntaxProperty { + .init(0) + } + + public static var clauses: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenClausesAndPoundEndif: ConcreteSyntaxProperty { + .init(2) + } + + public static var poundEndif: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterPoundEndif: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == IfExprSyntax { + public static var unexpectedBeforeIfKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var ifKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenIfKeywordAndConditions: ConcreteSyntaxProperty { + .init(2) + } + + public static var conditions: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenConditionsAndBody: ConcreteSyntaxProperty { + .init(4) + } + + public static var body: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenBodyAndElseKeyword: ConcreteSyntaxProperty { + .init(6) + } + + public static var elseKeyword: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenElseKeywordAndElseBody: ConcreteSyntaxProperty { + .init(8) + } + + public static var elseBody: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterElseBody: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == ImplementsAttributeArgumentsSyntax { + public static var unexpectedBeforeType: ConcreteSyntaxProperty { + .init(0) + } + + public static var type: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenTypeAndComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var comma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenCommaAndDeclName: ConcreteSyntaxProperty { + .init(4) + } + + public static var declName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterDeclName: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == ImplicitlyUnwrappedOptionalTypeSyntax { + public static var unexpectedBeforeWrappedType: ConcreteSyntaxProperty { + .init(0) + } + + public static var wrappedType: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWrappedTypeAndExclamationMark: ConcreteSyntaxProperty { + .init(2) + } + + public static var exclamationMark: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExclamationMark: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ImportDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndImportKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var importKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenImportKeywordAndImportKindSpecifier: ConcreteSyntaxProperty { + .init(6) + } + + public static var importKindSpecifier: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenImportKindSpecifierAndPath: ConcreteSyntaxProperty { + .init(8) + } + + public static var path: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterPath: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == ImportPathComponentSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndTrailingPeriod: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingPeriod: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingPeriod: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == InOutExprSyntax { + public static var unexpectedBeforeAmpersand: ConcreteSyntaxProperty { + .init(0) + } + + public static var ampersand: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAmpersandAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == InfixOperatorExprSyntax { + public static var unexpectedBeforeLeftOperand: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftOperand: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftOperandAndOperator: ConcreteSyntaxProperty { + .init(2) + } + + public static var `operator`: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenOperatorAndRightOperand: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightOperand: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightOperand: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == InheritanceClauseSyntax { + public static var unexpectedBeforeColon: ConcreteSyntaxProperty { + .init(0) + } + + public static var colon: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenColonAndInheritedTypes: ConcreteSyntaxProperty { + .init(2) + } + + public static var inheritedTypes: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterInheritedTypes: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == InheritedTypeSyntax { + public static var unexpectedBeforeType: ConcreteSyntaxProperty { + .init(0) + } + + public static var type: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenTypeAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == InitializerClauseSyntax { + public static var unexpectedBeforeEqual: ConcreteSyntaxProperty { + .init(0) + } + + public static var equal: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenEqualAndValue: ConcreteSyntaxProperty { + .init(2) + } + + public static var value: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterValue: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == InitializerDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndInitKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var initKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenInitKeywordAndOptionalMark: ConcreteSyntaxProperty { + .init(6) + } + + public static var optionalMark: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenOptionalMarkAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndSignature: ConcreteSyntaxProperty { + .init(10) + } + + public static var signature: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenSignatureAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndBody: ConcreteSyntaxProperty { + .init(14) + } + + public static var body: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == IntegerLiteralExprSyntax { + public static var unexpectedBeforeLiteral: ConcreteSyntaxProperty { + .init(0) + } + + public static var literal: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterLiteral: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == IsExprSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndIsKeyword: ConcreteSyntaxProperty { + .init(2) + } + + public static var isKeyword: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenIsKeywordAndType: ConcreteSyntaxProperty { + .init(4) + } + + public static var type: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == IsTypePatternSyntax { + public static var unexpectedBeforeIsKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var isKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenIsKeywordAndType: ConcreteSyntaxProperty { + .init(2) + } + + public static var type: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == KeyPathComponentSyntax { + public static var unexpectedBeforePeriod: ConcreteSyntaxProperty { + .init(0) + } + + public static var period: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPeriodAndComponent: ConcreteSyntaxProperty { + .init(2) + } + + public static var component: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterComponent: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == KeyPathExprSyntax { + public static var unexpectedBeforeBackslash: ConcreteSyntaxProperty { + .init(0) + } + + public static var backslash: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBackslashAndRoot: ConcreteSyntaxProperty { + .init(2) + } + + public static var root: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenRootAndComponents: ConcreteSyntaxProperty { + .init(4) + } + + public static var components: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterComponents: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == KeyPathOptionalComponentSyntax { + public static var unexpectedBeforeQuestionOrExclamationMark: ConcreteSyntaxProperty { + .init(0) + } + + public static var questionOrExclamationMark: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterQuestionOrExclamationMark: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == KeyPathPropertyComponentSyntax { + public static var unexpectedBeforeDeclName: ConcreteSyntaxProperty { + .init(0) + } + + public static var declName: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDeclNameAndGenericArgumentClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var genericArgumentClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterGenericArgumentClause: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == KeyPathSubscriptComponentSyntax { + public static var unexpectedBeforeLeftSquare: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftSquare: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftSquareAndArguments: ConcreteSyntaxProperty { + .init(2) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenArgumentsAndRightSquare: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightSquare: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightSquare: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == LabeledExprSyntax { + public static var unexpectedBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var label: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndExpression: ConcreteSyntaxProperty { + .init(4) + } + + public static var expression: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenExpressionAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == LabeledSpecializeArgumentSyntax { + public static var unexpectedBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var label: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndValue: ConcreteSyntaxProperty { + .init(4) + } + + public static var value: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenValueAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == LabeledStmtSyntax { + public static var unexpectedBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var label: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndStatement: ConcreteSyntaxProperty { + .init(4) + } + + public static var statement: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterStatement: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == LayoutRequirementSyntax { + public static var unexpectedBeforeType: ConcreteSyntaxProperty { + .init(0) + } + + public static var type: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenTypeAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndLayoutSpecifier: ConcreteSyntaxProperty { + .init(4) + } + + public static var layoutSpecifier: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenLayoutSpecifierAndLeftParen: ConcreteSyntaxProperty { + .init(6) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenLeftParenAndSize: ConcreteSyntaxProperty { + .init(8) + } + + public static var size: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenSizeAndComma: ConcreteSyntaxProperty { + .init(10) + } + + public static var comma: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenCommaAndAlignment: ConcreteSyntaxProperty { + .init(12) + } + + public static var alignment: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenAlignmentAndRightParen: ConcreteSyntaxProperty { + .init(14) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(16) + } +} + +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +extension ConcreteSyntaxProperty where Base == LifetimeSpecifierArgumentSyntax { + public static var unexpectedBeforeParameter: ConcreteSyntaxProperty { + .init(0) + } + + public static var parameter: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenParameterAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +extension ConcreteSyntaxProperty where Base == LifetimeTypeSpecifierSyntax { + public static var unexpectedBeforeDependsOnKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var dependsOnKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDependsOnKeywordAndLeftParen: ConcreteSyntaxProperty { + .init(2) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLeftParenAndScopedKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var scopedKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenScopedKeywordAndArguments: ConcreteSyntaxProperty { + .init(6) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(8) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == MacroDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndMacroKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var macroKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenMacroKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndSignature: ConcreteSyntaxProperty { + .init(10) + } + + public static var signature: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenSignatureAndDefinition: ConcreteSyntaxProperty { + .init(12) + } + + public static var definition: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenDefinitionAndGenericWhereClause: ConcreteSyntaxProperty { + .init(14) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterGenericWhereClause: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == MacroExpansionDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndPound: ConcreteSyntaxProperty { + .init(4) + } + + public static var pound: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenPoundAndMacroName: ConcreteSyntaxProperty { + .init(6) + } + + public static var macroName: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenMacroNameAndGenericArgumentClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericArgumentClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericArgumentClauseAndLeftParen: ConcreteSyntaxProperty { + .init(10) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenLeftParenAndArguments: ConcreteSyntaxProperty { + .init(12) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(14) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedBetweenRightParenAndTrailingClosure: ConcreteSyntaxProperty { + .init(16) + } + + public static var trailingClosure: ConcreteSyntaxProperty { + .init(17) + } + + public static var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(18) + } + + public static var additionalTrailingClosures: ConcreteSyntaxProperty { + .init(19) + } + + public static var unexpectedAfterAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(20) + } +} + +extension ConcreteSyntaxProperty where Base == MacroExpansionExprSyntax { + public static var unexpectedBeforePound: ConcreteSyntaxProperty { + .init(0) + } + + public static var pound: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPoundAndMacroName: ConcreteSyntaxProperty { + .init(2) + } + + public static var macroName: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenMacroNameAndGenericArgumentClause: ConcreteSyntaxProperty { + .init(4) + } + + public static var genericArgumentClause: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenGenericArgumentClauseAndLeftParen: ConcreteSyntaxProperty { + .init(6) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenLeftParenAndArguments: ConcreteSyntaxProperty { + .init(8) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(10) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenRightParenAndTrailingClosure: ConcreteSyntaxProperty { + .init(12) + } + + public static var trailingClosure: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(14) + } + + public static var additionalTrailingClosures: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == MatchingPatternConditionSyntax { + public static var unexpectedBeforeCaseKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var caseKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenCaseKeywordAndPattern: ConcreteSyntaxProperty { + .init(2) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPatternAndTypeAnnotation: ConcreteSyntaxProperty { + .init(4) + } + + public static var typeAnnotation: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenTypeAnnotationAndInitializer: ConcreteSyntaxProperty { + .init(6) + } + + public static var initializer: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterInitializer: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == MemberAccessExprSyntax { + public static var unexpectedBeforeBase: ConcreteSyntaxProperty { + .init(0) + } + + public static var base: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBaseAndPeriod: ConcreteSyntaxProperty { + .init(2) + } + + public static var period: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPeriodAndDeclName: ConcreteSyntaxProperty { + .init(4) + } + + public static var declName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterDeclName: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == MemberBlockItemSyntax { + public static var unexpectedBeforeDecl: ConcreteSyntaxProperty { + .init(0) + } + + public static var decl: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDeclAndSemicolon: ConcreteSyntaxProperty { + .init(2) + } + + public static var semicolon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterSemicolon: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == MemberBlockSyntax { + public static var unexpectedBeforeLeftBrace: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftBrace: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftBraceAndMembers: ConcreteSyntaxProperty { + .init(2) + } + + public static var members: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenMembersAndRightBrace: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightBrace: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightBrace: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == MemberTypeSyntax { + public static var unexpectedBeforeBaseType: ConcreteSyntaxProperty { + .init(0) + } + + public static var baseType: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBaseTypeAndPeriod: ConcreteSyntaxProperty { + .init(2) + } + + public static var period: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPeriodAndName: ConcreteSyntaxProperty { + .init(4) + } + + public static var name: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenNameAndGenericArgumentClause: ConcreteSyntaxProperty { + .init(6) + } + + public static var genericArgumentClause: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterGenericArgumentClause: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == MetatypeTypeSyntax { + public static var unexpectedBeforeBaseType: ConcreteSyntaxProperty { + .init(0) + } + + public static var baseType: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBaseTypeAndPeriod: ConcreteSyntaxProperty { + .init(2) + } + + public static var period: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPeriodAndMetatypeSpecifier: ConcreteSyntaxProperty { + .init(4) + } + + public static var metatypeSpecifier: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterMetatypeSpecifier: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == MissingDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndPlaceholder: ConcreteSyntaxProperty { + .init(4) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == MissingExprSyntax { + public static var unexpectedBeforePlaceholder: ConcreteSyntaxProperty { + .init(0) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == MissingPatternSyntax { + public static var unexpectedBeforePlaceholder: ConcreteSyntaxProperty { + .init(0) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == MissingStmtSyntax { + public static var unexpectedBeforePlaceholder: ConcreteSyntaxProperty { + .init(0) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == MissingSyntax { + public static var unexpectedBeforePlaceholder: ConcreteSyntaxProperty { + .init(0) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == MissingTypeSyntax { + public static var unexpectedBeforePlaceholder: ConcreteSyntaxProperty { + .init(0) + } + + public static var placeholder: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterPlaceholder: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == MultipleTrailingClosureElementSyntax { + public static var unexpectedBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var label: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndClosure: ConcreteSyntaxProperty { + .init(4) + } + + public static var closure: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterClosure: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == NamedOpaqueReturnTypeSyntax { + public static var unexpectedBeforeGenericParameterClause: ConcreteSyntaxProperty { + .init(0) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenGenericParameterClauseAndType: ConcreteSyntaxProperty { + .init(2) + } + + public static var type: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == NilLiteralExprSyntax { + public static var unexpectedBeforeNilKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var nilKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterNilKeyword: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == ObjCSelectorPieceSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterColon: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == OpaqueReturnTypeOfAttributeArgumentsSyntax { + public static var unexpectedBeforeMangledName: ConcreteSyntaxProperty { + .init(0) + } + + public static var mangledName: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenMangledNameAndComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var comma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenCommaAndOrdinal: ConcreteSyntaxProperty { + .init(4) + } + + public static var ordinal: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterOrdinal: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == OperatorDeclSyntax { + public static var unexpectedBeforeFixitySpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var fixitySpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenFixitySpecifierAndOperatorKeyword: ConcreteSyntaxProperty { + .init(2) + } + + public static var operatorKeyword: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenOperatorKeywordAndName: ConcreteSyntaxProperty { + .init(4) + } + + public static var name: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenNameAndOperatorPrecedenceAndTypes: ConcreteSyntaxProperty { + .init(6) + } + + public static var operatorPrecedenceAndTypes: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterOperatorPrecedenceAndTypes: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == OperatorPrecedenceAndTypesSyntax { + public static var unexpectedBeforeColon: ConcreteSyntaxProperty { + .init(0) + } + + public static var colon: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenColonAndPrecedenceGroup: ConcreteSyntaxProperty { + .init(2) + } + + public static var precedenceGroup: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPrecedenceGroupAndDesignatedTypes: ConcreteSyntaxProperty { + .init(4) + } + + public static var designatedTypes: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterDesignatedTypes: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == OptionalBindingConditionSyntax { + public static var unexpectedBeforeBindingSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var bindingSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBindingSpecifierAndPattern: ConcreteSyntaxProperty { + .init(2) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPatternAndTypeAnnotation: ConcreteSyntaxProperty { + .init(4) + } + + public static var typeAnnotation: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenTypeAnnotationAndInitializer: ConcreteSyntaxProperty { + .init(6) + } + + public static var initializer: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterInitializer: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == OptionalChainingExprSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndQuestionMark: ConcreteSyntaxProperty { + .init(2) + } + + public static var questionMark: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterQuestionMark: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == OptionalTypeSyntax { + public static var unexpectedBeforeWrappedType: ConcreteSyntaxProperty { + .init(0) + } + + public static var wrappedType: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWrappedTypeAndQuestionMark: ConcreteSyntaxProperty { + .init(2) + } + + public static var questionMark: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterQuestionMark: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == OriginallyDefinedInAttributeArgumentsSyntax { + public static var unexpectedBeforeModuleLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var moduleLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenModuleLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndModuleName: ConcreteSyntaxProperty { + .init(4) + } + + public static var moduleName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenModuleNameAndComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var comma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenCommaAndPlatforms: ConcreteSyntaxProperty { + .init(8) + } + + public static var platforms: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterPlatforms: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == PackElementExprSyntax { + public static var unexpectedBeforeEachKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var eachKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenEachKeywordAndPack: ConcreteSyntaxProperty { + .init(2) + } + + public static var pack: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterPack: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PackElementTypeSyntax { + public static var unexpectedBeforeEachKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var eachKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenEachKeywordAndPack: ConcreteSyntaxProperty { + .init(2) + } + + public static var pack: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterPack: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PackExpansionExprSyntax { + public static var unexpectedBeforeRepeatKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var repeatKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenRepeatKeywordAndRepetitionPattern: ConcreteSyntaxProperty { + .init(2) + } + + public static var repetitionPattern: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterRepetitionPattern: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PackExpansionTypeSyntax { + public static var unexpectedBeforeRepeatKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var repeatKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenRepeatKeywordAndRepetitionPattern: ConcreteSyntaxProperty { + .init(2) + } + + public static var repetitionPattern: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterRepetitionPattern: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PatternBindingSyntax { + public static var unexpectedBeforePattern: ConcreteSyntaxProperty { + .init(0) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPatternAndTypeAnnotation: ConcreteSyntaxProperty { + .init(2) + } + + public static var typeAnnotation: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenTypeAnnotationAndInitializer: ConcreteSyntaxProperty { + .init(4) + } + + public static var initializer: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenInitializerAndAccessorBlock: ConcreteSyntaxProperty { + .init(6) + } + + public static var accessorBlock: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenAccessorBlockAndTrailingComma: ConcreteSyntaxProperty { + .init(8) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == PatternExprSyntax { + public static var unexpectedBeforePattern: ConcreteSyntaxProperty { + .init(0) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterPattern: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == PlatformVersionItemSyntax { + public static var unexpectedBeforePlatformVersion: ConcreteSyntaxProperty { + .init(0) + } + + public static var platformVersion: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPlatformVersionAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PlatformVersionSyntax { + public static var unexpectedBeforePlatform: ConcreteSyntaxProperty { + .init(0) + } + + public static var platform: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPlatformAndVersion: ConcreteSyntaxProperty { + .init(2) + } + + public static var version: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterVersion: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PostfixIfConfigExprSyntax { + public static var unexpectedBeforeBase: ConcreteSyntaxProperty { + .init(0) + } + + public static var base: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBaseAndConfig: ConcreteSyntaxProperty { + .init(2) + } + + public static var config: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterConfig: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PostfixOperatorExprSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndOperator: ConcreteSyntaxProperty { + .init(2) + } + + public static var `operator`: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterOperator: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PoundSourceLocationArgumentsSyntax { + public static var unexpectedBeforeFileLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var fileLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenFileLabelAndFileColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var fileColon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenFileColonAndFileName: ConcreteSyntaxProperty { + .init(4) + } + + public static var fileName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenFileNameAndComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var comma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenCommaAndLineLabel: ConcreteSyntaxProperty { + .init(8) + } + + public static var lineLabel: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenLineLabelAndLineColon: ConcreteSyntaxProperty { + .init(10) + } + + public static var lineColon: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenLineColonAndLineNumber: ConcreteSyntaxProperty { + .init(12) + } + + public static var lineNumber: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterLineNumber: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == PoundSourceLocationSyntax { + public static var unexpectedBeforePoundSourceLocation: ConcreteSyntaxProperty { + .init(0) + } + + public static var poundSourceLocation: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPoundSourceLocationAndLeftParen: ConcreteSyntaxProperty { + .init(2) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLeftParenAndArguments: ConcreteSyntaxProperty { + .init(4) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenArgumentsAndRightParen: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == PrecedenceGroupAssignmentSyntax { + public static var unexpectedBeforeAssignmentLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var assignmentLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAssignmentLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndValue: ConcreteSyntaxProperty { + .init(4) + } + + public static var value: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterValue: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == PrecedenceGroupAssociativitySyntax { + public static var unexpectedBeforeAssociativityLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var associativityLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAssociativityLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndValue: ConcreteSyntaxProperty { + .init(4) + } + + public static var value: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterValue: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == PrecedenceGroupDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndPrecedencegroupKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var precedencegroupKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenPrecedencegroupKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndLeftBrace: ConcreteSyntaxProperty { + .init(8) + } + + public static var leftBrace: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenLeftBraceAndGroupAttributes: ConcreteSyntaxProperty { + .init(10) + } + + public static var groupAttributes: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenGroupAttributesAndRightBrace: ConcreteSyntaxProperty { + .init(12) + } + + public static var rightBrace: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterRightBrace: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == PrecedenceGroupNameSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PrecedenceGroupRelationSyntax { + public static var unexpectedBeforeHigherThanOrLowerThanLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var higherThanOrLowerThanLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenHigherThanOrLowerThanLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndPrecedenceGroups: ConcreteSyntaxProperty { + .init(4) + } + + public static var precedenceGroups: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterPrecedenceGroups: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == PrefixOperatorExprSyntax { + public static var unexpectedBeforeOperator: ConcreteSyntaxProperty { + .init(0) + } + + public static var `operator`: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenOperatorAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == PrimaryAssociatedTypeClauseSyntax { + public static var unexpectedBeforeLeftAngle: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftAngle: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes: ConcreteSyntaxProperty { + .init(2) + } + + public static var primaryAssociatedTypes: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenPrimaryAssociatedTypesAndRightAngle: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightAngle: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightAngle: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == PrimaryAssociatedTypeSyntax { + public static var unexpectedBeforeName: ConcreteSyntaxProperty { + .init(0) + } + + public static var name: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenNameAndTrailingComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ProtocolDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndProtocolKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var protocolKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenProtocolKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndPrimaryAssociatedTypeClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var primaryAssociatedTypeClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: ConcreteSyntaxProperty { + .init(10) + } + + public static var inheritanceClause: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenInheritanceClauseAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndMemberBlock: ConcreteSyntaxProperty { + .init(14) + } + + public static var memberBlock: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterMemberBlock: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == RegexLiteralExprSyntax { + public static var unexpectedBeforeOpeningPounds: ConcreteSyntaxProperty { + .init(0) + } + + public static var openingPounds: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenOpeningPoundsAndOpeningSlash: ConcreteSyntaxProperty { + .init(2) + } + + public static var openingSlash: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenOpeningSlashAndRegex: ConcreteSyntaxProperty { + .init(4) + } + + public static var regex: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenRegexAndClosingSlash: ConcreteSyntaxProperty { + .init(6) + } + + public static var closingSlash: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenClosingSlashAndClosingPounds: ConcreteSyntaxProperty { + .init(8) + } + + public static var closingPounds: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterClosingPounds: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == RepeatStmtSyntax { + public static var unexpectedBeforeRepeatKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var repeatKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenRepeatKeywordAndBody: ConcreteSyntaxProperty { + .init(2) + } + + public static var body: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenBodyAndWhileKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var whileKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenWhileKeywordAndCondition: ConcreteSyntaxProperty { + .init(6) + } + + public static var condition: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterCondition: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == ReturnClauseSyntax { + public static var unexpectedBeforeArrow: ConcreteSyntaxProperty { + .init(0) + } + + public static var arrow: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenArrowAndType: ConcreteSyntaxProperty { + .init(2) + } + + public static var type: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ReturnStmtSyntax { + public static var unexpectedBeforeReturnKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var returnKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenReturnKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == SameTypeRequirementSyntax { + public static var unexpectedBeforeLeftType: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftType: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftTypeAndEqual: ConcreteSyntaxProperty { + .init(2) + } + + public static var equal: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenEqualAndRightType: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightType: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightType: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == SequenceExprSyntax { + public static var unexpectedBeforeElements: ConcreteSyntaxProperty { + .init(0) + } + + public static var elements: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterElements: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == SimpleStringLiteralExprSyntax { + public static var unexpectedBeforeOpeningQuote: ConcreteSyntaxProperty { + .init(0) + } + + public static var openingQuote: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenOpeningQuoteAndSegments: ConcreteSyntaxProperty { + .init(2) + } + + public static var segments: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenSegmentsAndClosingQuote: ConcreteSyntaxProperty { + .init(4) + } + + public static var closingQuote: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterClosingQuote: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == SimpleTypeSpecifierSyntax { + public static var unexpectedBeforeSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var specifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterSpecifier: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == SomeOrAnyTypeSyntax { + public static var unexpectedBeforeSomeOrAnySpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var someOrAnySpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenSomeOrAnySpecifierAndConstraint: ConcreteSyntaxProperty { + .init(2) + } + + public static var constraint: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterConstraint: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == SourceFileSyntax { + public static var unexpectedBeforeShebang: ConcreteSyntaxProperty { + .init(0) + } + + public static var shebang: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenShebangAndStatements: ConcreteSyntaxProperty { + .init(2) + } + + public static var statements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenStatementsAndEndOfFileToken: ConcreteSyntaxProperty { + .init(4) + } + + public static var endOfFileToken: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterEndOfFileToken: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == SpecializeAvailabilityArgumentSyntax { + public static var unexpectedBeforeAvailabilityLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var availabilityLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAvailabilityLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndAvailabilityArguments: ConcreteSyntaxProperty { + .init(4) + } + + public static var availabilityArguments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenAvailabilityArgumentsAndSemicolon: ConcreteSyntaxProperty { + .init(6) + } + + public static var semicolon: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterSemicolon: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == SpecializeTargetFunctionArgumentSyntax { + public static var unexpectedBeforeTargetLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var targetLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenTargetLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndDeclName: ConcreteSyntaxProperty { + .init(4) + } + + public static var declName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenDeclNameAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == StringLiteralExprSyntax { + public static var unexpectedBeforeOpeningPounds: ConcreteSyntaxProperty { + .init(0) + } + + public static var openingPounds: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenOpeningPoundsAndOpeningQuote: ConcreteSyntaxProperty { + .init(2) + } + + public static var openingQuote: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenOpeningQuoteAndSegments: ConcreteSyntaxProperty { + .init(4) + } + + public static var segments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenSegmentsAndClosingQuote: ConcreteSyntaxProperty { + .init(6) + } + + public static var closingQuote: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenClosingQuoteAndClosingPounds: ConcreteSyntaxProperty { + .init(8) + } + + public static var closingPounds: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterClosingPounds: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == StringSegmentSyntax { + public static var unexpectedBeforeContent: ConcreteSyntaxProperty { + .init(0) + } + + public static var content: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterContent: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == StructDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndStructKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var structKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenStructKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndInheritanceClause: ConcreteSyntaxProperty { + .init(10) + } + + public static var inheritanceClause: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenInheritanceClauseAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndMemberBlock: ConcreteSyntaxProperty { + .init(14) + } + + public static var memberBlock: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterMemberBlock: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == SubscriptCallExprSyntax { + public static var unexpectedBeforeCalledExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var calledExpression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenCalledExpressionAndLeftSquare: ConcreteSyntaxProperty { + .init(2) + } + + public static var leftSquare: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLeftSquareAndArguments: ConcreteSyntaxProperty { + .init(4) + } + + public static var arguments: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenArgumentsAndRightSquare: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightSquare: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenRightSquareAndTrailingClosure: ConcreteSyntaxProperty { + .init(8) + } + + public static var trailingClosure: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(10) + } + + public static var additionalTrailingClosures: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedAfterAdditionalTrailingClosures: ConcreteSyntaxProperty { + .init(12) + } +} + +extension ConcreteSyntaxProperty where Base == SubscriptDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndSubscriptKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var subscriptKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenSubscriptKeywordAndGenericParameterClause: ConcreteSyntaxProperty { + .init(6) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenGenericParameterClauseAndParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var parameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenParameterClauseAndReturnClause: ConcreteSyntaxProperty { + .init(10) + } + + public static var returnClause: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenReturnClauseAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedBetweenGenericWhereClauseAndAccessorBlock: ConcreteSyntaxProperty { + .init(14) + } + + public static var accessorBlock: ConcreteSyntaxProperty { + .init(15) + } + + public static var unexpectedAfterAccessorBlock: ConcreteSyntaxProperty { + .init(16) + } +} + +extension ConcreteSyntaxProperty where Base == SuperExprSyntax { + public static var unexpectedBeforeSuperKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var superKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterSuperKeyword: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == SuppressedTypeSyntax { + public static var unexpectedBeforeWithoutTilde: ConcreteSyntaxProperty { + .init(0) + } + + public static var withoutTilde: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWithoutTildeAndType: ConcreteSyntaxProperty { + .init(2) + } + + public static var type: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == SwitchCaseItemSyntax { + public static var unexpectedBeforePattern: ConcreteSyntaxProperty { + .init(0) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPatternAndWhereClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var whereClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenWhereClauseAndTrailingComma: ConcreteSyntaxProperty { + .init(4) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == SwitchCaseLabelSyntax { + public static var unexpectedBeforeCaseKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var caseKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenCaseKeywordAndCaseItems: ConcreteSyntaxProperty { + .init(2) + } + + public static var caseItems: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenCaseItemsAndColon: ConcreteSyntaxProperty { + .init(4) + } + + public static var colon: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterColon: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == SwitchCaseSyntax { + public static var unexpectedBeforeAttribute: ConcreteSyntaxProperty { + .init(0) + } + + public static var attribute: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributeAndLabel: ConcreteSyntaxProperty { + .init(2) + } + + public static var label: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLabelAndStatements: ConcreteSyntaxProperty { + .init(4) + } + + public static var statements: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterStatements: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == SwitchDefaultLabelSyntax { + public static var unexpectedBeforeDefaultKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var defaultKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenDefaultKeywordAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterColon: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == SwitchExprSyntax { + public static var unexpectedBeforeSwitchKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var switchKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenSwitchKeywordAndSubject: ConcreteSyntaxProperty { + .init(2) + } + + public static var subject: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenSubjectAndLeftBrace: ConcreteSyntaxProperty { + .init(4) + } + + public static var leftBrace: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenLeftBraceAndCases: ConcreteSyntaxProperty { + .init(6) + } + + public static var cases: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenCasesAndRightBrace: ConcreteSyntaxProperty { + .init(8) + } + + public static var rightBrace: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterRightBrace: ConcreteSyntaxProperty { + .init(10) + } +} + +extension ConcreteSyntaxProperty where Base == TernaryExprSyntax { + public static var unexpectedBeforeCondition: ConcreteSyntaxProperty { + .init(0) + } + + public static var condition: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenConditionAndQuestionMark: ConcreteSyntaxProperty { + .init(2) + } + + public static var questionMark: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenQuestionMarkAndThenExpression: ConcreteSyntaxProperty { + .init(4) + } + + public static var thenExpression: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenThenExpressionAndColon: ConcreteSyntaxProperty { + .init(6) + } + + public static var colon: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenColonAndElseExpression: ConcreteSyntaxProperty { + .init(8) + } + + public static var elseExpression: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedAfterElseExpression: ConcreteSyntaxProperty { + .init(10) + } +} + +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +extension ConcreteSyntaxProperty where Base == ThenStmtSyntax { + public static var unexpectedBeforeThenKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var thenKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenThenKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ThrowStmtSyntax { + public static var unexpectedBeforeThrowKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var throwKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenThrowKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ThrowsClauseSyntax { + public static var unexpectedBeforeThrowsSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var throwsSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenThrowsSpecifierAndLeftParen: ConcreteSyntaxProperty { + .init(2) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenLeftParenAndType: ConcreteSyntaxProperty { + .init(4) + } + + public static var type: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenTypeAndRightParen: ConcreteSyntaxProperty { + .init(6) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == TryExprSyntax { + public static var unexpectedBeforeTryKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var tryKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenTryKeywordAndQuestionOrExclamationMark: ConcreteSyntaxProperty { + .init(2) + } + + public static var questionOrExclamationMark: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenQuestionOrExclamationMarkAndExpression: ConcreteSyntaxProperty { + .init(4) + } + + public static var expression: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == TupleExprSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndElements: ConcreteSyntaxProperty { + .init(2) + } + + public static var elements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenElementsAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == TuplePatternElementSyntax { + public static var unexpectedBeforeLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var label: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndPattern: ConcreteSyntaxProperty { + .init(4) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenPatternAndTrailingComma: ConcreteSyntaxProperty { + .init(6) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == TuplePatternSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndElements: ConcreteSyntaxProperty { + .init(2) + } + + public static var elements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenElementsAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == TupleTypeElementSyntax { + public static var unexpectedBeforeInoutKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var inoutKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenInoutKeywordAndFirstName: ConcreteSyntaxProperty { + .init(2) + } + + public static var firstName: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenFirstNameAndSecondName: ConcreteSyntaxProperty { + .init(4) + } + + public static var secondName: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenSecondNameAndColon: ConcreteSyntaxProperty { + .init(6) + } + + public static var colon: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenColonAndType: ConcreteSyntaxProperty { + .init(8) + } + + public static var type: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenTypeAndEllipsis: ConcreteSyntaxProperty { + .init(10) + } + + public static var ellipsis: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenEllipsisAndTrailingComma: ConcreteSyntaxProperty { + .init(12) + } + + public static var trailingComma: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterTrailingComma: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == TupleTypeSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndElements: ConcreteSyntaxProperty { + .init(2) + } + + public static var elements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenElementsAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == TypeAliasDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndTypealiasKeyword: ConcreteSyntaxProperty { + .init(4) + } + + public static var typealiasKeyword: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenTypealiasKeywordAndName: ConcreteSyntaxProperty { + .init(6) + } + + public static var name: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedBetweenNameAndGenericParameterClause: ConcreteSyntaxProperty { + .init(8) + } + + public static var genericParameterClause: ConcreteSyntaxProperty { + .init(9) + } + + public static var unexpectedBetweenGenericParameterClauseAndInitializer: ConcreteSyntaxProperty { + .init(10) + } + + public static var initializer: ConcreteSyntaxProperty { + .init(11) + } + + public static var unexpectedBetweenInitializerAndGenericWhereClause: ConcreteSyntaxProperty { + .init(12) + } + + public static var genericWhereClause: ConcreteSyntaxProperty { + .init(13) + } + + public static var unexpectedAfterGenericWhereClause: ConcreteSyntaxProperty { + .init(14) + } +} + +extension ConcreteSyntaxProperty where Base == TypeAnnotationSyntax { + public static var unexpectedBeforeColon: ConcreteSyntaxProperty { + .init(0) + } + + public static var colon: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenColonAndType: ConcreteSyntaxProperty { + .init(2) + } + + public static var type: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == TypeEffectSpecifiersSyntax { + public static var unexpectedBeforeAsyncSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var asyncSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAsyncSpecifierAndThrowsClause: ConcreteSyntaxProperty { + .init(2) + } + + public static var throwsClause: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterThrowsClause: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == TypeExprSyntax { + public static var unexpectedBeforeType: ConcreteSyntaxProperty { + .init(0) + } + + public static var type: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterType: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == TypeInitializerClauseSyntax { + public static var unexpectedBeforeEqual: ConcreteSyntaxProperty { + .init(0) + } + + public static var equal: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenEqualAndValue: ConcreteSyntaxProperty { + .init(2) + } + + public static var value: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterValue: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == UnavailableFromAsyncAttributeArgumentsSyntax { + public static var unexpectedBeforeMessageLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var messageLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenMessageLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndMessage: ConcreteSyntaxProperty { + .init(4) + } + + public static var message: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterMessage: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == UnderscorePrivateAttributeArgumentsSyntax { + public static var unexpectedBeforeSourceFileLabel: ConcreteSyntaxProperty { + .init(0) + } + + public static var sourceFileLabel: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenSourceFileLabelAndColon: ConcreteSyntaxProperty { + .init(2) + } + + public static var colon: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenColonAndFilename: ConcreteSyntaxProperty { + .init(4) + } + + public static var filename: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterFilename: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == UnresolvedAsExprSyntax { + public static var unexpectedBeforeAsKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var asKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAsKeywordAndQuestionOrExclamationMark: ConcreteSyntaxProperty { + .init(2) + } + + public static var questionOrExclamationMark: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterQuestionOrExclamationMark: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == UnresolvedIsExprSyntax { + public static var unexpectedBeforeIsKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var isKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterIsKeyword: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == UnresolvedTernaryExprSyntax { + public static var unexpectedBeforeQuestionMark: ConcreteSyntaxProperty { + .init(0) + } + + public static var questionMark: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenQuestionMarkAndThenExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var thenExpression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenThenExpressionAndColon: ConcreteSyntaxProperty { + .init(4) + } + + public static var colon: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterColon: ConcreteSyntaxProperty { + .init(6) + } +} + +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +extension ConcreteSyntaxProperty where Base == UnsafeExprSyntax { + public static var unexpectedBeforeUnsafeKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var unsafeKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenUnsafeKeywordAndExpression: ConcreteSyntaxProperty { + .init(2) + } + + public static var expression: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterExpression: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == ValueBindingPatternSyntax { + public static var unexpectedBeforeBindingSpecifier: ConcreteSyntaxProperty { + .init(0) + } + + public static var bindingSpecifier: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenBindingSpecifierAndPattern: ConcreteSyntaxProperty { + .init(2) + } + + public static var pattern: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterPattern: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == VariableDeclSyntax { + public static var unexpectedBeforeAttributes: ConcreteSyntaxProperty { + .init(0) + } + + public static var attributes: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenAttributesAndModifiers: ConcreteSyntaxProperty { + .init(2) + } + + public static var modifiers: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenModifiersAndBindingSpecifier: ConcreteSyntaxProperty { + .init(4) + } + + public static var bindingSpecifier: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedBetweenBindingSpecifierAndBindings: ConcreteSyntaxProperty { + .init(6) + } + + public static var bindings: ConcreteSyntaxProperty { + .init(7) + } + + public static var unexpectedAfterBindings: ConcreteSyntaxProperty { + .init(8) + } +} + +extension ConcreteSyntaxProperty where Base == VersionComponentSyntax { + public static var unexpectedBeforePeriod: ConcreteSyntaxProperty { + .init(0) + } + + public static var period: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenPeriodAndNumber: ConcreteSyntaxProperty { + .init(2) + } + + public static var number: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterNumber: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == VersionTupleSyntax { + public static var unexpectedBeforeMajor: ConcreteSyntaxProperty { + .init(0) + } + + public static var major: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenMajorAndComponents: ConcreteSyntaxProperty { + .init(2) + } + + public static var components: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterComponents: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == WhereClauseSyntax { + public static var unexpectedBeforeWhereKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var whereKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWhereKeywordAndCondition: ConcreteSyntaxProperty { + .init(2) + } + + public static var condition: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterCondition: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == WhileStmtSyntax { + public static var unexpectedBeforeWhileKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var whileKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenWhileKeywordAndConditions: ConcreteSyntaxProperty { + .init(2) + } + + public static var conditions: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenConditionsAndBody: ConcreteSyntaxProperty { + .init(4) + } + + public static var body: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterBody: ConcreteSyntaxProperty { + .init(6) + } +} + +extension ConcreteSyntaxProperty where Base == WildcardPatternSyntax { + public static var unexpectedBeforeWildcard: ConcreteSyntaxProperty { + .init(0) + } + + public static var wildcard: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedAfterWildcard: ConcreteSyntaxProperty { + .init(2) + } +} + +extension ConcreteSyntaxProperty where Base == YieldStmtSyntax { + public static var unexpectedBeforeYieldKeyword: ConcreteSyntaxProperty { + .init(0) + } + + public static var yieldKeyword: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenYieldKeywordAndYieldedExpressions: ConcreteSyntaxProperty { + .init(2) + } + + public static var yieldedExpressions: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterYieldedExpressions: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == YieldedExpressionSyntax { + public static var unexpectedBeforeExpression: ConcreteSyntaxProperty { + .init(0) + } + + public static var expression: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenExpressionAndComma: ConcreteSyntaxProperty { + .init(2) + } + + public static var comma: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedAfterComma: ConcreteSyntaxProperty { + .init(4) + } +} + +extension ConcreteSyntaxProperty where Base == YieldedExpressionsClauseSyntax { + public static var unexpectedBeforeLeftParen: ConcreteSyntaxProperty { + .init(0) + } + + public static var leftParen: ConcreteSyntaxProperty { + .init(1) + } + + public static var unexpectedBetweenLeftParenAndElements: ConcreteSyntaxProperty { + .init(2) + } + + public static var elements: ConcreteSyntaxProperty { + .init(3) + } + + public static var unexpectedBetweenElementsAndRightParen: ConcreteSyntaxProperty { + .init(4) + } + + public static var rightParen: ConcreteSyntaxProperty { + .init(5) + } + + public static var unexpectedAfterRightParen: ConcreteSyntaxProperty { + .init(6) + } +} diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index 210d83d4fea..8a4241343c3 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -268,14 +268,7 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } -/// Protocol that syntax nodes conform to if they don't have any semantic subtypes. -/// These are syntax nodes that are not considered base nodes for other syntax types. -/// -/// Syntax nodes conforming to this protocol have their inherited casting methods -/// deprecated to prevent incorrect casting. -public protocol _LeafDeclSyntaxNodeProtocol: DeclSyntaxProtocol {} - -extension _LeafDeclSyntaxNodeProtocol { +extension _LeafSyntaxNodeProtocol where Self: DeclSyntaxProtocol { /// Checks if the current leaf syntax node can be cast to a different specified type. /// /// - Returns: `false` since the leaf node cannot be cast to a different specified type. @@ -625,14 +618,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -/// Protocol that syntax nodes conform to if they don't have any semantic subtypes. -/// These are syntax nodes that are not considered base nodes for other syntax types. -/// -/// Syntax nodes conforming to this protocol have their inherited casting methods -/// deprecated to prevent incorrect casting. -public protocol _LeafExprSyntaxNodeProtocol: ExprSyntaxProtocol {} - -extension _LeafExprSyntaxNodeProtocol { +extension _LeafSyntaxNodeProtocol where Self: ExprSyntaxProtocol { /// Checks if the current leaf syntax node can be cast to a different specified type. /// /// - Returns: `false` since the leaf node cannot be cast to a different specified type. @@ -892,14 +878,7 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } } -/// Protocol that syntax nodes conform to if they don't have any semantic subtypes. -/// These are syntax nodes that are not considered base nodes for other syntax types. -/// -/// Syntax nodes conforming to this protocol have their inherited casting methods -/// deprecated to prevent incorrect casting. -public protocol _LeafPatternSyntaxNodeProtocol: PatternSyntaxProtocol {} - -extension _LeafPatternSyntaxNodeProtocol { +extension _LeafSyntaxNodeProtocol where Self: PatternSyntaxProtocol { /// Checks if the current leaf syntax node can be cast to a different specified type. /// /// - Returns: `false` since the leaf node cannot be cast to a different specified type. @@ -1178,14 +1157,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } } -/// Protocol that syntax nodes conform to if they don't have any semantic subtypes. -/// These are syntax nodes that are not considered base nodes for other syntax types. -/// -/// Syntax nodes conforming to this protocol have their inherited casting methods -/// deprecated to prevent incorrect casting. -public protocol _LeafStmtSyntaxNodeProtocol: StmtSyntaxProtocol {} - -extension _LeafStmtSyntaxNodeProtocol { +extension _LeafSyntaxNodeProtocol where Self: StmtSyntaxProtocol { /// Checks if the current leaf syntax node can be cast to a different specified type. /// /// - Returns: `false` since the leaf node cannot be cast to a different specified type. @@ -1467,14 +1439,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } } -/// Protocol that syntax nodes conform to if they don't have any semantic subtypes. -/// These are syntax nodes that are not considered base nodes for other syntax types. -/// -/// Syntax nodes conforming to this protocol have their inherited casting methods -/// deprecated to prevent incorrect casting. -public protocol _LeafTypeSyntaxNodeProtocol: TypeSyntaxProtocol {} - -extension _LeafTypeSyntaxNodeProtocol { +extension _LeafSyntaxNodeProtocol where Self: TypeSyntaxProtocol { /// Checks if the current leaf syntax node can be cast to a different specified type. /// /// - Returns: `false` since the leaf node cannot be cast to a different specified type. @@ -1807,14 +1772,7 @@ extension Syntax { } } -/// Protocol that syntax nodes conform to if they don't have any semantic subtypes. -/// These are syntax nodes that are not considered base nodes for other syntax types. -/// -/// Syntax nodes conforming to this protocol have their inherited casting methods -/// deprecated to prevent incorrect casting. -public protocol _LeafSyntaxNodeProtocol: SyntaxProtocol {} - -extension _LeafSyntaxNodeProtocol { +extension _LeafSyntaxNodeProtocol where Self: SyntaxProtocol { /// Checks if the current leaf syntax node can be cast to a different specified type. /// /// - Returns: `false` since the leaf node cannot be cast to a different specified type. diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift index f265a19a16c..dc11273c5e0 100644 --- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift +++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift @@ -36,7 +36,9 @@ public struct AccessorDeclListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.accessorDeclList + public static var syntaxKind: SyntaxKind { + .accessorDeclList + } } /// ### Children @@ -63,7 +65,9 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.arrayElementList + public static var syntaxKind: SyntaxKind { + .arrayElementList + } } /// A list of attributes that can be attached to a declaration. @@ -208,7 +212,9 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.attributeList + public static var syntaxKind: SyntaxKind { + .attributeList + } } /// ### Children @@ -237,7 +243,9 @@ public struct AvailabilityArgumentListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.availabilityArgumentList + public static var syntaxKind: SyntaxKind { + .availabilityArgumentList + } } /// ### Children @@ -264,7 +272,9 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.catchClauseList + public static var syntaxKind: SyntaxKind { + .catchClauseList + } } /// ### Children @@ -291,7 +301,9 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.catchItemList + public static var syntaxKind: SyntaxKind { + .catchItemList + } } /// ### Children @@ -318,7 +330,9 @@ public struct ClosureCaptureListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.closureCaptureList + public static var syntaxKind: SyntaxKind { + .closureCaptureList + } } /// ### Children @@ -345,7 +359,9 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.closureParameterList + public static var syntaxKind: SyntaxKind { + .closureParameterList + } } /// A list of closure parameters that are not parenthesized and don't have type annotations. @@ -385,7 +401,9 @@ public struct ClosureShorthandParameterListSyntax: SyntaxCollection, SyntaxHasha self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.closureShorthandParameterList + public static var syntaxKind: SyntaxKind { + .closureShorthandParameterList + } } /// ### Children @@ -417,7 +435,9 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.codeBlockItemList + public static var syntaxKind: SyntaxKind { + .codeBlockItemList + } } /// ### Children @@ -444,7 +464,9 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.compositionTypeElementList + public static var syntaxKind: SyntaxKind { + .compositionTypeElementList + } } /// ### Children @@ -473,7 +495,9 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.conditionElementList + public static var syntaxKind: SyntaxKind { + .conditionElementList + } } /// ### Children @@ -522,7 +546,9 @@ public struct DeclModifierListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.declModifierList + public static var syntaxKind: SyntaxKind { + .declModifierList + } } /// ### Children @@ -549,7 +575,9 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.declNameArgumentList + public static var syntaxKind: SyntaxKind { + .declNameArgumentList + } } /// ### Children @@ -576,7 +604,9 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.designatedTypeList + public static var syntaxKind: SyntaxKind { + .designatedTypeList + } } /// ### Children @@ -603,7 +633,9 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.dictionaryElementList + public static var syntaxKind: SyntaxKind { + .dictionaryElementList + } } /// ### Children @@ -630,7 +662,9 @@ public struct DifferentiabilityArgumentListSyntax: SyntaxCollection, SyntaxHasha self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.differentiabilityArgumentList + public static var syntaxKind: SyntaxKind { + .differentiabilityArgumentList + } } /// The arguments of the '@_documentation' attribute @@ -659,7 +693,9 @@ public struct DocumentationAttributeArgumentListSyntax: SyntaxCollection, Syntax self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.documentationAttributeArgumentList + public static var syntaxKind: SyntaxKind { + .documentationAttributeArgumentList + } } /// The arguments of the '@_effects' attribute. These will be parsed during the SIL stage. @@ -688,7 +724,9 @@ public struct EffectsAttributeArgumentListSyntax: SyntaxCollection, SyntaxHashab self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.effectsAttributeArgumentList + public static var syntaxKind: SyntaxKind { + .effectsAttributeArgumentList + } } /// A collection of 0 or more ``EnumCaseElementSyntax``s. @@ -717,7 +755,9 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.enumCaseElementList + public static var syntaxKind: SyntaxKind { + .enumCaseElementList + } } /// ### Children @@ -744,7 +784,9 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.enumCaseParameterList + public static var syntaxKind: SyntaxKind { + .enumCaseParameterList + } } /// A list of expressions connected by operators. This list is contained by a ``SequenceExprSyntax``. @@ -773,7 +815,9 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.exprList + public static var syntaxKind: SyntaxKind { + .exprList + } } /// A list of function parameters that are type annotated and a label. @@ -811,7 +855,9 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.functionParameterList + public static var syntaxKind: SyntaxKind { + .functionParameterList + } } /// ### Children @@ -838,7 +884,9 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.genericArgumentList + public static var syntaxKind: SyntaxKind { + .genericArgumentList + } } /// ### Children @@ -865,7 +913,9 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.genericParameterList + public static var syntaxKind: SyntaxKind { + .genericParameterList + } } /// ### Children @@ -892,7 +942,9 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.genericRequirementList + public static var syntaxKind: SyntaxKind { + .genericRequirementList + } } /// ### Children @@ -919,7 +971,9 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.ifConfigClauseList + public static var syntaxKind: SyntaxKind { + .ifConfigClauseList + } } /// ### Children @@ -946,7 +1000,9 @@ public struct ImportPathComponentListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.importPathComponentList + public static var syntaxKind: SyntaxKind { + .importPathComponentList + } } /// ### Children @@ -973,7 +1029,9 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.inheritedTypeList + public static var syntaxKind: SyntaxKind { + .inheritedTypeList + } } /// The components of a key path @@ -1002,7 +1060,9 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.keyPathComponentList + public static var syntaxKind: SyntaxKind { + .keyPathComponentList + } } /// ### Children @@ -1036,7 +1096,9 @@ public struct LabeledExprListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.labeledExprList + public static var syntaxKind: SyntaxKind { + .labeledExprList + } } /// - Note: Requires experimental feature `nonescapableTypes`. @@ -1064,7 +1126,9 @@ public struct LifetimeSpecifierArgumentListSyntax: SyntaxCollection, SyntaxHasha self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.lifetimeSpecifierArgumentList + public static var syntaxKind: SyntaxKind { + .lifetimeSpecifierArgumentList + } } /// ### Children @@ -1092,7 +1156,9 @@ public struct MemberBlockItemListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.memberBlockItemList + public static var syntaxKind: SyntaxKind { + .memberBlockItemList + } } /// ### Children @@ -1122,7 +1188,9 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.multipleTrailingClosureElementList + public static var syntaxKind: SyntaxKind { + .multipleTrailingClosureElementList + } } /// ### Children @@ -1149,7 +1217,9 @@ public struct ObjCSelectorPieceListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.objCSelectorPieceList + public static var syntaxKind: SyntaxKind { + .objCSelectorPieceList + } } /// ### Children @@ -1176,7 +1246,9 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.patternBindingList + public static var syntaxKind: SyntaxKind { + .patternBindingList + } } /// ### Children @@ -1204,7 +1276,9 @@ public struct PlatformVersionItemListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.platformVersionItemList + public static var syntaxKind: SyntaxKind { + .platformVersionItemList + } } /// ### Children @@ -1343,7 +1417,9 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.precedenceGroupAttributeList + public static var syntaxKind: SyntaxKind { + .precedenceGroupAttributeList + } } /// ### Children @@ -1370,7 +1446,9 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.precedenceGroupNameList + public static var syntaxKind: SyntaxKind { + .precedenceGroupNameList + } } /// ### Children @@ -1397,7 +1475,9 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.primaryAssociatedTypeList + public static var syntaxKind: SyntaxKind { + .primaryAssociatedTypeList + } } /// String literal segments that only can contain non string interpolated or extended escaped strings @@ -1426,7 +1506,9 @@ public struct SimpleStringLiteralSegmentListSyntax: SyntaxCollection, SyntaxHash self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.simpleStringLiteralSegmentList + public static var syntaxKind: SyntaxKind { + .simpleStringLiteralSegmentList + } } /// A collection of arguments for the `@_specialize` attribute @@ -1604,7 +1686,9 @@ public struct SpecializeAttributeArgumentListSyntax: SyntaxCollection, SyntaxHas self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.specializeAttributeArgumentList + public static var syntaxKind: SyntaxKind { + .specializeAttributeArgumentList + } } /// ### Children @@ -1715,7 +1799,9 @@ public struct StringLiteralSegmentListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.stringLiteralSegmentList + public static var syntaxKind: SyntaxKind { + .stringLiteralSegmentList + } } /// ### Children @@ -1742,7 +1828,9 @@ public struct SwitchCaseItemListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.switchCaseItemList + public static var syntaxKind: SyntaxKind { + .switchCaseItemList + } } /// ### Children @@ -1848,7 +1936,9 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.switchCaseList + public static var syntaxKind: SyntaxKind { + .switchCaseList + } } /// A list of ``TuplePatternElementSyntax``. @@ -1877,7 +1967,9 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.tuplePatternElementList + public static var syntaxKind: SyntaxKind { + .tuplePatternElementList + } } /// ### Children @@ -1905,7 +1997,9 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.tupleTypeElementList + public static var syntaxKind: SyntaxKind { + .tupleTypeElementList + } } /// ### Children @@ -2032,7 +2126,9 @@ public struct TypeSpecifierListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.typeSpecifierList + public static var syntaxKind: SyntaxKind { + .typeSpecifierList + } } /// A collection of syntax nodes that occurred in the source code but could not be used to form a valid syntax tree. @@ -2057,7 +2153,9 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.unexpectedNodes + public static var syntaxKind: SyntaxKind { + .unexpectedNodes + } } /// ### Children @@ -2084,7 +2182,9 @@ public struct VersionComponentListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.versionComponentList + public static var syntaxKind: SyntaxKind { + .versionComponentList + } } /// ### Children @@ -2111,5 +2211,7 @@ public struct YieldedExpressionListSyntax: SyntaxCollection, SyntaxHashable { self._syntaxNode = node } - public static let syntaxKind = SyntaxKind.yieldedExpressionList + public static var syntaxKind: SyntaxKind { + .yieldedExpressionList + } } diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index b3bd4e49111..dad5593844e 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -431,6 +431,481 @@ public enum SyntaxKind: Sendable { } } + public var isLayout: Bool { + switch self { + case .abiAttributeArguments: + return true + case .accessorBlock: + return true + case .accessorDecl: + return true + case .accessorEffectSpecifiers: + return true + case .accessorParameters: + return true + case .actorDecl: + return true + case .arrayElement: + return true + case .arrayExpr: + return true + case .arrayType: + return true + case .arrowExpr: + return true + case .asExpr: + return true + case .assignmentExpr: + return true + case .associatedTypeDecl: + return true + case .attribute: + return true + case .attributedType: + return true + case .availabilityArgument: + return true + case .availabilityCondition: + return true + case .availabilityLabeledArgument: + return true + case .awaitExpr: + return true + case .backDeployedAttributeArguments: + return true + case .binaryOperatorExpr: + return true + case .booleanLiteralExpr: + return true + case .borrowExpr: + return true + case .breakStmt: + return true + case ._canImportExpr: + return true + case ._canImportVersionInfo: + return true + case .catchClause: + return true + case .catchItem: + return true + case .classDecl: + return true + case .classRestrictionType: + return true + case .closureCaptureClause: + return true + case .closureCaptureSpecifier: + return true + case .closureCapture: + return true + case .closureExpr: + return true + case .closureParameterClause: + return true + case .closureParameter: + return true + case .closureShorthandParameter: + return true + case .closureSignature: + return true + case .codeBlockItem: + return true + case .codeBlock: + return true + case .compositionTypeElement: + return true + case .compositionType: + return true + case .conditionElement: + return true + case .conformanceRequirement: + return true + case .consumeExpr: + return true + case .continueStmt: + return true + case .conventionAttributeArguments: + return true + case .conventionWitnessMethodAttributeArguments: + return true + case .copyExpr: + return true + case .declModifierDetail: + return true + case .declModifier: + return true + case .declNameArgument: + return true + case .declNameArguments: + return true + case .declReferenceExpr: + return true + case .deferStmt: + return true + case .deinitializerDecl: + return true + case .deinitializerEffectSpecifiers: + return true + case .derivativeAttributeArguments: + return true + case .designatedType: + return true + case .dictionaryElement: + return true + case .dictionaryExpr: + return true + case .dictionaryType: + return true + case .differentiabilityArgument: + return true + case .differentiabilityArguments: + return true + case .differentiabilityWithRespectToArgument: + return true + case .differentiableAttributeArguments: + return true + case .discardAssignmentExpr: + return true + case .discardStmt: + return true + case .doExpr: + return true + case .doStmt: + return true + case .documentationAttributeArgument: + return true + case .dynamicReplacementAttributeArguments: + return true + case .editorPlaceholderDecl: + return true + case .editorPlaceholderExpr: + return true + case .enumCaseDecl: + return true + case .enumCaseElement: + return true + case .enumCaseParameterClause: + return true + case .enumCaseParameter: + return true + case .enumDecl: + return true + case .exposeAttributeArguments: + return true + case .expressionPattern: + return true + case .expressionSegment: + return true + case .expressionStmt: + return true + case .extensionDecl: + return true + case .fallThroughStmt: + return true + case .floatLiteralExpr: + return true + case .forStmt: + return true + case .forceUnwrapExpr: + return true + case .functionCallExpr: + return true + case .functionDecl: + return true + case .functionEffectSpecifiers: + return true + case .functionParameterClause: + return true + case .functionParameter: + return true + case .functionSignature: + return true + case .functionType: + return true + case .genericArgumentClause: + return true + case .genericArgument: + return true + case .genericParameterClause: + return true + case .genericParameter: + return true + case .genericRequirement: + return true + case .genericSpecializationExpr: + return true + case .genericWhereClause: + return true + case .guardStmt: + return true + case .identifierPattern: + return true + case .identifierType: + return true + case .ifConfigClause: + return true + case .ifConfigDecl: + return true + case .ifExpr: + return true + case .implementsAttributeArguments: + return true + case .implicitlyUnwrappedOptionalType: + return true + case .importDecl: + return true + case .importPathComponent: + return true + case .inOutExpr: + return true + case .infixOperatorExpr: + return true + case .inheritanceClause: + return true + case .inheritedType: + return true + case .initializerClause: + return true + case .initializerDecl: + return true + case .integerLiteralExpr: + return true + case .isExpr: + return true + case .isTypePattern: + return true + case .keyPathComponent: + return true + case .keyPathExpr: + return true + case .keyPathOptionalComponent: + return true + case .keyPathPropertyComponent: + return true + case .keyPathSubscriptComponent: + return true + case .labeledExpr: + return true + case .labeledSpecializeArgument: + return true + case .labeledStmt: + return true + case .layoutRequirement: + return true + case .lifetimeSpecifierArgument: + return true + case .lifetimeTypeSpecifier: + return true + case .macroDecl: + return true + case .macroExpansionDecl: + return true + case .macroExpansionExpr: + return true + case .matchingPatternCondition: + return true + case .memberAccessExpr: + return true + case .memberBlockItem: + return true + case .memberBlock: + return true + case .memberType: + return true + case .metatypeType: + return true + case .missingDecl: + return true + case .missingExpr: + return true + case .missingPattern: + return true + case .missingStmt: + return true + case .missing: + return true + case .missingType: + return true + case .multipleTrailingClosureElement: + return true + case .namedOpaqueReturnType: + return true + case .nilLiteralExpr: + return true + case .objCSelectorPiece: + return true + case .opaqueReturnTypeOfAttributeArguments: + return true + case .operatorDecl: + return true + case .operatorPrecedenceAndTypes: + return true + case .optionalBindingCondition: + return true + case .optionalChainingExpr: + return true + case .optionalType: + return true + case .originallyDefinedInAttributeArguments: + return true + case .packElementExpr: + return true + case .packElementType: + return true + case .packExpansionExpr: + return true + case .packExpansionType: + return true + case .patternBinding: + return true + case .patternExpr: + return true + case .platformVersionItem: + return true + case .platformVersion: + return true + case .postfixIfConfigExpr: + return true + case .postfixOperatorExpr: + return true + case .poundSourceLocationArguments: + return true + case .poundSourceLocation: + return true + case .precedenceGroupAssignment: + return true + case .precedenceGroupAssociativity: + return true + case .precedenceGroupDecl: + return true + case .precedenceGroupName: + return true + case .precedenceGroupRelation: + return true + case .prefixOperatorExpr: + return true + case .primaryAssociatedTypeClause: + return true + case .primaryAssociatedType: + return true + case .protocolDecl: + return true + case .regexLiteralExpr: + return true + case .repeatStmt: + return true + case .returnClause: + return true + case .returnStmt: + return true + case .sameTypeRequirement: + return true + case .sequenceExpr: + return true + case .simpleStringLiteralExpr: + return true + case .simpleTypeSpecifier: + return true + case .someOrAnyType: + return true + case .sourceFile: + return true + case .specializeAvailabilityArgument: + return true + case .specializeTargetFunctionArgument: + return true + case .stringLiteralExpr: + return true + case .stringSegment: + return true + case .structDecl: + return true + case .subscriptCallExpr: + return true + case .subscriptDecl: + return true + case .superExpr: + return true + case .suppressedType: + return true + case .switchCaseItem: + return true + case .switchCaseLabel: + return true + case .switchCase: + return true + case .switchDefaultLabel: + return true + case .switchExpr: + return true + case .ternaryExpr: + return true + case .thenStmt: + return true + case .throwStmt: + return true + case .throwsClause: + return true + case .tryExpr: + return true + case .tupleExpr: + return true + case .tuplePatternElement: + return true + case .tuplePattern: + return true + case .tupleTypeElement: + return true + case .tupleType: + return true + case .typeAliasDecl: + return true + case .typeAnnotation: + return true + case .typeEffectSpecifiers: + return true + case .typeExpr: + return true + case .typeInitializerClause: + return true + case .unavailableFromAsyncAttributeArguments: + return true + case .underscorePrivateAttributeArguments: + return true + case .unresolvedAsExpr: + return true + case .unresolvedIsExpr: + return true + case .unresolvedTernaryExpr: + return true + case .unsafeExpr: + return true + case .valueBindingPattern: + return true + case .variableDecl: + return true + case .versionComponent: + return true + case .versionTuple: + return true + case .whereClause: + return true + case .whileStmt: + return true + case .wildcardPattern: + return true + case .yieldStmt: + return true + case .yieldedExpression: + return true + case .yieldedExpressionsClause: + return true + default: + return false + } + } + public var isMissing: Bool { switch self { case .missing: diff --git a/Sources/SwiftSyntax/generated/SyntaxLayoutPropertyName.swift b/Sources/SwiftSyntax/generated/SyntaxLayoutPropertyName.swift new file mode 100644 index 00000000000..b517ac62876 --- /dev/null +++ b/Sources/SwiftSyntax/generated/SyntaxLayoutPropertyName.swift @@ -0,0 +1,3517 @@ +//// Automatically generated by generate-swift-syntax +//// Do not edit directly! +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +extension SyntaxLayoutProperty { + /// Property name if this is a valid property. + /// 'nil' if the `syntaxKind` is not a layout syntax, or the index is out of range. + @_spi(RawSyntax) + public var name: String? { + switch (self.syntaxKind, self.index.value) { + case (.abiAttributeArguments, 0): + return "unexpectedBeforeProvider" + case (.abiAttributeArguments, 1): + return "provider" + case (.abiAttributeArguments, 2): + return "unexpectedAfterProvider" + case (.accessorBlock, 0): + return "unexpectedBeforeLeftBrace" + case (.accessorBlock, 1): + return "leftBrace" + case (.accessorBlock, 2): + return "unexpectedBetweenLeftBraceAndAccessors" + case (.accessorBlock, 3): + return "accessors" + case (.accessorBlock, 4): + return "unexpectedBetweenAccessorsAndRightBrace" + case (.accessorBlock, 5): + return "rightBrace" + case (.accessorBlock, 6): + return "unexpectedAfterRightBrace" + case (.accessorDecl, 0): + return "unexpectedBeforeAttributes" + case (.accessorDecl, 1): + return "attributes" + case (.accessorDecl, 2): + return "unexpectedBetweenAttributesAndModifier" + case (.accessorDecl, 3): + return "modifier" + case (.accessorDecl, 4): + return "unexpectedBetweenModifierAndAccessorSpecifier" + case (.accessorDecl, 5): + return "accessorSpecifier" + case (.accessorDecl, 6): + return "unexpectedBetweenAccessorSpecifierAndParameters" + case (.accessorDecl, 7): + return "parameters" + case (.accessorDecl, 8): + return "unexpectedBetweenParametersAndEffectSpecifiers" + case (.accessorDecl, 9): + return "effectSpecifiers" + case (.accessorDecl, 10): + return "unexpectedBetweenEffectSpecifiersAndBody" + case (.accessorDecl, 11): + return "body" + case (.accessorDecl, 12): + return "unexpectedAfterBody" + case (.accessorEffectSpecifiers, 0): + return "unexpectedBeforeAsyncSpecifier" + case (.accessorEffectSpecifiers, 1): + return "asyncSpecifier" + case (.accessorEffectSpecifiers, 2): + return "unexpectedBetweenAsyncSpecifierAndThrowsClause" + case (.accessorEffectSpecifiers, 3): + return "throwsClause" + case (.accessorEffectSpecifiers, 4): + return "unexpectedAfterThrowsClause" + case (.accessorParameters, 0): + return "unexpectedBeforeLeftParen" + case (.accessorParameters, 1): + return "leftParen" + case (.accessorParameters, 2): + return "unexpectedBetweenLeftParenAndName" + case (.accessorParameters, 3): + return "name" + case (.accessorParameters, 4): + return "unexpectedBetweenNameAndRightParen" + case (.accessorParameters, 5): + return "rightParen" + case (.accessorParameters, 6): + return "unexpectedAfterRightParen" + case (.actorDecl, 0): + return "unexpectedBeforeAttributes" + case (.actorDecl, 1): + return "attributes" + case (.actorDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.actorDecl, 3): + return "modifiers" + case (.actorDecl, 4): + return "unexpectedBetweenModifiersAndActorKeyword" + case (.actorDecl, 5): + return "actorKeyword" + case (.actorDecl, 6): + return "unexpectedBetweenActorKeywordAndName" + case (.actorDecl, 7): + return "name" + case (.actorDecl, 8): + return "unexpectedBetweenNameAndGenericParameterClause" + case (.actorDecl, 9): + return "genericParameterClause" + case (.actorDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" + case (.actorDecl, 11): + return "inheritanceClause" + case (.actorDecl, 12): + return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" + case (.actorDecl, 13): + return "genericWhereClause" + case (.actorDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case (.actorDecl, 15): + return "memberBlock" + case (.actorDecl, 16): + return "unexpectedAfterMemberBlock" + case (.arrayElement, 0): + return "unexpectedBeforeExpression" + case (.arrayElement, 1): + return "expression" + case (.arrayElement, 2): + return "unexpectedBetweenExpressionAndTrailingComma" + case (.arrayElement, 3): + return "trailingComma" + case (.arrayElement, 4): + return "unexpectedAfterTrailingComma" + case (.arrayExpr, 0): + return "unexpectedBeforeLeftSquare" + case (.arrayExpr, 1): + return "leftSquare" + case (.arrayExpr, 2): + return "unexpectedBetweenLeftSquareAndElements" + case (.arrayExpr, 3): + return "elements" + case (.arrayExpr, 4): + return "unexpectedBetweenElementsAndRightSquare" + case (.arrayExpr, 5): + return "rightSquare" + case (.arrayExpr, 6): + return "unexpectedAfterRightSquare" + case (.arrayType, 0): + return "unexpectedBeforeLeftSquare" + case (.arrayType, 1): + return "leftSquare" + case (.arrayType, 2): + return "unexpectedBetweenLeftSquareAndElement" + case (.arrayType, 3): + return "element" + case (.arrayType, 4): + return "unexpectedBetweenElementAndRightSquare" + case (.arrayType, 5): + return "rightSquare" + case (.arrayType, 6): + return "unexpectedAfterRightSquare" + case (.arrowExpr, 0): + return "unexpectedBeforeEffectSpecifiers" + case (.arrowExpr, 1): + return "effectSpecifiers" + case (.arrowExpr, 2): + return "unexpectedBetweenEffectSpecifiersAndArrow" + case (.arrowExpr, 3): + return "arrow" + case (.arrowExpr, 4): + return "unexpectedAfterArrow" + case (.asExpr, 0): + return "unexpectedBeforeExpression" + case (.asExpr, 1): + return "expression" + case (.asExpr, 2): + return "unexpectedBetweenExpressionAndAsKeyword" + case (.asExpr, 3): + return "asKeyword" + case (.asExpr, 4): + return "unexpectedBetweenAsKeywordAndQuestionOrExclamationMark" + case (.asExpr, 5): + return "questionOrExclamationMark" + case (.asExpr, 6): + return "unexpectedBetweenQuestionOrExclamationMarkAndType" + case (.asExpr, 7): + return "type" + case (.asExpr, 8): + return "unexpectedAfterType" + case (.assignmentExpr, 0): + return "unexpectedBeforeEqual" + case (.assignmentExpr, 1): + return "equal" + case (.assignmentExpr, 2): + return "unexpectedAfterEqual" + case (.associatedTypeDecl, 0): + return "unexpectedBeforeAttributes" + case (.associatedTypeDecl, 1): + return "attributes" + case (.associatedTypeDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.associatedTypeDecl, 3): + return "modifiers" + case (.associatedTypeDecl, 4): + return "unexpectedBetweenModifiersAndAssociatedtypeKeyword" + case (.associatedTypeDecl, 5): + return "associatedtypeKeyword" + case (.associatedTypeDecl, 6): + return "unexpectedBetweenAssociatedtypeKeywordAndName" + case (.associatedTypeDecl, 7): + return "name" + case (.associatedTypeDecl, 8): + return "unexpectedBetweenNameAndInheritanceClause" + case (.associatedTypeDecl, 9): + return "inheritanceClause" + case (.associatedTypeDecl, 10): + return "unexpectedBetweenInheritanceClauseAndInitializer" + case (.associatedTypeDecl, 11): + return "initializer" + case (.associatedTypeDecl, 12): + return "unexpectedBetweenInitializerAndGenericWhereClause" + case (.associatedTypeDecl, 13): + return "genericWhereClause" + case (.associatedTypeDecl, 14): + return "unexpectedAfterGenericWhereClause" + case (.attribute, 0): + return "unexpectedBeforeAtSign" + case (.attribute, 1): + return "atSign" + case (.attribute, 2): + return "unexpectedBetweenAtSignAndAttributeName" + case (.attribute, 3): + return "attributeName" + case (.attribute, 4): + return "unexpectedBetweenAttributeNameAndLeftParen" + case (.attribute, 5): + return "leftParen" + case (.attribute, 6): + return "unexpectedBetweenLeftParenAndArguments" + case (.attribute, 7): + return "arguments" + case (.attribute, 8): + return "unexpectedBetweenArgumentsAndRightParen" + case (.attribute, 9): + return "rightParen" + case (.attribute, 10): + return "unexpectedAfterRightParen" + case (.attributedType, 0): + return "unexpectedBeforeSpecifiers" + case (.attributedType, 1): + return "specifiers" + case (.attributedType, 2): + return "unexpectedBetweenSpecifiersAndAttributes" + case (.attributedType, 3): + return "attributes" + case (.attributedType, 4): + return "unexpectedBetweenAttributesAndBaseType" + case (.attributedType, 5): + return "baseType" + case (.attributedType, 6): + return "unexpectedAfterBaseType" + case (.availabilityArgument, 0): + return "unexpectedBeforeArgument" + case (.availabilityArgument, 1): + return "argument" + case (.availabilityArgument, 2): + return "unexpectedBetweenArgumentAndTrailingComma" + case (.availabilityArgument, 3): + return "trailingComma" + case (.availabilityArgument, 4): + return "unexpectedAfterTrailingComma" + case (.availabilityCondition, 0): + return "unexpectedBeforeAvailabilityKeyword" + case (.availabilityCondition, 1): + return "availabilityKeyword" + case (.availabilityCondition, 2): + return "unexpectedBetweenAvailabilityKeywordAndLeftParen" + case (.availabilityCondition, 3): + return "leftParen" + case (.availabilityCondition, 4): + return "unexpectedBetweenLeftParenAndAvailabilityArguments" + case (.availabilityCondition, 5): + return "availabilityArguments" + case (.availabilityCondition, 6): + return "unexpectedBetweenAvailabilityArgumentsAndRightParen" + case (.availabilityCondition, 7): + return "rightParen" + case (.availabilityCondition, 8): + return "unexpectedAfterRightParen" + case (.availabilityLabeledArgument, 0): + return "unexpectedBeforeLabel" + case (.availabilityLabeledArgument, 1): + return "label" + case (.availabilityLabeledArgument, 2): + return "unexpectedBetweenLabelAndColon" + case (.availabilityLabeledArgument, 3): + return "colon" + case (.availabilityLabeledArgument, 4): + return "unexpectedBetweenColonAndValue" + case (.availabilityLabeledArgument, 5): + return "value" + case (.availabilityLabeledArgument, 6): + return "unexpectedAfterValue" + case (.awaitExpr, 0): + return "unexpectedBeforeAwaitKeyword" + case (.awaitExpr, 1): + return "awaitKeyword" + case (.awaitExpr, 2): + return "unexpectedBetweenAwaitKeywordAndExpression" + case (.awaitExpr, 3): + return "expression" + case (.awaitExpr, 4): + return "unexpectedAfterExpression" + case (.backDeployedAttributeArguments, 0): + return "unexpectedBeforeBeforeLabel" + case (.backDeployedAttributeArguments, 1): + return "beforeLabel" + case (.backDeployedAttributeArguments, 2): + return "unexpectedBetweenBeforeLabelAndColon" + case (.backDeployedAttributeArguments, 3): + return "colon" + case (.backDeployedAttributeArguments, 4): + return "unexpectedBetweenColonAndPlatforms" + case (.backDeployedAttributeArguments, 5): + return "platforms" + case (.backDeployedAttributeArguments, 6): + return "unexpectedAfterPlatforms" + case (.binaryOperatorExpr, 0): + return "unexpectedBeforeOperator" + case (.binaryOperatorExpr, 1): + return "operator" + case (.binaryOperatorExpr, 2): + return "unexpectedAfterOperator" + case (.booleanLiteralExpr, 0): + return "unexpectedBeforeLiteral" + case (.booleanLiteralExpr, 1): + return "literal" + case (.booleanLiteralExpr, 2): + return "unexpectedAfterLiteral" + case (.borrowExpr, 0): + return "unexpectedBeforeBorrowKeyword" + case (.borrowExpr, 1): + return "borrowKeyword" + case (.borrowExpr, 2): + return "unexpectedBetweenBorrowKeywordAndExpression" + case (.borrowExpr, 3): + return "expression" + case (.borrowExpr, 4): + return "unexpectedAfterExpression" + case (.breakStmt, 0): + return "unexpectedBeforeBreakKeyword" + case (.breakStmt, 1): + return "breakKeyword" + case (.breakStmt, 2): + return "unexpectedBetweenBreakKeywordAndLabel" + case (.breakStmt, 3): + return "label" + case (.breakStmt, 4): + return "unexpectedAfterLabel" + case (._canImportExpr, 0): + return "unexpectedBeforeCanImportKeyword" + case (._canImportExpr, 1): + return "canImportKeyword" + case (._canImportExpr, 2): + return "unexpectedBetweenCanImportKeywordAndLeftParen" + case (._canImportExpr, 3): + return "leftParen" + case (._canImportExpr, 4): + return "unexpectedBetweenLeftParenAndImportPath" + case (._canImportExpr, 5): + return "importPath" + case (._canImportExpr, 6): + return "unexpectedBetweenImportPathAndVersionInfo" + case (._canImportExpr, 7): + return "versionInfo" + case (._canImportExpr, 8): + return "unexpectedBetweenVersionInfoAndRightParen" + case (._canImportExpr, 9): + return "rightParen" + case (._canImportExpr, 10): + return "unexpectedAfterRightParen" + case (._canImportVersionInfo, 0): + return "unexpectedBeforeComma" + case (._canImportVersionInfo, 1): + return "comma" + case (._canImportVersionInfo, 2): + return "unexpectedBetweenCommaAndLabel" + case (._canImportVersionInfo, 3): + return "label" + case (._canImportVersionInfo, 4): + return "unexpectedBetweenLabelAndColon" + case (._canImportVersionInfo, 5): + return "colon" + case (._canImportVersionInfo, 6): + return "unexpectedBetweenColonAndVersion" + case (._canImportVersionInfo, 7): + return "version" + case (._canImportVersionInfo, 8): + return "unexpectedAfterVersion" + case (.catchClause, 0): + return "unexpectedBeforeCatchKeyword" + case (.catchClause, 1): + return "catchKeyword" + case (.catchClause, 2): + return "unexpectedBetweenCatchKeywordAndCatchItems" + case (.catchClause, 3): + return "catchItems" + case (.catchClause, 4): + return "unexpectedBetweenCatchItemsAndBody" + case (.catchClause, 5): + return "body" + case (.catchClause, 6): + return "unexpectedAfterBody" + case (.catchItem, 0): + return "unexpectedBeforePattern" + case (.catchItem, 1): + return "pattern" + case (.catchItem, 2): + return "unexpectedBetweenPatternAndWhereClause" + case (.catchItem, 3): + return "whereClause" + case (.catchItem, 4): + return "unexpectedBetweenWhereClauseAndTrailingComma" + case (.catchItem, 5): + return "trailingComma" + case (.catchItem, 6): + return "unexpectedAfterTrailingComma" + case (.classDecl, 0): + return "unexpectedBeforeAttributes" + case (.classDecl, 1): + return "attributes" + case (.classDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.classDecl, 3): + return "modifiers" + case (.classDecl, 4): + return "unexpectedBetweenModifiersAndClassKeyword" + case (.classDecl, 5): + return "classKeyword" + case (.classDecl, 6): + return "unexpectedBetweenClassKeywordAndName" + case (.classDecl, 7): + return "name" + case (.classDecl, 8): + return "unexpectedBetweenNameAndGenericParameterClause" + case (.classDecl, 9): + return "genericParameterClause" + case (.classDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" + case (.classDecl, 11): + return "inheritanceClause" + case (.classDecl, 12): + return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" + case (.classDecl, 13): + return "genericWhereClause" + case (.classDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case (.classDecl, 15): + return "memberBlock" + case (.classDecl, 16): + return "unexpectedAfterMemberBlock" + case (.classRestrictionType, 0): + return "unexpectedBeforeClassKeyword" + case (.classRestrictionType, 1): + return "classKeyword" + case (.classRestrictionType, 2): + return "unexpectedAfterClassKeyword" + case (.closureCaptureClause, 0): + return "unexpectedBeforeLeftSquare" + case (.closureCaptureClause, 1): + return "leftSquare" + case (.closureCaptureClause, 2): + return "unexpectedBetweenLeftSquareAndItems" + case (.closureCaptureClause, 3): + return "items" + case (.closureCaptureClause, 4): + return "unexpectedBetweenItemsAndRightSquare" + case (.closureCaptureClause, 5): + return "rightSquare" + case (.closureCaptureClause, 6): + return "unexpectedAfterRightSquare" + case (.closureCaptureSpecifier, 0): + return "unexpectedBeforeSpecifier" + case (.closureCaptureSpecifier, 1): + return "specifier" + case (.closureCaptureSpecifier, 2): + return "unexpectedBetweenSpecifierAndLeftParen" + case (.closureCaptureSpecifier, 3): + return "leftParen" + case (.closureCaptureSpecifier, 4): + return "unexpectedBetweenLeftParenAndDetail" + case (.closureCaptureSpecifier, 5): + return "detail" + case (.closureCaptureSpecifier, 6): + return "unexpectedBetweenDetailAndRightParen" + case (.closureCaptureSpecifier, 7): + return "rightParen" + case (.closureCaptureSpecifier, 8): + return "unexpectedAfterRightParen" + case (.closureCapture, 0): + return "unexpectedBeforeSpecifier" + case (.closureCapture, 1): + return "specifier" + case (.closureCapture, 2): + return "unexpectedBetweenSpecifierAndName" + case (.closureCapture, 3): + return "name" + case (.closureCapture, 4): + return "unexpectedBetweenNameAndInitializer" + case (.closureCapture, 5): + return "initializer" + case (.closureCapture, 6): + return "unexpectedBetweenInitializerAndTrailingComma" + case (.closureCapture, 7): + return "trailingComma" + case (.closureCapture, 8): + return "unexpectedAfterTrailingComma" + case (.closureExpr, 0): + return "unexpectedBeforeLeftBrace" + case (.closureExpr, 1): + return "leftBrace" + case (.closureExpr, 2): + return "unexpectedBetweenLeftBraceAndSignature" + case (.closureExpr, 3): + return "signature" + case (.closureExpr, 4): + return "unexpectedBetweenSignatureAndStatements" + case (.closureExpr, 5): + return "statements" + case (.closureExpr, 6): + return "unexpectedBetweenStatementsAndRightBrace" + case (.closureExpr, 7): + return "rightBrace" + case (.closureExpr, 8): + return "unexpectedAfterRightBrace" + case (.closureParameterClause, 0): + return "unexpectedBeforeLeftParen" + case (.closureParameterClause, 1): + return "leftParen" + case (.closureParameterClause, 2): + return "unexpectedBetweenLeftParenAndParameters" + case (.closureParameterClause, 3): + return "parameters" + case (.closureParameterClause, 4): + return "unexpectedBetweenParametersAndRightParen" + case (.closureParameterClause, 5): + return "rightParen" + case (.closureParameterClause, 6): + return "unexpectedAfterRightParen" + case (.closureParameter, 0): + return "unexpectedBeforeAttributes" + case (.closureParameter, 1): + return "attributes" + case (.closureParameter, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.closureParameter, 3): + return "modifiers" + case (.closureParameter, 4): + return "unexpectedBetweenModifiersAndFirstName" + case (.closureParameter, 5): + return "firstName" + case (.closureParameter, 6): + return "unexpectedBetweenFirstNameAndSecondName" + case (.closureParameter, 7): + return "secondName" + case (.closureParameter, 8): + return "unexpectedBetweenSecondNameAndColon" + case (.closureParameter, 9): + return "colon" + case (.closureParameter, 10): + return "unexpectedBetweenColonAndType" + case (.closureParameter, 11): + return "type" + case (.closureParameter, 12): + return "unexpectedBetweenTypeAndEllipsis" + case (.closureParameter, 13): + return "ellipsis" + case (.closureParameter, 14): + return "unexpectedBetweenEllipsisAndTrailingComma" + case (.closureParameter, 15): + return "trailingComma" + case (.closureParameter, 16): + return "unexpectedAfterTrailingComma" + case (.closureShorthandParameter, 0): + return "unexpectedBeforeName" + case (.closureShorthandParameter, 1): + return "name" + case (.closureShorthandParameter, 2): + return "unexpectedBetweenNameAndTrailingComma" + case (.closureShorthandParameter, 3): + return "trailingComma" + case (.closureShorthandParameter, 4): + return "unexpectedAfterTrailingComma" + case (.closureSignature, 0): + return "unexpectedBeforeAttributes" + case (.closureSignature, 1): + return "attributes" + case (.closureSignature, 2): + return "unexpectedBetweenAttributesAndCapture" + case (.closureSignature, 3): + return "capture" + case (.closureSignature, 4): + return "unexpectedBetweenCaptureAndParameterClause" + case (.closureSignature, 5): + return "parameterClause" + case (.closureSignature, 6): + return "unexpectedBetweenParameterClauseAndEffectSpecifiers" + case (.closureSignature, 7): + return "effectSpecifiers" + case (.closureSignature, 8): + return "unexpectedBetweenEffectSpecifiersAndReturnClause" + case (.closureSignature, 9): + return "returnClause" + case (.closureSignature, 10): + return "unexpectedBetweenReturnClauseAndInKeyword" + case (.closureSignature, 11): + return "inKeyword" + case (.closureSignature, 12): + return "unexpectedAfterInKeyword" + case (.codeBlockItem, 0): + return "unexpectedBeforeItem" + case (.codeBlockItem, 1): + return "item" + case (.codeBlockItem, 2): + return "unexpectedBetweenItemAndSemicolon" + case (.codeBlockItem, 3): + return "semicolon" + case (.codeBlockItem, 4): + return "unexpectedAfterSemicolon" + case (.codeBlock, 0): + return "unexpectedBeforeLeftBrace" + case (.codeBlock, 1): + return "leftBrace" + case (.codeBlock, 2): + return "unexpectedBetweenLeftBraceAndStatements" + case (.codeBlock, 3): + return "statements" + case (.codeBlock, 4): + return "unexpectedBetweenStatementsAndRightBrace" + case (.codeBlock, 5): + return "rightBrace" + case (.codeBlock, 6): + return "unexpectedAfterRightBrace" + case (.compositionTypeElement, 0): + return "unexpectedBeforeType" + case (.compositionTypeElement, 1): + return "type" + case (.compositionTypeElement, 2): + return "unexpectedBetweenTypeAndAmpersand" + case (.compositionTypeElement, 3): + return "ampersand" + case (.compositionTypeElement, 4): + return "unexpectedAfterAmpersand" + case (.compositionType, 0): + return "unexpectedBeforeElements" + case (.compositionType, 1): + return "elements" + case (.compositionType, 2): + return "unexpectedAfterElements" + case (.conditionElement, 0): + return "unexpectedBeforeCondition" + case (.conditionElement, 1): + return "condition" + case (.conditionElement, 2): + return "unexpectedBetweenConditionAndTrailingComma" + case (.conditionElement, 3): + return "trailingComma" + case (.conditionElement, 4): + return "unexpectedAfterTrailingComma" + case (.conformanceRequirement, 0): + return "unexpectedBeforeLeftType" + case (.conformanceRequirement, 1): + return "leftType" + case (.conformanceRequirement, 2): + return "unexpectedBetweenLeftTypeAndColon" + case (.conformanceRequirement, 3): + return "colon" + case (.conformanceRequirement, 4): + return "unexpectedBetweenColonAndRightType" + case (.conformanceRequirement, 5): + return "rightType" + case (.conformanceRequirement, 6): + return "unexpectedAfterRightType" + case (.consumeExpr, 0): + return "unexpectedBeforeConsumeKeyword" + case (.consumeExpr, 1): + return "consumeKeyword" + case (.consumeExpr, 2): + return "unexpectedBetweenConsumeKeywordAndExpression" + case (.consumeExpr, 3): + return "expression" + case (.consumeExpr, 4): + return "unexpectedAfterExpression" + case (.continueStmt, 0): + return "unexpectedBeforeContinueKeyword" + case (.continueStmt, 1): + return "continueKeyword" + case (.continueStmt, 2): + return "unexpectedBetweenContinueKeywordAndLabel" + case (.continueStmt, 3): + return "label" + case (.continueStmt, 4): + return "unexpectedAfterLabel" + case (.conventionAttributeArguments, 0): + return "unexpectedBeforeConventionLabel" + case (.conventionAttributeArguments, 1): + return "conventionLabel" + case (.conventionAttributeArguments, 2): + return "unexpectedBetweenConventionLabelAndComma" + case (.conventionAttributeArguments, 3): + return "comma" + case (.conventionAttributeArguments, 4): + return "unexpectedBetweenCommaAndCTypeLabel" + case (.conventionAttributeArguments, 5): + return "cTypeLabel" + case (.conventionAttributeArguments, 6): + return "unexpectedBetweenCTypeLabelAndColon" + case (.conventionAttributeArguments, 7): + return "colon" + case (.conventionAttributeArguments, 8): + return "unexpectedBetweenColonAndCTypeString" + case (.conventionAttributeArguments, 9): + return "cTypeString" + case (.conventionAttributeArguments, 10): + return "unexpectedAfterCTypeString" + case (.conventionWitnessMethodAttributeArguments, 0): + return "unexpectedBeforeWitnessMethodLabel" + case (.conventionWitnessMethodAttributeArguments, 1): + return "witnessMethodLabel" + case (.conventionWitnessMethodAttributeArguments, 2): + return "unexpectedBetweenWitnessMethodLabelAndColon" + case (.conventionWitnessMethodAttributeArguments, 3): + return "colon" + case (.conventionWitnessMethodAttributeArguments, 4): + return "unexpectedBetweenColonAndProtocolName" + case (.conventionWitnessMethodAttributeArguments, 5): + return "protocolName" + case (.conventionWitnessMethodAttributeArguments, 6): + return "unexpectedAfterProtocolName" + case (.copyExpr, 0): + return "unexpectedBeforeCopyKeyword" + case (.copyExpr, 1): + return "copyKeyword" + case (.copyExpr, 2): + return "unexpectedBetweenCopyKeywordAndExpression" + case (.copyExpr, 3): + return "expression" + case (.copyExpr, 4): + return "unexpectedAfterExpression" + case (.declModifierDetail, 0): + return "unexpectedBeforeLeftParen" + case (.declModifierDetail, 1): + return "leftParen" + case (.declModifierDetail, 2): + return "unexpectedBetweenLeftParenAndDetail" + case (.declModifierDetail, 3): + return "detail" + case (.declModifierDetail, 4): + return "unexpectedBetweenDetailAndRightParen" + case (.declModifierDetail, 5): + return "rightParen" + case (.declModifierDetail, 6): + return "unexpectedAfterRightParen" + case (.declModifier, 0): + return "unexpectedBeforeName" + case (.declModifier, 1): + return "name" + case (.declModifier, 2): + return "unexpectedBetweenNameAndDetail" + case (.declModifier, 3): + return "detail" + case (.declModifier, 4): + return "unexpectedAfterDetail" + case (.declNameArgument, 0): + return "unexpectedBeforeName" + case (.declNameArgument, 1): + return "name" + case (.declNameArgument, 2): + return "unexpectedBetweenNameAndColon" + case (.declNameArgument, 3): + return "colon" + case (.declNameArgument, 4): + return "unexpectedAfterColon" + case (.declNameArguments, 0): + return "unexpectedBeforeLeftParen" + case (.declNameArguments, 1): + return "leftParen" + case (.declNameArguments, 2): + return "unexpectedBetweenLeftParenAndArguments" + case (.declNameArguments, 3): + return "arguments" + case (.declNameArguments, 4): + return "unexpectedBetweenArgumentsAndRightParen" + case (.declNameArguments, 5): + return "rightParen" + case (.declNameArguments, 6): + return "unexpectedAfterRightParen" + case (.declReferenceExpr, 0): + return "unexpectedBeforeBaseName" + case (.declReferenceExpr, 1): + return "baseName" + case (.declReferenceExpr, 2): + return "unexpectedBetweenBaseNameAndArgumentNames" + case (.declReferenceExpr, 3): + return "argumentNames" + case (.declReferenceExpr, 4): + return "unexpectedAfterArgumentNames" + case (.deferStmt, 0): + return "unexpectedBeforeDeferKeyword" + case (.deferStmt, 1): + return "deferKeyword" + case (.deferStmt, 2): + return "unexpectedBetweenDeferKeywordAndBody" + case (.deferStmt, 3): + return "body" + case (.deferStmt, 4): + return "unexpectedAfterBody" + case (.deinitializerDecl, 0): + return "unexpectedBeforeAttributes" + case (.deinitializerDecl, 1): + return "attributes" + case (.deinitializerDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.deinitializerDecl, 3): + return "modifiers" + case (.deinitializerDecl, 4): + return "unexpectedBetweenModifiersAndDeinitKeyword" + case (.deinitializerDecl, 5): + return "deinitKeyword" + case (.deinitializerDecl, 6): + return "unexpectedBetweenDeinitKeywordAndEffectSpecifiers" + case (.deinitializerDecl, 7): + return "effectSpecifiers" + case (.deinitializerDecl, 8): + return "unexpectedBetweenEffectSpecifiersAndBody" + case (.deinitializerDecl, 9): + return "body" + case (.deinitializerDecl, 10): + return "unexpectedAfterBody" + case (.deinitializerEffectSpecifiers, 0): + return "unexpectedBeforeAsyncSpecifier" + case (.deinitializerEffectSpecifiers, 1): + return "asyncSpecifier" + case (.deinitializerEffectSpecifiers, 2): + return "unexpectedAfterAsyncSpecifier" + case (.derivativeAttributeArguments, 0): + return "unexpectedBeforeOfLabel" + case (.derivativeAttributeArguments, 1): + return "ofLabel" + case (.derivativeAttributeArguments, 2): + return "unexpectedBetweenOfLabelAndColon" + case (.derivativeAttributeArguments, 3): + return "colon" + case (.derivativeAttributeArguments, 4): + return "unexpectedBetweenColonAndOriginalDeclName" + case (.derivativeAttributeArguments, 5): + return "originalDeclName" + case (.derivativeAttributeArguments, 6): + return "unexpectedBetweenOriginalDeclNameAndPeriod" + case (.derivativeAttributeArguments, 7): + return "period" + case (.derivativeAttributeArguments, 8): + return "unexpectedBetweenPeriodAndAccessorSpecifier" + case (.derivativeAttributeArguments, 9): + return "accessorSpecifier" + case (.derivativeAttributeArguments, 10): + return "unexpectedBetweenAccessorSpecifierAndComma" + case (.derivativeAttributeArguments, 11): + return "comma" + case (.derivativeAttributeArguments, 12): + return "unexpectedBetweenCommaAndArguments" + case (.derivativeAttributeArguments, 13): + return "arguments" + case (.derivativeAttributeArguments, 14): + return "unexpectedAfterArguments" + case (.designatedType, 0): + return "unexpectedBeforeLeadingComma" + case (.designatedType, 1): + return "leadingComma" + case (.designatedType, 2): + return "unexpectedBetweenLeadingCommaAndName" + case (.designatedType, 3): + return "name" + case (.designatedType, 4): + return "unexpectedAfterName" + case (.dictionaryElement, 0): + return "unexpectedBeforeKey" + case (.dictionaryElement, 1): + return "key" + case (.dictionaryElement, 2): + return "unexpectedBetweenKeyAndColon" + case (.dictionaryElement, 3): + return "colon" + case (.dictionaryElement, 4): + return "unexpectedBetweenColonAndValue" + case (.dictionaryElement, 5): + return "value" + case (.dictionaryElement, 6): + return "unexpectedBetweenValueAndTrailingComma" + case (.dictionaryElement, 7): + return "trailingComma" + case (.dictionaryElement, 8): + return "unexpectedAfterTrailingComma" + case (.dictionaryExpr, 0): + return "unexpectedBeforeLeftSquare" + case (.dictionaryExpr, 1): + return "leftSquare" + case (.dictionaryExpr, 2): + return "unexpectedBetweenLeftSquareAndContent" + case (.dictionaryExpr, 3): + return "content" + case (.dictionaryExpr, 4): + return "unexpectedBetweenContentAndRightSquare" + case (.dictionaryExpr, 5): + return "rightSquare" + case (.dictionaryExpr, 6): + return "unexpectedAfterRightSquare" + case (.dictionaryType, 0): + return "unexpectedBeforeLeftSquare" + case (.dictionaryType, 1): + return "leftSquare" + case (.dictionaryType, 2): + return "unexpectedBetweenLeftSquareAndKey" + case (.dictionaryType, 3): + return "key" + case (.dictionaryType, 4): + return "unexpectedBetweenKeyAndColon" + case (.dictionaryType, 5): + return "colon" + case (.dictionaryType, 6): + return "unexpectedBetweenColonAndValue" + case (.dictionaryType, 7): + return "value" + case (.dictionaryType, 8): + return "unexpectedBetweenValueAndRightSquare" + case (.dictionaryType, 9): + return "rightSquare" + case (.dictionaryType, 10): + return "unexpectedAfterRightSquare" + case (.differentiabilityArgument, 0): + return "unexpectedBeforeArgument" + case (.differentiabilityArgument, 1): + return "argument" + case (.differentiabilityArgument, 2): + return "unexpectedBetweenArgumentAndTrailingComma" + case (.differentiabilityArgument, 3): + return "trailingComma" + case (.differentiabilityArgument, 4): + return "unexpectedAfterTrailingComma" + case (.differentiabilityArguments, 0): + return "unexpectedBeforeLeftParen" + case (.differentiabilityArguments, 1): + return "leftParen" + case (.differentiabilityArguments, 2): + return "unexpectedBetweenLeftParenAndArguments" + case (.differentiabilityArguments, 3): + return "arguments" + case (.differentiabilityArguments, 4): + return "unexpectedBetweenArgumentsAndRightParen" + case (.differentiabilityArguments, 5): + return "rightParen" + case (.differentiabilityArguments, 6): + return "unexpectedAfterRightParen" + case (.differentiabilityWithRespectToArgument, 0): + return "unexpectedBeforeWrtLabel" + case (.differentiabilityWithRespectToArgument, 1): + return "wrtLabel" + case (.differentiabilityWithRespectToArgument, 2): + return "unexpectedBetweenWrtLabelAndColon" + case (.differentiabilityWithRespectToArgument, 3): + return "colon" + case (.differentiabilityWithRespectToArgument, 4): + return "unexpectedBetweenColonAndArguments" + case (.differentiabilityWithRespectToArgument, 5): + return "arguments" + case (.differentiabilityWithRespectToArgument, 6): + return "unexpectedAfterArguments" + case (.differentiableAttributeArguments, 0): + return "unexpectedBeforeKindSpecifier" + case (.differentiableAttributeArguments, 1): + return "kindSpecifier" + case (.differentiableAttributeArguments, 2): + return "unexpectedBetweenKindSpecifierAndKindSpecifierComma" + case (.differentiableAttributeArguments, 3): + return "kindSpecifierComma" + case (.differentiableAttributeArguments, 4): + return "unexpectedBetweenKindSpecifierCommaAndArguments" + case (.differentiableAttributeArguments, 5): + return "arguments" + case (.differentiableAttributeArguments, 6): + return "unexpectedBetweenArgumentsAndArgumentsComma" + case (.differentiableAttributeArguments, 7): + return "argumentsComma" + case (.differentiableAttributeArguments, 8): + return "unexpectedBetweenArgumentsCommaAndGenericWhereClause" + case (.differentiableAttributeArguments, 9): + return "genericWhereClause" + case (.differentiableAttributeArguments, 10): + return "unexpectedAfterGenericWhereClause" + case (.discardAssignmentExpr, 0): + return "unexpectedBeforeWildcard" + case (.discardAssignmentExpr, 1): + return "wildcard" + case (.discardAssignmentExpr, 2): + return "unexpectedAfterWildcard" + case (.discardStmt, 0): + return "unexpectedBeforeDiscardKeyword" + case (.discardStmt, 1): + return "discardKeyword" + case (.discardStmt, 2): + return "unexpectedBetweenDiscardKeywordAndExpression" + case (.discardStmt, 3): + return "expression" + case (.discardStmt, 4): + return "unexpectedAfterExpression" + case (.doExpr, 0): + return "unexpectedBeforeDoKeyword" + case (.doExpr, 1): + return "doKeyword" + case (.doExpr, 2): + return "unexpectedBetweenDoKeywordAndBody" + case (.doExpr, 3): + return "body" + case (.doExpr, 4): + return "unexpectedBetweenBodyAndCatchClauses" + case (.doExpr, 5): + return "catchClauses" + case (.doExpr, 6): + return "unexpectedAfterCatchClauses" + case (.doStmt, 0): + return "unexpectedBeforeDoKeyword" + case (.doStmt, 1): + return "doKeyword" + case (.doStmt, 2): + return "unexpectedBetweenDoKeywordAndThrowsClause" + case (.doStmt, 3): + return "throwsClause" + case (.doStmt, 4): + return "unexpectedBetweenThrowsClauseAndBody" + case (.doStmt, 5): + return "body" + case (.doStmt, 6): + return "unexpectedBetweenBodyAndCatchClauses" + case (.doStmt, 7): + return "catchClauses" + case (.doStmt, 8): + return "unexpectedAfterCatchClauses" + case (.documentationAttributeArgument, 0): + return "unexpectedBeforeLabel" + case (.documentationAttributeArgument, 1): + return "label" + case (.documentationAttributeArgument, 2): + return "unexpectedBetweenLabelAndColon" + case (.documentationAttributeArgument, 3): + return "colon" + case (.documentationAttributeArgument, 4): + return "unexpectedBetweenColonAndValue" + case (.documentationAttributeArgument, 5): + return "value" + case (.documentationAttributeArgument, 6): + return "unexpectedBetweenValueAndTrailingComma" + case (.documentationAttributeArgument, 7): + return "trailingComma" + case (.documentationAttributeArgument, 8): + return "unexpectedAfterTrailingComma" + case (.dynamicReplacementAttributeArguments, 0): + return "unexpectedBeforeForLabel" + case (.dynamicReplacementAttributeArguments, 1): + return "forLabel" + case (.dynamicReplacementAttributeArguments, 2): + return "unexpectedBetweenForLabelAndColon" + case (.dynamicReplacementAttributeArguments, 3): + return "colon" + case (.dynamicReplacementAttributeArguments, 4): + return "unexpectedBetweenColonAndDeclName" + case (.dynamicReplacementAttributeArguments, 5): + return "declName" + case (.dynamicReplacementAttributeArguments, 6): + return "unexpectedAfterDeclName" + case (.editorPlaceholderDecl, 0): + return "unexpectedBeforeAttributes" + case (.editorPlaceholderDecl, 1): + return "attributes" + case (.editorPlaceholderDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.editorPlaceholderDecl, 3): + return "modifiers" + case (.editorPlaceholderDecl, 4): + return "unexpectedBetweenModifiersAndPlaceholder" + case (.editorPlaceholderDecl, 5): + return "placeholder" + case (.editorPlaceholderDecl, 6): + return "unexpectedAfterPlaceholder" + case (.editorPlaceholderExpr, 0): + return "unexpectedBeforePlaceholder" + case (.editorPlaceholderExpr, 1): + return "placeholder" + case (.editorPlaceholderExpr, 2): + return "unexpectedAfterPlaceholder" + case (.enumCaseDecl, 0): + return "unexpectedBeforeAttributes" + case (.enumCaseDecl, 1): + return "attributes" + case (.enumCaseDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.enumCaseDecl, 3): + return "modifiers" + case (.enumCaseDecl, 4): + return "unexpectedBetweenModifiersAndCaseKeyword" + case (.enumCaseDecl, 5): + return "caseKeyword" + case (.enumCaseDecl, 6): + return "unexpectedBetweenCaseKeywordAndElements" + case (.enumCaseDecl, 7): + return "elements" + case (.enumCaseDecl, 8): + return "unexpectedAfterElements" + case (.enumCaseElement, 0): + return "unexpectedBeforeName" + case (.enumCaseElement, 1): + return "name" + case (.enumCaseElement, 2): + return "unexpectedBetweenNameAndParameterClause" + case (.enumCaseElement, 3): + return "parameterClause" + case (.enumCaseElement, 4): + return "unexpectedBetweenParameterClauseAndRawValue" + case (.enumCaseElement, 5): + return "rawValue" + case (.enumCaseElement, 6): + return "unexpectedBetweenRawValueAndTrailingComma" + case (.enumCaseElement, 7): + return "trailingComma" + case (.enumCaseElement, 8): + return "unexpectedAfterTrailingComma" + case (.enumCaseParameterClause, 0): + return "unexpectedBeforeLeftParen" + case (.enumCaseParameterClause, 1): + return "leftParen" + case (.enumCaseParameterClause, 2): + return "unexpectedBetweenLeftParenAndParameters" + case (.enumCaseParameterClause, 3): + return "parameters" + case (.enumCaseParameterClause, 4): + return "unexpectedBetweenParametersAndRightParen" + case (.enumCaseParameterClause, 5): + return "rightParen" + case (.enumCaseParameterClause, 6): + return "unexpectedAfterRightParen" + case (.enumCaseParameter, 0): + return "unexpectedBeforeModifiers" + case (.enumCaseParameter, 1): + return "modifiers" + case (.enumCaseParameter, 2): + return "unexpectedBetweenModifiersAndFirstName" + case (.enumCaseParameter, 3): + return "firstName" + case (.enumCaseParameter, 4): + return "unexpectedBetweenFirstNameAndSecondName" + case (.enumCaseParameter, 5): + return "secondName" + case (.enumCaseParameter, 6): + return "unexpectedBetweenSecondNameAndColon" + case (.enumCaseParameter, 7): + return "colon" + case (.enumCaseParameter, 8): + return "unexpectedBetweenColonAndType" + case (.enumCaseParameter, 9): + return "type" + case (.enumCaseParameter, 10): + return "unexpectedBetweenTypeAndDefaultValue" + case (.enumCaseParameter, 11): + return "defaultValue" + case (.enumCaseParameter, 12): + return "unexpectedBetweenDefaultValueAndTrailingComma" + case (.enumCaseParameter, 13): + return "trailingComma" + case (.enumCaseParameter, 14): + return "unexpectedAfterTrailingComma" + case (.enumDecl, 0): + return "unexpectedBeforeAttributes" + case (.enumDecl, 1): + return "attributes" + case (.enumDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.enumDecl, 3): + return "modifiers" + case (.enumDecl, 4): + return "unexpectedBetweenModifiersAndEnumKeyword" + case (.enumDecl, 5): + return "enumKeyword" + case (.enumDecl, 6): + return "unexpectedBetweenEnumKeywordAndName" + case (.enumDecl, 7): + return "name" + case (.enumDecl, 8): + return "unexpectedBetweenNameAndGenericParameterClause" + case (.enumDecl, 9): + return "genericParameterClause" + case (.enumDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" + case (.enumDecl, 11): + return "inheritanceClause" + case (.enumDecl, 12): + return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" + case (.enumDecl, 13): + return "genericWhereClause" + case (.enumDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case (.enumDecl, 15): + return "memberBlock" + case (.enumDecl, 16): + return "unexpectedAfterMemberBlock" + case (.exposeAttributeArguments, 0): + return "unexpectedBeforeLanguage" + case (.exposeAttributeArguments, 1): + return "language" + case (.exposeAttributeArguments, 2): + return "unexpectedBetweenLanguageAndComma" + case (.exposeAttributeArguments, 3): + return "comma" + case (.exposeAttributeArguments, 4): + return "unexpectedBetweenCommaAndCxxName" + case (.exposeAttributeArguments, 5): + return "cxxName" + case (.exposeAttributeArguments, 6): + return "unexpectedAfterCxxName" + case (.expressionPattern, 0): + return "unexpectedBeforeExpression" + case (.expressionPattern, 1): + return "expression" + case (.expressionPattern, 2): + return "unexpectedAfterExpression" + case (.expressionSegment, 0): + return "unexpectedBeforeBackslash" + case (.expressionSegment, 1): + return "backslash" + case (.expressionSegment, 2): + return "unexpectedBetweenBackslashAndPounds" + case (.expressionSegment, 3): + return "pounds" + case (.expressionSegment, 4): + return "unexpectedBetweenPoundsAndLeftParen" + case (.expressionSegment, 5): + return "leftParen" + case (.expressionSegment, 6): + return "unexpectedBetweenLeftParenAndExpressions" + case (.expressionSegment, 7): + return "expressions" + case (.expressionSegment, 8): + return "unexpectedBetweenExpressionsAndRightParen" + case (.expressionSegment, 9): + return "rightParen" + case (.expressionSegment, 10): + return "unexpectedAfterRightParen" + case (.expressionStmt, 0): + return "unexpectedBeforeExpression" + case (.expressionStmt, 1): + return "expression" + case (.expressionStmt, 2): + return "unexpectedAfterExpression" + case (.extensionDecl, 0): + return "unexpectedBeforeAttributes" + case (.extensionDecl, 1): + return "attributes" + case (.extensionDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.extensionDecl, 3): + return "modifiers" + case (.extensionDecl, 4): + return "unexpectedBetweenModifiersAndExtensionKeyword" + case (.extensionDecl, 5): + return "extensionKeyword" + case (.extensionDecl, 6): + return "unexpectedBetweenExtensionKeywordAndExtendedType" + case (.extensionDecl, 7): + return "extendedType" + case (.extensionDecl, 8): + return "unexpectedBetweenExtendedTypeAndInheritanceClause" + case (.extensionDecl, 9): + return "inheritanceClause" + case (.extensionDecl, 10): + return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" + case (.extensionDecl, 11): + return "genericWhereClause" + case (.extensionDecl, 12): + return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case (.extensionDecl, 13): + return "memberBlock" + case (.extensionDecl, 14): + return "unexpectedAfterMemberBlock" + case (.fallThroughStmt, 0): + return "unexpectedBeforeFallthroughKeyword" + case (.fallThroughStmt, 1): + return "fallthroughKeyword" + case (.fallThroughStmt, 2): + return "unexpectedAfterFallthroughKeyword" + case (.floatLiteralExpr, 0): + return "unexpectedBeforeLiteral" + case (.floatLiteralExpr, 1): + return "literal" + case (.floatLiteralExpr, 2): + return "unexpectedAfterLiteral" + case (.forStmt, 0): + return "unexpectedBeforeForKeyword" + case (.forStmt, 1): + return "forKeyword" + case (.forStmt, 2): + return "unexpectedBetweenForKeywordAndTryKeyword" + case (.forStmt, 3): + return "tryKeyword" + case (.forStmt, 4): + return "unexpectedBetweenTryKeywordAndAwaitKeyword" + case (.forStmt, 5): + return "awaitKeyword" + case (.forStmt, 6): + return "unexpectedBetweenAwaitKeywordAndCaseKeyword" + case (.forStmt, 7): + return "caseKeyword" + case (.forStmt, 8): + return "unexpectedBetweenCaseKeywordAndPattern" + case (.forStmt, 9): + return "pattern" + case (.forStmt, 10): + return "unexpectedBetweenPatternAndTypeAnnotation" + case (.forStmt, 11): + return "typeAnnotation" + case (.forStmt, 12): + return "unexpectedBetweenTypeAnnotationAndInKeyword" + case (.forStmt, 13): + return "inKeyword" + case (.forStmt, 14): + return "unexpectedBetweenInKeywordAndSequence" + case (.forStmt, 15): + return "sequence" + case (.forStmt, 16): + return "unexpectedBetweenSequenceAndWhereClause" + case (.forStmt, 17): + return "whereClause" + case (.forStmt, 18): + return "unexpectedBetweenWhereClauseAndBody" + case (.forStmt, 19): + return "body" + case (.forStmt, 20): + return "unexpectedAfterBody" + case (.forceUnwrapExpr, 0): + return "unexpectedBeforeExpression" + case (.forceUnwrapExpr, 1): + return "expression" + case (.forceUnwrapExpr, 2): + return "unexpectedBetweenExpressionAndExclamationMark" + case (.forceUnwrapExpr, 3): + return "exclamationMark" + case (.forceUnwrapExpr, 4): + return "unexpectedAfterExclamationMark" + case (.functionCallExpr, 0): + return "unexpectedBeforeCalledExpression" + case (.functionCallExpr, 1): + return "calledExpression" + case (.functionCallExpr, 2): + return "unexpectedBetweenCalledExpressionAndLeftParen" + case (.functionCallExpr, 3): + return "leftParen" + case (.functionCallExpr, 4): + return "unexpectedBetweenLeftParenAndArguments" + case (.functionCallExpr, 5): + return "arguments" + case (.functionCallExpr, 6): + return "unexpectedBetweenArgumentsAndRightParen" + case (.functionCallExpr, 7): + return "rightParen" + case (.functionCallExpr, 8): + return "unexpectedBetweenRightParenAndTrailingClosure" + case (.functionCallExpr, 9): + return "trailingClosure" + case (.functionCallExpr, 10): + return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" + case (.functionCallExpr, 11): + return "additionalTrailingClosures" + case (.functionCallExpr, 12): + return "unexpectedAfterAdditionalTrailingClosures" + case (.functionDecl, 0): + return "unexpectedBeforeAttributes" + case (.functionDecl, 1): + return "attributes" + case (.functionDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.functionDecl, 3): + return "modifiers" + case (.functionDecl, 4): + return "unexpectedBetweenModifiersAndFuncKeyword" + case (.functionDecl, 5): + return "funcKeyword" + case (.functionDecl, 6): + return "unexpectedBetweenFuncKeywordAndName" + case (.functionDecl, 7): + return "name" + case (.functionDecl, 8): + return "unexpectedBetweenNameAndGenericParameterClause" + case (.functionDecl, 9): + return "genericParameterClause" + case (.functionDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndSignature" + case (.functionDecl, 11): + return "signature" + case (.functionDecl, 12): + return "unexpectedBetweenSignatureAndGenericWhereClause" + case (.functionDecl, 13): + return "genericWhereClause" + case (.functionDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndBody" + case (.functionDecl, 15): + return "body" + case (.functionDecl, 16): + return "unexpectedAfterBody" + case (.functionEffectSpecifiers, 0): + return "unexpectedBeforeAsyncSpecifier" + case (.functionEffectSpecifiers, 1): + return "asyncSpecifier" + case (.functionEffectSpecifiers, 2): + return "unexpectedBetweenAsyncSpecifierAndThrowsClause" + case (.functionEffectSpecifiers, 3): + return "throwsClause" + case (.functionEffectSpecifiers, 4): + return "unexpectedAfterThrowsClause" + case (.functionParameterClause, 0): + return "unexpectedBeforeLeftParen" + case (.functionParameterClause, 1): + return "leftParen" + case (.functionParameterClause, 2): + return "unexpectedBetweenLeftParenAndParameters" + case (.functionParameterClause, 3): + return "parameters" + case (.functionParameterClause, 4): + return "unexpectedBetweenParametersAndRightParen" + case (.functionParameterClause, 5): + return "rightParen" + case (.functionParameterClause, 6): + return "unexpectedAfterRightParen" + case (.functionParameter, 0): + return "unexpectedBeforeAttributes" + case (.functionParameter, 1): + return "attributes" + case (.functionParameter, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.functionParameter, 3): + return "modifiers" + case (.functionParameter, 4): + return "unexpectedBetweenModifiersAndFirstName" + case (.functionParameter, 5): + return "firstName" + case (.functionParameter, 6): + return "unexpectedBetweenFirstNameAndSecondName" + case (.functionParameter, 7): + return "secondName" + case (.functionParameter, 8): + return "unexpectedBetweenSecondNameAndColon" + case (.functionParameter, 9): + return "colon" + case (.functionParameter, 10): + return "unexpectedBetweenColonAndType" + case (.functionParameter, 11): + return "type" + case (.functionParameter, 12): + return "unexpectedBetweenTypeAndEllipsis" + case (.functionParameter, 13): + return "ellipsis" + case (.functionParameter, 14): + return "unexpectedBetweenEllipsisAndDefaultValue" + case (.functionParameter, 15): + return "defaultValue" + case (.functionParameter, 16): + return "unexpectedBetweenDefaultValueAndTrailingComma" + case (.functionParameter, 17): + return "trailingComma" + case (.functionParameter, 18): + return "unexpectedAfterTrailingComma" + case (.functionSignature, 0): + return "unexpectedBeforeParameterClause" + case (.functionSignature, 1): + return "parameterClause" + case (.functionSignature, 2): + return "unexpectedBetweenParameterClauseAndEffectSpecifiers" + case (.functionSignature, 3): + return "effectSpecifiers" + case (.functionSignature, 4): + return "unexpectedBetweenEffectSpecifiersAndReturnClause" + case (.functionSignature, 5): + return "returnClause" + case (.functionSignature, 6): + return "unexpectedAfterReturnClause" + case (.functionType, 0): + return "unexpectedBeforeLeftParen" + case (.functionType, 1): + return "leftParen" + case (.functionType, 2): + return "unexpectedBetweenLeftParenAndParameters" + case (.functionType, 3): + return "parameters" + case (.functionType, 4): + return "unexpectedBetweenParametersAndRightParen" + case (.functionType, 5): + return "rightParen" + case (.functionType, 6): + return "unexpectedBetweenRightParenAndEffectSpecifiers" + case (.functionType, 7): + return "effectSpecifiers" + case (.functionType, 8): + return "unexpectedBetweenEffectSpecifiersAndReturnClause" + case (.functionType, 9): + return "returnClause" + case (.functionType, 10): + return "unexpectedAfterReturnClause" + case (.genericArgumentClause, 0): + return "unexpectedBeforeLeftAngle" + case (.genericArgumentClause, 1): + return "leftAngle" + case (.genericArgumentClause, 2): + return "unexpectedBetweenLeftAngleAndArguments" + case (.genericArgumentClause, 3): + return "arguments" + case (.genericArgumentClause, 4): + return "unexpectedBetweenArgumentsAndRightAngle" + case (.genericArgumentClause, 5): + return "rightAngle" + case (.genericArgumentClause, 6): + return "unexpectedAfterRightAngle" + case (.genericArgument, 0): + return "unexpectedBeforeArgument" + case (.genericArgument, 1): + return "argument" + case (.genericArgument, 2): + return "unexpectedBetweenArgumentAndTrailingComma" + case (.genericArgument, 3): + return "trailingComma" + case (.genericArgument, 4): + return "unexpectedAfterTrailingComma" + case (.genericParameterClause, 0): + return "unexpectedBeforeLeftAngle" + case (.genericParameterClause, 1): + return "leftAngle" + case (.genericParameterClause, 2): + return "unexpectedBetweenLeftAngleAndParameters" + case (.genericParameterClause, 3): + return "parameters" + case (.genericParameterClause, 4): + return "unexpectedBetweenParametersAndGenericWhereClause" + case (.genericParameterClause, 5): + return "genericWhereClause" + case (.genericParameterClause, 6): + return "unexpectedBetweenGenericWhereClauseAndRightAngle" + case (.genericParameterClause, 7): + return "rightAngle" + case (.genericParameterClause, 8): + return "unexpectedAfterRightAngle" + case (.genericParameter, 0): + return "unexpectedBeforeAttributes" + case (.genericParameter, 1): + return "attributes" + case (.genericParameter, 2): + return "unexpectedBetweenAttributesAndSpecifier" + case (.genericParameter, 3): + return "specifier" + case (.genericParameter, 4): + return "unexpectedBetweenSpecifierAndName" + case (.genericParameter, 5): + return "name" + case (.genericParameter, 6): + return "unexpectedBetweenNameAndColon" + case (.genericParameter, 7): + return "colon" + case (.genericParameter, 8): + return "unexpectedBetweenColonAndInheritedType" + case (.genericParameter, 9): + return "inheritedType" + case (.genericParameter, 10): + return "unexpectedBetweenInheritedTypeAndTrailingComma" + case (.genericParameter, 11): + return "trailingComma" + case (.genericParameter, 12): + return "unexpectedAfterTrailingComma" + case (.genericRequirement, 0): + return "unexpectedBeforeRequirement" + case (.genericRequirement, 1): + return "requirement" + case (.genericRequirement, 2): + return "unexpectedBetweenRequirementAndTrailingComma" + case (.genericRequirement, 3): + return "trailingComma" + case (.genericRequirement, 4): + return "unexpectedAfterTrailingComma" + case (.genericSpecializationExpr, 0): + return "unexpectedBeforeExpression" + case (.genericSpecializationExpr, 1): + return "expression" + case (.genericSpecializationExpr, 2): + return "unexpectedBetweenExpressionAndGenericArgumentClause" + case (.genericSpecializationExpr, 3): + return "genericArgumentClause" + case (.genericSpecializationExpr, 4): + return "unexpectedAfterGenericArgumentClause" + case (.genericWhereClause, 0): + return "unexpectedBeforeWhereKeyword" + case (.genericWhereClause, 1): + return "whereKeyword" + case (.genericWhereClause, 2): + return "unexpectedBetweenWhereKeywordAndRequirements" + case (.genericWhereClause, 3): + return "requirements" + case (.genericWhereClause, 4): + return "unexpectedAfterRequirements" + case (.guardStmt, 0): + return "unexpectedBeforeGuardKeyword" + case (.guardStmt, 1): + return "guardKeyword" + case (.guardStmt, 2): + return "unexpectedBetweenGuardKeywordAndConditions" + case (.guardStmt, 3): + return "conditions" + case (.guardStmt, 4): + return "unexpectedBetweenConditionsAndElseKeyword" + case (.guardStmt, 5): + return "elseKeyword" + case (.guardStmt, 6): + return "unexpectedBetweenElseKeywordAndBody" + case (.guardStmt, 7): + return "body" + case (.guardStmt, 8): + return "unexpectedAfterBody" + case (.identifierPattern, 0): + return "unexpectedBeforeIdentifier" + case (.identifierPattern, 1): + return "identifier" + case (.identifierPattern, 2): + return "unexpectedAfterIdentifier" + case (.identifierType, 0): + return "unexpectedBeforeName" + case (.identifierType, 1): + return "name" + case (.identifierType, 2): + return "unexpectedBetweenNameAndGenericArgumentClause" + case (.identifierType, 3): + return "genericArgumentClause" + case (.identifierType, 4): + return "unexpectedAfterGenericArgumentClause" + case (.ifConfigClause, 0): + return "unexpectedBeforePoundKeyword" + case (.ifConfigClause, 1): + return "poundKeyword" + case (.ifConfigClause, 2): + return "unexpectedBetweenPoundKeywordAndCondition" + case (.ifConfigClause, 3): + return "condition" + case (.ifConfigClause, 4): + return "unexpectedBetweenConditionAndElements" + case (.ifConfigClause, 5): + return "elements" + case (.ifConfigClause, 6): + return "unexpectedAfterElements" + case (.ifConfigDecl, 0): + return "unexpectedBeforeClauses" + case (.ifConfigDecl, 1): + return "clauses" + case (.ifConfigDecl, 2): + return "unexpectedBetweenClausesAndPoundEndif" + case (.ifConfigDecl, 3): + return "poundEndif" + case (.ifConfigDecl, 4): + return "unexpectedAfterPoundEndif" + case (.ifExpr, 0): + return "unexpectedBeforeIfKeyword" + case (.ifExpr, 1): + return "ifKeyword" + case (.ifExpr, 2): + return "unexpectedBetweenIfKeywordAndConditions" + case (.ifExpr, 3): + return "conditions" + case (.ifExpr, 4): + return "unexpectedBetweenConditionsAndBody" + case (.ifExpr, 5): + return "body" + case (.ifExpr, 6): + return "unexpectedBetweenBodyAndElseKeyword" + case (.ifExpr, 7): + return "elseKeyword" + case (.ifExpr, 8): + return "unexpectedBetweenElseKeywordAndElseBody" + case (.ifExpr, 9): + return "elseBody" + case (.ifExpr, 10): + return "unexpectedAfterElseBody" + case (.implementsAttributeArguments, 0): + return "unexpectedBeforeType" + case (.implementsAttributeArguments, 1): + return "type" + case (.implementsAttributeArguments, 2): + return "unexpectedBetweenTypeAndComma" + case (.implementsAttributeArguments, 3): + return "comma" + case (.implementsAttributeArguments, 4): + return "unexpectedBetweenCommaAndDeclName" + case (.implementsAttributeArguments, 5): + return "declName" + case (.implementsAttributeArguments, 6): + return "unexpectedAfterDeclName" + case (.implicitlyUnwrappedOptionalType, 0): + return "unexpectedBeforeWrappedType" + case (.implicitlyUnwrappedOptionalType, 1): + return "wrappedType" + case (.implicitlyUnwrappedOptionalType, 2): + return "unexpectedBetweenWrappedTypeAndExclamationMark" + case (.implicitlyUnwrappedOptionalType, 3): + return "exclamationMark" + case (.implicitlyUnwrappedOptionalType, 4): + return "unexpectedAfterExclamationMark" + case (.importDecl, 0): + return "unexpectedBeforeAttributes" + case (.importDecl, 1): + return "attributes" + case (.importDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.importDecl, 3): + return "modifiers" + case (.importDecl, 4): + return "unexpectedBetweenModifiersAndImportKeyword" + case (.importDecl, 5): + return "importKeyword" + case (.importDecl, 6): + return "unexpectedBetweenImportKeywordAndImportKindSpecifier" + case (.importDecl, 7): + return "importKindSpecifier" + case (.importDecl, 8): + return "unexpectedBetweenImportKindSpecifierAndPath" + case (.importDecl, 9): + return "path" + case (.importDecl, 10): + return "unexpectedAfterPath" + case (.importPathComponent, 0): + return "unexpectedBeforeName" + case (.importPathComponent, 1): + return "name" + case (.importPathComponent, 2): + return "unexpectedBetweenNameAndTrailingPeriod" + case (.importPathComponent, 3): + return "trailingPeriod" + case (.importPathComponent, 4): + return "unexpectedAfterTrailingPeriod" + case (.inOutExpr, 0): + return "unexpectedBeforeAmpersand" + case (.inOutExpr, 1): + return "ampersand" + case (.inOutExpr, 2): + return "unexpectedBetweenAmpersandAndExpression" + case (.inOutExpr, 3): + return "expression" + case (.inOutExpr, 4): + return "unexpectedAfterExpression" + case (.infixOperatorExpr, 0): + return "unexpectedBeforeLeftOperand" + case (.infixOperatorExpr, 1): + return "leftOperand" + case (.infixOperatorExpr, 2): + return "unexpectedBetweenLeftOperandAndOperator" + case (.infixOperatorExpr, 3): + return "operator" + case (.infixOperatorExpr, 4): + return "unexpectedBetweenOperatorAndRightOperand" + case (.infixOperatorExpr, 5): + return "rightOperand" + case (.infixOperatorExpr, 6): + return "unexpectedAfterRightOperand" + case (.inheritanceClause, 0): + return "unexpectedBeforeColon" + case (.inheritanceClause, 1): + return "colon" + case (.inheritanceClause, 2): + return "unexpectedBetweenColonAndInheritedTypes" + case (.inheritanceClause, 3): + return "inheritedTypes" + case (.inheritanceClause, 4): + return "unexpectedAfterInheritedTypes" + case (.inheritedType, 0): + return "unexpectedBeforeType" + case (.inheritedType, 1): + return "type" + case (.inheritedType, 2): + return "unexpectedBetweenTypeAndTrailingComma" + case (.inheritedType, 3): + return "trailingComma" + case (.inheritedType, 4): + return "unexpectedAfterTrailingComma" + case (.initializerClause, 0): + return "unexpectedBeforeEqual" + case (.initializerClause, 1): + return "equal" + case (.initializerClause, 2): + return "unexpectedBetweenEqualAndValue" + case (.initializerClause, 3): + return "value" + case (.initializerClause, 4): + return "unexpectedAfterValue" + case (.initializerDecl, 0): + return "unexpectedBeforeAttributes" + case (.initializerDecl, 1): + return "attributes" + case (.initializerDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.initializerDecl, 3): + return "modifiers" + case (.initializerDecl, 4): + return "unexpectedBetweenModifiersAndInitKeyword" + case (.initializerDecl, 5): + return "initKeyword" + case (.initializerDecl, 6): + return "unexpectedBetweenInitKeywordAndOptionalMark" + case (.initializerDecl, 7): + return "optionalMark" + case (.initializerDecl, 8): + return "unexpectedBetweenOptionalMarkAndGenericParameterClause" + case (.initializerDecl, 9): + return "genericParameterClause" + case (.initializerDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndSignature" + case (.initializerDecl, 11): + return "signature" + case (.initializerDecl, 12): + return "unexpectedBetweenSignatureAndGenericWhereClause" + case (.initializerDecl, 13): + return "genericWhereClause" + case (.initializerDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndBody" + case (.initializerDecl, 15): + return "body" + case (.initializerDecl, 16): + return "unexpectedAfterBody" + case (.integerLiteralExpr, 0): + return "unexpectedBeforeLiteral" + case (.integerLiteralExpr, 1): + return "literal" + case (.integerLiteralExpr, 2): + return "unexpectedAfterLiteral" + case (.isExpr, 0): + return "unexpectedBeforeExpression" + case (.isExpr, 1): + return "expression" + case (.isExpr, 2): + return "unexpectedBetweenExpressionAndIsKeyword" + case (.isExpr, 3): + return "isKeyword" + case (.isExpr, 4): + return "unexpectedBetweenIsKeywordAndType" + case (.isExpr, 5): + return "type" + case (.isExpr, 6): + return "unexpectedAfterType" + case (.isTypePattern, 0): + return "unexpectedBeforeIsKeyword" + case (.isTypePattern, 1): + return "isKeyword" + case (.isTypePattern, 2): + return "unexpectedBetweenIsKeywordAndType" + case (.isTypePattern, 3): + return "type" + case (.isTypePattern, 4): + return "unexpectedAfterType" + case (.keyPathComponent, 0): + return "unexpectedBeforePeriod" + case (.keyPathComponent, 1): + return "period" + case (.keyPathComponent, 2): + return "unexpectedBetweenPeriodAndComponent" + case (.keyPathComponent, 3): + return "component" + case (.keyPathComponent, 4): + return "unexpectedAfterComponent" + case (.keyPathExpr, 0): + return "unexpectedBeforeBackslash" + case (.keyPathExpr, 1): + return "backslash" + case (.keyPathExpr, 2): + return "unexpectedBetweenBackslashAndRoot" + case (.keyPathExpr, 3): + return "root" + case (.keyPathExpr, 4): + return "unexpectedBetweenRootAndComponents" + case (.keyPathExpr, 5): + return "components" + case (.keyPathExpr, 6): + return "unexpectedAfterComponents" + case (.keyPathOptionalComponent, 0): + return "unexpectedBeforeQuestionOrExclamationMark" + case (.keyPathOptionalComponent, 1): + return "questionOrExclamationMark" + case (.keyPathOptionalComponent, 2): + return "unexpectedAfterQuestionOrExclamationMark" + case (.keyPathPropertyComponent, 0): + return "unexpectedBeforeDeclName" + case (.keyPathPropertyComponent, 1): + return "declName" + case (.keyPathPropertyComponent, 2): + return "unexpectedBetweenDeclNameAndGenericArgumentClause" + case (.keyPathPropertyComponent, 3): + return "genericArgumentClause" + case (.keyPathPropertyComponent, 4): + return "unexpectedAfterGenericArgumentClause" + case (.keyPathSubscriptComponent, 0): + return "unexpectedBeforeLeftSquare" + case (.keyPathSubscriptComponent, 1): + return "leftSquare" + case (.keyPathSubscriptComponent, 2): + return "unexpectedBetweenLeftSquareAndArguments" + case (.keyPathSubscriptComponent, 3): + return "arguments" + case (.keyPathSubscriptComponent, 4): + return "unexpectedBetweenArgumentsAndRightSquare" + case (.keyPathSubscriptComponent, 5): + return "rightSquare" + case (.keyPathSubscriptComponent, 6): + return "unexpectedAfterRightSquare" + case (.labeledExpr, 0): + return "unexpectedBeforeLabel" + case (.labeledExpr, 1): + return "label" + case (.labeledExpr, 2): + return "unexpectedBetweenLabelAndColon" + case (.labeledExpr, 3): + return "colon" + case (.labeledExpr, 4): + return "unexpectedBetweenColonAndExpression" + case (.labeledExpr, 5): + return "expression" + case (.labeledExpr, 6): + return "unexpectedBetweenExpressionAndTrailingComma" + case (.labeledExpr, 7): + return "trailingComma" + case (.labeledExpr, 8): + return "unexpectedAfterTrailingComma" + case (.labeledSpecializeArgument, 0): + return "unexpectedBeforeLabel" + case (.labeledSpecializeArgument, 1): + return "label" + case (.labeledSpecializeArgument, 2): + return "unexpectedBetweenLabelAndColon" + case (.labeledSpecializeArgument, 3): + return "colon" + case (.labeledSpecializeArgument, 4): + return "unexpectedBetweenColonAndValue" + case (.labeledSpecializeArgument, 5): + return "value" + case (.labeledSpecializeArgument, 6): + return "unexpectedBetweenValueAndTrailingComma" + case (.labeledSpecializeArgument, 7): + return "trailingComma" + case (.labeledSpecializeArgument, 8): + return "unexpectedAfterTrailingComma" + case (.labeledStmt, 0): + return "unexpectedBeforeLabel" + case (.labeledStmt, 1): + return "label" + case (.labeledStmt, 2): + return "unexpectedBetweenLabelAndColon" + case (.labeledStmt, 3): + return "colon" + case (.labeledStmt, 4): + return "unexpectedBetweenColonAndStatement" + case (.labeledStmt, 5): + return "statement" + case (.labeledStmt, 6): + return "unexpectedAfterStatement" + case (.layoutRequirement, 0): + return "unexpectedBeforeType" + case (.layoutRequirement, 1): + return "type" + case (.layoutRequirement, 2): + return "unexpectedBetweenTypeAndColon" + case (.layoutRequirement, 3): + return "colon" + case (.layoutRequirement, 4): + return "unexpectedBetweenColonAndLayoutSpecifier" + case (.layoutRequirement, 5): + return "layoutSpecifier" + case (.layoutRequirement, 6): + return "unexpectedBetweenLayoutSpecifierAndLeftParen" + case (.layoutRequirement, 7): + return "leftParen" + case (.layoutRequirement, 8): + return "unexpectedBetweenLeftParenAndSize" + case (.layoutRequirement, 9): + return "size" + case (.layoutRequirement, 10): + return "unexpectedBetweenSizeAndComma" + case (.layoutRequirement, 11): + return "comma" + case (.layoutRequirement, 12): + return "unexpectedBetweenCommaAndAlignment" + case (.layoutRequirement, 13): + return "alignment" + case (.layoutRequirement, 14): + return "unexpectedBetweenAlignmentAndRightParen" + case (.layoutRequirement, 15): + return "rightParen" + case (.layoutRequirement, 16): + return "unexpectedAfterRightParen" + case (.lifetimeSpecifierArgument, 0): + return "unexpectedBeforeParameter" + case (.lifetimeSpecifierArgument, 1): + return "parameter" + case (.lifetimeSpecifierArgument, 2): + return "unexpectedBetweenParameterAndTrailingComma" + case (.lifetimeSpecifierArgument, 3): + return "trailingComma" + case (.lifetimeSpecifierArgument, 4): + return "unexpectedAfterTrailingComma" + case (.lifetimeTypeSpecifier, 0): + return "unexpectedBeforeDependsOnKeyword" + case (.lifetimeTypeSpecifier, 1): + return "dependsOnKeyword" + case (.lifetimeTypeSpecifier, 2): + return "unexpectedBetweenDependsOnKeywordAndLeftParen" + case (.lifetimeTypeSpecifier, 3): + return "leftParen" + case (.lifetimeTypeSpecifier, 4): + return "unexpectedBetweenLeftParenAndScopedKeyword" + case (.lifetimeTypeSpecifier, 5): + return "scopedKeyword" + case (.lifetimeTypeSpecifier, 6): + return "unexpectedBetweenScopedKeywordAndArguments" + case (.lifetimeTypeSpecifier, 7): + return "arguments" + case (.lifetimeTypeSpecifier, 8): + return "unexpectedBetweenArgumentsAndRightParen" + case (.lifetimeTypeSpecifier, 9): + return "rightParen" + case (.lifetimeTypeSpecifier, 10): + return "unexpectedAfterRightParen" + case (.macroDecl, 0): + return "unexpectedBeforeAttributes" + case (.macroDecl, 1): + return "attributes" + case (.macroDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.macroDecl, 3): + return "modifiers" + case (.macroDecl, 4): + return "unexpectedBetweenModifiersAndMacroKeyword" + case (.macroDecl, 5): + return "macroKeyword" + case (.macroDecl, 6): + return "unexpectedBetweenMacroKeywordAndName" + case (.macroDecl, 7): + return "name" + case (.macroDecl, 8): + return "unexpectedBetweenNameAndGenericParameterClause" + case (.macroDecl, 9): + return "genericParameterClause" + case (.macroDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndSignature" + case (.macroDecl, 11): + return "signature" + case (.macroDecl, 12): + return "unexpectedBetweenSignatureAndDefinition" + case (.macroDecl, 13): + return "definition" + case (.macroDecl, 14): + return "unexpectedBetweenDefinitionAndGenericWhereClause" + case (.macroDecl, 15): + return "genericWhereClause" + case (.macroDecl, 16): + return "unexpectedAfterGenericWhereClause" + case (.macroExpansionDecl, 0): + return "unexpectedBeforeAttributes" + case (.macroExpansionDecl, 1): + return "attributes" + case (.macroExpansionDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.macroExpansionDecl, 3): + return "modifiers" + case (.macroExpansionDecl, 4): + return "unexpectedBetweenModifiersAndPound" + case (.macroExpansionDecl, 5): + return "pound" + case (.macroExpansionDecl, 6): + return "unexpectedBetweenPoundAndMacroName" + case (.macroExpansionDecl, 7): + return "macroName" + case (.macroExpansionDecl, 8): + return "unexpectedBetweenMacroNameAndGenericArgumentClause" + case (.macroExpansionDecl, 9): + return "genericArgumentClause" + case (.macroExpansionDecl, 10): + return "unexpectedBetweenGenericArgumentClauseAndLeftParen" + case (.macroExpansionDecl, 11): + return "leftParen" + case (.macroExpansionDecl, 12): + return "unexpectedBetweenLeftParenAndArguments" + case (.macroExpansionDecl, 13): + return "arguments" + case (.macroExpansionDecl, 14): + return "unexpectedBetweenArgumentsAndRightParen" + case (.macroExpansionDecl, 15): + return "rightParen" + case (.macroExpansionDecl, 16): + return "unexpectedBetweenRightParenAndTrailingClosure" + case (.macroExpansionDecl, 17): + return "trailingClosure" + case (.macroExpansionDecl, 18): + return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" + case (.macroExpansionDecl, 19): + return "additionalTrailingClosures" + case (.macroExpansionDecl, 20): + return "unexpectedAfterAdditionalTrailingClosures" + case (.macroExpansionExpr, 0): + return "unexpectedBeforePound" + case (.macroExpansionExpr, 1): + return "pound" + case (.macroExpansionExpr, 2): + return "unexpectedBetweenPoundAndMacroName" + case (.macroExpansionExpr, 3): + return "macroName" + case (.macroExpansionExpr, 4): + return "unexpectedBetweenMacroNameAndGenericArgumentClause" + case (.macroExpansionExpr, 5): + return "genericArgumentClause" + case (.macroExpansionExpr, 6): + return "unexpectedBetweenGenericArgumentClauseAndLeftParen" + case (.macroExpansionExpr, 7): + return "leftParen" + case (.macroExpansionExpr, 8): + return "unexpectedBetweenLeftParenAndArguments" + case (.macroExpansionExpr, 9): + return "arguments" + case (.macroExpansionExpr, 10): + return "unexpectedBetweenArgumentsAndRightParen" + case (.macroExpansionExpr, 11): + return "rightParen" + case (.macroExpansionExpr, 12): + return "unexpectedBetweenRightParenAndTrailingClosure" + case (.macroExpansionExpr, 13): + return "trailingClosure" + case (.macroExpansionExpr, 14): + return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" + case (.macroExpansionExpr, 15): + return "additionalTrailingClosures" + case (.macroExpansionExpr, 16): + return "unexpectedAfterAdditionalTrailingClosures" + case (.matchingPatternCondition, 0): + return "unexpectedBeforeCaseKeyword" + case (.matchingPatternCondition, 1): + return "caseKeyword" + case (.matchingPatternCondition, 2): + return "unexpectedBetweenCaseKeywordAndPattern" + case (.matchingPatternCondition, 3): + return "pattern" + case (.matchingPatternCondition, 4): + return "unexpectedBetweenPatternAndTypeAnnotation" + case (.matchingPatternCondition, 5): + return "typeAnnotation" + case (.matchingPatternCondition, 6): + return "unexpectedBetweenTypeAnnotationAndInitializer" + case (.matchingPatternCondition, 7): + return "initializer" + case (.matchingPatternCondition, 8): + return "unexpectedAfterInitializer" + case (.memberAccessExpr, 0): + return "unexpectedBeforeBase" + case (.memberAccessExpr, 1): + return "base" + case (.memberAccessExpr, 2): + return "unexpectedBetweenBaseAndPeriod" + case (.memberAccessExpr, 3): + return "period" + case (.memberAccessExpr, 4): + return "unexpectedBetweenPeriodAndDeclName" + case (.memberAccessExpr, 5): + return "declName" + case (.memberAccessExpr, 6): + return "unexpectedAfterDeclName" + case (.memberBlockItem, 0): + return "unexpectedBeforeDecl" + case (.memberBlockItem, 1): + return "decl" + case (.memberBlockItem, 2): + return "unexpectedBetweenDeclAndSemicolon" + case (.memberBlockItem, 3): + return "semicolon" + case (.memberBlockItem, 4): + return "unexpectedAfterSemicolon" + case (.memberBlock, 0): + return "unexpectedBeforeLeftBrace" + case (.memberBlock, 1): + return "leftBrace" + case (.memberBlock, 2): + return "unexpectedBetweenLeftBraceAndMembers" + case (.memberBlock, 3): + return "members" + case (.memberBlock, 4): + return "unexpectedBetweenMembersAndRightBrace" + case (.memberBlock, 5): + return "rightBrace" + case (.memberBlock, 6): + return "unexpectedAfterRightBrace" + case (.memberType, 0): + return "unexpectedBeforeBaseType" + case (.memberType, 1): + return "baseType" + case (.memberType, 2): + return "unexpectedBetweenBaseTypeAndPeriod" + case (.memberType, 3): + return "period" + case (.memberType, 4): + return "unexpectedBetweenPeriodAndName" + case (.memberType, 5): + return "name" + case (.memberType, 6): + return "unexpectedBetweenNameAndGenericArgumentClause" + case (.memberType, 7): + return "genericArgumentClause" + case (.memberType, 8): + return "unexpectedAfterGenericArgumentClause" + case (.metatypeType, 0): + return "unexpectedBeforeBaseType" + case (.metatypeType, 1): + return "baseType" + case (.metatypeType, 2): + return "unexpectedBetweenBaseTypeAndPeriod" + case (.metatypeType, 3): + return "period" + case (.metatypeType, 4): + return "unexpectedBetweenPeriodAndMetatypeSpecifier" + case (.metatypeType, 5): + return "metatypeSpecifier" + case (.metatypeType, 6): + return "unexpectedAfterMetatypeSpecifier" + case (.missingDecl, 0): + return "unexpectedBeforeAttributes" + case (.missingDecl, 1): + return "attributes" + case (.missingDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.missingDecl, 3): + return "modifiers" + case (.missingDecl, 4): + return "unexpectedBetweenModifiersAndPlaceholder" + case (.missingDecl, 5): + return "placeholder" + case (.missingDecl, 6): + return "unexpectedAfterPlaceholder" + case (.missingExpr, 0): + return "unexpectedBeforePlaceholder" + case (.missingExpr, 1): + return "placeholder" + case (.missingExpr, 2): + return "unexpectedAfterPlaceholder" + case (.missingPattern, 0): + return "unexpectedBeforePlaceholder" + case (.missingPattern, 1): + return "placeholder" + case (.missingPattern, 2): + return "unexpectedAfterPlaceholder" + case (.missingStmt, 0): + return "unexpectedBeforePlaceholder" + case (.missingStmt, 1): + return "placeholder" + case (.missingStmt, 2): + return "unexpectedAfterPlaceholder" + case (.missing, 0): + return "unexpectedBeforePlaceholder" + case (.missing, 1): + return "placeholder" + case (.missing, 2): + return "unexpectedAfterPlaceholder" + case (.missingType, 0): + return "unexpectedBeforePlaceholder" + case (.missingType, 1): + return "placeholder" + case (.missingType, 2): + return "unexpectedAfterPlaceholder" + case (.multipleTrailingClosureElement, 0): + return "unexpectedBeforeLabel" + case (.multipleTrailingClosureElement, 1): + return "label" + case (.multipleTrailingClosureElement, 2): + return "unexpectedBetweenLabelAndColon" + case (.multipleTrailingClosureElement, 3): + return "colon" + case (.multipleTrailingClosureElement, 4): + return "unexpectedBetweenColonAndClosure" + case (.multipleTrailingClosureElement, 5): + return "closure" + case (.multipleTrailingClosureElement, 6): + return "unexpectedAfterClosure" + case (.namedOpaqueReturnType, 0): + return "unexpectedBeforeGenericParameterClause" + case (.namedOpaqueReturnType, 1): + return "genericParameterClause" + case (.namedOpaqueReturnType, 2): + return "unexpectedBetweenGenericParameterClauseAndType" + case (.namedOpaqueReturnType, 3): + return "type" + case (.namedOpaqueReturnType, 4): + return "unexpectedAfterType" + case (.nilLiteralExpr, 0): + return "unexpectedBeforeNilKeyword" + case (.nilLiteralExpr, 1): + return "nilKeyword" + case (.nilLiteralExpr, 2): + return "unexpectedAfterNilKeyword" + case (.objCSelectorPiece, 0): + return "unexpectedBeforeName" + case (.objCSelectorPiece, 1): + return "name" + case (.objCSelectorPiece, 2): + return "unexpectedBetweenNameAndColon" + case (.objCSelectorPiece, 3): + return "colon" + case (.objCSelectorPiece, 4): + return "unexpectedAfterColon" + case (.opaqueReturnTypeOfAttributeArguments, 0): + return "unexpectedBeforeMangledName" + case (.opaqueReturnTypeOfAttributeArguments, 1): + return "mangledName" + case (.opaqueReturnTypeOfAttributeArguments, 2): + return "unexpectedBetweenMangledNameAndComma" + case (.opaqueReturnTypeOfAttributeArguments, 3): + return "comma" + case (.opaqueReturnTypeOfAttributeArguments, 4): + return "unexpectedBetweenCommaAndOrdinal" + case (.opaqueReturnTypeOfAttributeArguments, 5): + return "ordinal" + case (.opaqueReturnTypeOfAttributeArguments, 6): + return "unexpectedAfterOrdinal" + case (.operatorDecl, 0): + return "unexpectedBeforeFixitySpecifier" + case (.operatorDecl, 1): + return "fixitySpecifier" + case (.operatorDecl, 2): + return "unexpectedBetweenFixitySpecifierAndOperatorKeyword" + case (.operatorDecl, 3): + return "operatorKeyword" + case (.operatorDecl, 4): + return "unexpectedBetweenOperatorKeywordAndName" + case (.operatorDecl, 5): + return "name" + case (.operatorDecl, 6): + return "unexpectedBetweenNameAndOperatorPrecedenceAndTypes" + case (.operatorDecl, 7): + return "operatorPrecedenceAndTypes" + case (.operatorDecl, 8): + return "unexpectedAfterOperatorPrecedenceAndTypes" + case (.operatorPrecedenceAndTypes, 0): + return "unexpectedBeforeColon" + case (.operatorPrecedenceAndTypes, 1): + return "colon" + case (.operatorPrecedenceAndTypes, 2): + return "unexpectedBetweenColonAndPrecedenceGroup" + case (.operatorPrecedenceAndTypes, 3): + return "precedenceGroup" + case (.operatorPrecedenceAndTypes, 4): + return "unexpectedBetweenPrecedenceGroupAndDesignatedTypes" + case (.operatorPrecedenceAndTypes, 5): + return "designatedTypes" + case (.operatorPrecedenceAndTypes, 6): + return "unexpectedAfterDesignatedTypes" + case (.optionalBindingCondition, 0): + return "unexpectedBeforeBindingSpecifier" + case (.optionalBindingCondition, 1): + return "bindingSpecifier" + case (.optionalBindingCondition, 2): + return "unexpectedBetweenBindingSpecifierAndPattern" + case (.optionalBindingCondition, 3): + return "pattern" + case (.optionalBindingCondition, 4): + return "unexpectedBetweenPatternAndTypeAnnotation" + case (.optionalBindingCondition, 5): + return "typeAnnotation" + case (.optionalBindingCondition, 6): + return "unexpectedBetweenTypeAnnotationAndInitializer" + case (.optionalBindingCondition, 7): + return "initializer" + case (.optionalBindingCondition, 8): + return "unexpectedAfterInitializer" + case (.optionalChainingExpr, 0): + return "unexpectedBeforeExpression" + case (.optionalChainingExpr, 1): + return "expression" + case (.optionalChainingExpr, 2): + return "unexpectedBetweenExpressionAndQuestionMark" + case (.optionalChainingExpr, 3): + return "questionMark" + case (.optionalChainingExpr, 4): + return "unexpectedAfterQuestionMark" + case (.optionalType, 0): + return "unexpectedBeforeWrappedType" + case (.optionalType, 1): + return "wrappedType" + case (.optionalType, 2): + return "unexpectedBetweenWrappedTypeAndQuestionMark" + case (.optionalType, 3): + return "questionMark" + case (.optionalType, 4): + return "unexpectedAfterQuestionMark" + case (.originallyDefinedInAttributeArguments, 0): + return "unexpectedBeforeModuleLabel" + case (.originallyDefinedInAttributeArguments, 1): + return "moduleLabel" + case (.originallyDefinedInAttributeArguments, 2): + return "unexpectedBetweenModuleLabelAndColon" + case (.originallyDefinedInAttributeArguments, 3): + return "colon" + case (.originallyDefinedInAttributeArguments, 4): + return "unexpectedBetweenColonAndModuleName" + case (.originallyDefinedInAttributeArguments, 5): + return "moduleName" + case (.originallyDefinedInAttributeArguments, 6): + return "unexpectedBetweenModuleNameAndComma" + case (.originallyDefinedInAttributeArguments, 7): + return "comma" + case (.originallyDefinedInAttributeArguments, 8): + return "unexpectedBetweenCommaAndPlatforms" + case (.originallyDefinedInAttributeArguments, 9): + return "platforms" + case (.originallyDefinedInAttributeArguments, 10): + return "unexpectedAfterPlatforms" + case (.packElementExpr, 0): + return "unexpectedBeforeEachKeyword" + case (.packElementExpr, 1): + return "eachKeyword" + case (.packElementExpr, 2): + return "unexpectedBetweenEachKeywordAndPack" + case (.packElementExpr, 3): + return "pack" + case (.packElementExpr, 4): + return "unexpectedAfterPack" + case (.packElementType, 0): + return "unexpectedBeforeEachKeyword" + case (.packElementType, 1): + return "eachKeyword" + case (.packElementType, 2): + return "unexpectedBetweenEachKeywordAndPack" + case (.packElementType, 3): + return "pack" + case (.packElementType, 4): + return "unexpectedAfterPack" + case (.packExpansionExpr, 0): + return "unexpectedBeforeRepeatKeyword" + case (.packExpansionExpr, 1): + return "repeatKeyword" + case (.packExpansionExpr, 2): + return "unexpectedBetweenRepeatKeywordAndRepetitionPattern" + case (.packExpansionExpr, 3): + return "repetitionPattern" + case (.packExpansionExpr, 4): + return "unexpectedAfterRepetitionPattern" + case (.packExpansionType, 0): + return "unexpectedBeforeRepeatKeyword" + case (.packExpansionType, 1): + return "repeatKeyword" + case (.packExpansionType, 2): + return "unexpectedBetweenRepeatKeywordAndRepetitionPattern" + case (.packExpansionType, 3): + return "repetitionPattern" + case (.packExpansionType, 4): + return "unexpectedAfterRepetitionPattern" + case (.patternBinding, 0): + return "unexpectedBeforePattern" + case (.patternBinding, 1): + return "pattern" + case (.patternBinding, 2): + return "unexpectedBetweenPatternAndTypeAnnotation" + case (.patternBinding, 3): + return "typeAnnotation" + case (.patternBinding, 4): + return "unexpectedBetweenTypeAnnotationAndInitializer" + case (.patternBinding, 5): + return "initializer" + case (.patternBinding, 6): + return "unexpectedBetweenInitializerAndAccessorBlock" + case (.patternBinding, 7): + return "accessorBlock" + case (.patternBinding, 8): + return "unexpectedBetweenAccessorBlockAndTrailingComma" + case (.patternBinding, 9): + return "trailingComma" + case (.patternBinding, 10): + return "unexpectedAfterTrailingComma" + case (.patternExpr, 0): + return "unexpectedBeforePattern" + case (.patternExpr, 1): + return "pattern" + case (.patternExpr, 2): + return "unexpectedAfterPattern" + case (.platformVersionItem, 0): + return "unexpectedBeforePlatformVersion" + case (.platformVersionItem, 1): + return "platformVersion" + case (.platformVersionItem, 2): + return "unexpectedBetweenPlatformVersionAndTrailingComma" + case (.platformVersionItem, 3): + return "trailingComma" + case (.platformVersionItem, 4): + return "unexpectedAfterTrailingComma" + case (.platformVersion, 0): + return "unexpectedBeforePlatform" + case (.platformVersion, 1): + return "platform" + case (.platformVersion, 2): + return "unexpectedBetweenPlatformAndVersion" + case (.platformVersion, 3): + return "version" + case (.platformVersion, 4): + return "unexpectedAfterVersion" + case (.postfixIfConfigExpr, 0): + return "unexpectedBeforeBase" + case (.postfixIfConfigExpr, 1): + return "base" + case (.postfixIfConfigExpr, 2): + return "unexpectedBetweenBaseAndConfig" + case (.postfixIfConfigExpr, 3): + return "config" + case (.postfixIfConfigExpr, 4): + return "unexpectedAfterConfig" + case (.postfixOperatorExpr, 0): + return "unexpectedBeforeExpression" + case (.postfixOperatorExpr, 1): + return "expression" + case (.postfixOperatorExpr, 2): + return "unexpectedBetweenExpressionAndOperator" + case (.postfixOperatorExpr, 3): + return "operator" + case (.postfixOperatorExpr, 4): + return "unexpectedAfterOperator" + case (.poundSourceLocationArguments, 0): + return "unexpectedBeforeFileLabel" + case (.poundSourceLocationArguments, 1): + return "fileLabel" + case (.poundSourceLocationArguments, 2): + return "unexpectedBetweenFileLabelAndFileColon" + case (.poundSourceLocationArguments, 3): + return "fileColon" + case (.poundSourceLocationArguments, 4): + return "unexpectedBetweenFileColonAndFileName" + case (.poundSourceLocationArguments, 5): + return "fileName" + case (.poundSourceLocationArguments, 6): + return "unexpectedBetweenFileNameAndComma" + case (.poundSourceLocationArguments, 7): + return "comma" + case (.poundSourceLocationArguments, 8): + return "unexpectedBetweenCommaAndLineLabel" + case (.poundSourceLocationArguments, 9): + return "lineLabel" + case (.poundSourceLocationArguments, 10): + return "unexpectedBetweenLineLabelAndLineColon" + case (.poundSourceLocationArguments, 11): + return "lineColon" + case (.poundSourceLocationArguments, 12): + return "unexpectedBetweenLineColonAndLineNumber" + case (.poundSourceLocationArguments, 13): + return "lineNumber" + case (.poundSourceLocationArguments, 14): + return "unexpectedAfterLineNumber" + case (.poundSourceLocation, 0): + return "unexpectedBeforePoundSourceLocation" + case (.poundSourceLocation, 1): + return "poundSourceLocation" + case (.poundSourceLocation, 2): + return "unexpectedBetweenPoundSourceLocationAndLeftParen" + case (.poundSourceLocation, 3): + return "leftParen" + case (.poundSourceLocation, 4): + return "unexpectedBetweenLeftParenAndArguments" + case (.poundSourceLocation, 5): + return "arguments" + case (.poundSourceLocation, 6): + return "unexpectedBetweenArgumentsAndRightParen" + case (.poundSourceLocation, 7): + return "rightParen" + case (.poundSourceLocation, 8): + return "unexpectedAfterRightParen" + case (.precedenceGroupAssignment, 0): + return "unexpectedBeforeAssignmentLabel" + case (.precedenceGroupAssignment, 1): + return "assignmentLabel" + case (.precedenceGroupAssignment, 2): + return "unexpectedBetweenAssignmentLabelAndColon" + case (.precedenceGroupAssignment, 3): + return "colon" + case (.precedenceGroupAssignment, 4): + return "unexpectedBetweenColonAndValue" + case (.precedenceGroupAssignment, 5): + return "value" + case (.precedenceGroupAssignment, 6): + return "unexpectedAfterValue" + case (.precedenceGroupAssociativity, 0): + return "unexpectedBeforeAssociativityLabel" + case (.precedenceGroupAssociativity, 1): + return "associativityLabel" + case (.precedenceGroupAssociativity, 2): + return "unexpectedBetweenAssociativityLabelAndColon" + case (.precedenceGroupAssociativity, 3): + return "colon" + case (.precedenceGroupAssociativity, 4): + return "unexpectedBetweenColonAndValue" + case (.precedenceGroupAssociativity, 5): + return "value" + case (.precedenceGroupAssociativity, 6): + return "unexpectedAfterValue" + case (.precedenceGroupDecl, 0): + return "unexpectedBeforeAttributes" + case (.precedenceGroupDecl, 1): + return "attributes" + case (.precedenceGroupDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.precedenceGroupDecl, 3): + return "modifiers" + case (.precedenceGroupDecl, 4): + return "unexpectedBetweenModifiersAndPrecedencegroupKeyword" + case (.precedenceGroupDecl, 5): + return "precedencegroupKeyword" + case (.precedenceGroupDecl, 6): + return "unexpectedBetweenPrecedencegroupKeywordAndName" + case (.precedenceGroupDecl, 7): + return "name" + case (.precedenceGroupDecl, 8): + return "unexpectedBetweenNameAndLeftBrace" + case (.precedenceGroupDecl, 9): + return "leftBrace" + case (.precedenceGroupDecl, 10): + return "unexpectedBetweenLeftBraceAndGroupAttributes" + case (.precedenceGroupDecl, 11): + return "groupAttributes" + case (.precedenceGroupDecl, 12): + return "unexpectedBetweenGroupAttributesAndRightBrace" + case (.precedenceGroupDecl, 13): + return "rightBrace" + case (.precedenceGroupDecl, 14): + return "unexpectedAfterRightBrace" + case (.precedenceGroupName, 0): + return "unexpectedBeforeName" + case (.precedenceGroupName, 1): + return "name" + case (.precedenceGroupName, 2): + return "unexpectedBetweenNameAndTrailingComma" + case (.precedenceGroupName, 3): + return "trailingComma" + case (.precedenceGroupName, 4): + return "unexpectedAfterTrailingComma" + case (.precedenceGroupRelation, 0): + return "unexpectedBeforeHigherThanOrLowerThanLabel" + case (.precedenceGroupRelation, 1): + return "higherThanOrLowerThanLabel" + case (.precedenceGroupRelation, 2): + return "unexpectedBetweenHigherThanOrLowerThanLabelAndColon" + case (.precedenceGroupRelation, 3): + return "colon" + case (.precedenceGroupRelation, 4): + return "unexpectedBetweenColonAndPrecedenceGroups" + case (.precedenceGroupRelation, 5): + return "precedenceGroups" + case (.precedenceGroupRelation, 6): + return "unexpectedAfterPrecedenceGroups" + case (.prefixOperatorExpr, 0): + return "unexpectedBeforeOperator" + case (.prefixOperatorExpr, 1): + return "operator" + case (.prefixOperatorExpr, 2): + return "unexpectedBetweenOperatorAndExpression" + case (.prefixOperatorExpr, 3): + return "expression" + case (.prefixOperatorExpr, 4): + return "unexpectedAfterExpression" + case (.primaryAssociatedTypeClause, 0): + return "unexpectedBeforeLeftAngle" + case (.primaryAssociatedTypeClause, 1): + return "leftAngle" + case (.primaryAssociatedTypeClause, 2): + return "unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes" + case (.primaryAssociatedTypeClause, 3): + return "primaryAssociatedTypes" + case (.primaryAssociatedTypeClause, 4): + return "unexpectedBetweenPrimaryAssociatedTypesAndRightAngle" + case (.primaryAssociatedTypeClause, 5): + return "rightAngle" + case (.primaryAssociatedTypeClause, 6): + return "unexpectedAfterRightAngle" + case (.primaryAssociatedType, 0): + return "unexpectedBeforeName" + case (.primaryAssociatedType, 1): + return "name" + case (.primaryAssociatedType, 2): + return "unexpectedBetweenNameAndTrailingComma" + case (.primaryAssociatedType, 3): + return "trailingComma" + case (.primaryAssociatedType, 4): + return "unexpectedAfterTrailingComma" + case (.protocolDecl, 0): + return "unexpectedBeforeAttributes" + case (.protocolDecl, 1): + return "attributes" + case (.protocolDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.protocolDecl, 3): + return "modifiers" + case (.protocolDecl, 4): + return "unexpectedBetweenModifiersAndProtocolKeyword" + case (.protocolDecl, 5): + return "protocolKeyword" + case (.protocolDecl, 6): + return "unexpectedBetweenProtocolKeywordAndName" + case (.protocolDecl, 7): + return "name" + case (.protocolDecl, 8): + return "unexpectedBetweenNameAndPrimaryAssociatedTypeClause" + case (.protocolDecl, 9): + return "primaryAssociatedTypeClause" + case (.protocolDecl, 10): + return "unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause" + case (.protocolDecl, 11): + return "inheritanceClause" + case (.protocolDecl, 12): + return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" + case (.protocolDecl, 13): + return "genericWhereClause" + case (.protocolDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case (.protocolDecl, 15): + return "memberBlock" + case (.protocolDecl, 16): + return "unexpectedAfterMemberBlock" + case (.regexLiteralExpr, 0): + return "unexpectedBeforeOpeningPounds" + case (.regexLiteralExpr, 1): + return "openingPounds" + case (.regexLiteralExpr, 2): + return "unexpectedBetweenOpeningPoundsAndOpeningSlash" + case (.regexLiteralExpr, 3): + return "openingSlash" + case (.regexLiteralExpr, 4): + return "unexpectedBetweenOpeningSlashAndRegex" + case (.regexLiteralExpr, 5): + return "regex" + case (.regexLiteralExpr, 6): + return "unexpectedBetweenRegexAndClosingSlash" + case (.regexLiteralExpr, 7): + return "closingSlash" + case (.regexLiteralExpr, 8): + return "unexpectedBetweenClosingSlashAndClosingPounds" + case (.regexLiteralExpr, 9): + return "closingPounds" + case (.regexLiteralExpr, 10): + return "unexpectedAfterClosingPounds" + case (.repeatStmt, 0): + return "unexpectedBeforeRepeatKeyword" + case (.repeatStmt, 1): + return "repeatKeyword" + case (.repeatStmt, 2): + return "unexpectedBetweenRepeatKeywordAndBody" + case (.repeatStmt, 3): + return "body" + case (.repeatStmt, 4): + return "unexpectedBetweenBodyAndWhileKeyword" + case (.repeatStmt, 5): + return "whileKeyword" + case (.repeatStmt, 6): + return "unexpectedBetweenWhileKeywordAndCondition" + case (.repeatStmt, 7): + return "condition" + case (.repeatStmt, 8): + return "unexpectedAfterCondition" + case (.returnClause, 0): + return "unexpectedBeforeArrow" + case (.returnClause, 1): + return "arrow" + case (.returnClause, 2): + return "unexpectedBetweenArrowAndType" + case (.returnClause, 3): + return "type" + case (.returnClause, 4): + return "unexpectedAfterType" + case (.returnStmt, 0): + return "unexpectedBeforeReturnKeyword" + case (.returnStmt, 1): + return "returnKeyword" + case (.returnStmt, 2): + return "unexpectedBetweenReturnKeywordAndExpression" + case (.returnStmt, 3): + return "expression" + case (.returnStmt, 4): + return "unexpectedAfterExpression" + case (.sameTypeRequirement, 0): + return "unexpectedBeforeLeftType" + case (.sameTypeRequirement, 1): + return "leftType" + case (.sameTypeRequirement, 2): + return "unexpectedBetweenLeftTypeAndEqual" + case (.sameTypeRequirement, 3): + return "equal" + case (.sameTypeRequirement, 4): + return "unexpectedBetweenEqualAndRightType" + case (.sameTypeRequirement, 5): + return "rightType" + case (.sameTypeRequirement, 6): + return "unexpectedAfterRightType" + case (.sequenceExpr, 0): + return "unexpectedBeforeElements" + case (.sequenceExpr, 1): + return "elements" + case (.sequenceExpr, 2): + return "unexpectedAfterElements" + case (.simpleStringLiteralExpr, 0): + return "unexpectedBeforeOpeningQuote" + case (.simpleStringLiteralExpr, 1): + return "openingQuote" + case (.simpleStringLiteralExpr, 2): + return "unexpectedBetweenOpeningQuoteAndSegments" + case (.simpleStringLiteralExpr, 3): + return "segments" + case (.simpleStringLiteralExpr, 4): + return "unexpectedBetweenSegmentsAndClosingQuote" + case (.simpleStringLiteralExpr, 5): + return "closingQuote" + case (.simpleStringLiteralExpr, 6): + return "unexpectedAfterClosingQuote" + case (.simpleTypeSpecifier, 0): + return "unexpectedBeforeSpecifier" + case (.simpleTypeSpecifier, 1): + return "specifier" + case (.simpleTypeSpecifier, 2): + return "unexpectedAfterSpecifier" + case (.someOrAnyType, 0): + return "unexpectedBeforeSomeOrAnySpecifier" + case (.someOrAnyType, 1): + return "someOrAnySpecifier" + case (.someOrAnyType, 2): + return "unexpectedBetweenSomeOrAnySpecifierAndConstraint" + case (.someOrAnyType, 3): + return "constraint" + case (.someOrAnyType, 4): + return "unexpectedAfterConstraint" + case (.sourceFile, 0): + return "unexpectedBeforeShebang" + case (.sourceFile, 1): + return "shebang" + case (.sourceFile, 2): + return "unexpectedBetweenShebangAndStatements" + case (.sourceFile, 3): + return "statements" + case (.sourceFile, 4): + return "unexpectedBetweenStatementsAndEndOfFileToken" + case (.sourceFile, 5): + return "endOfFileToken" + case (.sourceFile, 6): + return "unexpectedAfterEndOfFileToken" + case (.specializeAvailabilityArgument, 0): + return "unexpectedBeforeAvailabilityLabel" + case (.specializeAvailabilityArgument, 1): + return "availabilityLabel" + case (.specializeAvailabilityArgument, 2): + return "unexpectedBetweenAvailabilityLabelAndColon" + case (.specializeAvailabilityArgument, 3): + return "colon" + case (.specializeAvailabilityArgument, 4): + return "unexpectedBetweenColonAndAvailabilityArguments" + case (.specializeAvailabilityArgument, 5): + return "availabilityArguments" + case (.specializeAvailabilityArgument, 6): + return "unexpectedBetweenAvailabilityArgumentsAndSemicolon" + case (.specializeAvailabilityArgument, 7): + return "semicolon" + case (.specializeAvailabilityArgument, 8): + return "unexpectedAfterSemicolon" + case (.specializeTargetFunctionArgument, 0): + return "unexpectedBeforeTargetLabel" + case (.specializeTargetFunctionArgument, 1): + return "targetLabel" + case (.specializeTargetFunctionArgument, 2): + return "unexpectedBetweenTargetLabelAndColon" + case (.specializeTargetFunctionArgument, 3): + return "colon" + case (.specializeTargetFunctionArgument, 4): + return "unexpectedBetweenColonAndDeclName" + case (.specializeTargetFunctionArgument, 5): + return "declName" + case (.specializeTargetFunctionArgument, 6): + return "unexpectedBetweenDeclNameAndTrailingComma" + case (.specializeTargetFunctionArgument, 7): + return "trailingComma" + case (.specializeTargetFunctionArgument, 8): + return "unexpectedAfterTrailingComma" + case (.stringLiteralExpr, 0): + return "unexpectedBeforeOpeningPounds" + case (.stringLiteralExpr, 1): + return "openingPounds" + case (.stringLiteralExpr, 2): + return "unexpectedBetweenOpeningPoundsAndOpeningQuote" + case (.stringLiteralExpr, 3): + return "openingQuote" + case (.stringLiteralExpr, 4): + return "unexpectedBetweenOpeningQuoteAndSegments" + case (.stringLiteralExpr, 5): + return "segments" + case (.stringLiteralExpr, 6): + return "unexpectedBetweenSegmentsAndClosingQuote" + case (.stringLiteralExpr, 7): + return "closingQuote" + case (.stringLiteralExpr, 8): + return "unexpectedBetweenClosingQuoteAndClosingPounds" + case (.stringLiteralExpr, 9): + return "closingPounds" + case (.stringLiteralExpr, 10): + return "unexpectedAfterClosingPounds" + case (.stringSegment, 0): + return "unexpectedBeforeContent" + case (.stringSegment, 1): + return "content" + case (.stringSegment, 2): + return "unexpectedAfterContent" + case (.structDecl, 0): + return "unexpectedBeforeAttributes" + case (.structDecl, 1): + return "attributes" + case (.structDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.structDecl, 3): + return "modifiers" + case (.structDecl, 4): + return "unexpectedBetweenModifiersAndStructKeyword" + case (.structDecl, 5): + return "structKeyword" + case (.structDecl, 6): + return "unexpectedBetweenStructKeywordAndName" + case (.structDecl, 7): + return "name" + case (.structDecl, 8): + return "unexpectedBetweenNameAndGenericParameterClause" + case (.structDecl, 9): + return "genericParameterClause" + case (.structDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" + case (.structDecl, 11): + return "inheritanceClause" + case (.structDecl, 12): + return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" + case (.structDecl, 13): + return "genericWhereClause" + case (.structDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case (.structDecl, 15): + return "memberBlock" + case (.structDecl, 16): + return "unexpectedAfterMemberBlock" + case (.subscriptCallExpr, 0): + return "unexpectedBeforeCalledExpression" + case (.subscriptCallExpr, 1): + return "calledExpression" + case (.subscriptCallExpr, 2): + return "unexpectedBetweenCalledExpressionAndLeftSquare" + case (.subscriptCallExpr, 3): + return "leftSquare" + case (.subscriptCallExpr, 4): + return "unexpectedBetweenLeftSquareAndArguments" + case (.subscriptCallExpr, 5): + return "arguments" + case (.subscriptCallExpr, 6): + return "unexpectedBetweenArgumentsAndRightSquare" + case (.subscriptCallExpr, 7): + return "rightSquare" + case (.subscriptCallExpr, 8): + return "unexpectedBetweenRightSquareAndTrailingClosure" + case (.subscriptCallExpr, 9): + return "trailingClosure" + case (.subscriptCallExpr, 10): + return "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures" + case (.subscriptCallExpr, 11): + return "additionalTrailingClosures" + case (.subscriptCallExpr, 12): + return "unexpectedAfterAdditionalTrailingClosures" + case (.subscriptDecl, 0): + return "unexpectedBeforeAttributes" + case (.subscriptDecl, 1): + return "attributes" + case (.subscriptDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.subscriptDecl, 3): + return "modifiers" + case (.subscriptDecl, 4): + return "unexpectedBetweenModifiersAndSubscriptKeyword" + case (.subscriptDecl, 5): + return "subscriptKeyword" + case (.subscriptDecl, 6): + return "unexpectedBetweenSubscriptKeywordAndGenericParameterClause" + case (.subscriptDecl, 7): + return "genericParameterClause" + case (.subscriptDecl, 8): + return "unexpectedBetweenGenericParameterClauseAndParameterClause" + case (.subscriptDecl, 9): + return "parameterClause" + case (.subscriptDecl, 10): + return "unexpectedBetweenParameterClauseAndReturnClause" + case (.subscriptDecl, 11): + return "returnClause" + case (.subscriptDecl, 12): + return "unexpectedBetweenReturnClauseAndGenericWhereClause" + case (.subscriptDecl, 13): + return "genericWhereClause" + case (.subscriptDecl, 14): + return "unexpectedBetweenGenericWhereClauseAndAccessorBlock" + case (.subscriptDecl, 15): + return "accessorBlock" + case (.subscriptDecl, 16): + return "unexpectedAfterAccessorBlock" + case (.superExpr, 0): + return "unexpectedBeforeSuperKeyword" + case (.superExpr, 1): + return "superKeyword" + case (.superExpr, 2): + return "unexpectedAfterSuperKeyword" + case (.suppressedType, 0): + return "unexpectedBeforeWithoutTilde" + case (.suppressedType, 1): + return "withoutTilde" + case (.suppressedType, 2): + return "unexpectedBetweenWithoutTildeAndType" + case (.suppressedType, 3): + return "type" + case (.suppressedType, 4): + return "unexpectedAfterType" + case (.switchCaseItem, 0): + return "unexpectedBeforePattern" + case (.switchCaseItem, 1): + return "pattern" + case (.switchCaseItem, 2): + return "unexpectedBetweenPatternAndWhereClause" + case (.switchCaseItem, 3): + return "whereClause" + case (.switchCaseItem, 4): + return "unexpectedBetweenWhereClauseAndTrailingComma" + case (.switchCaseItem, 5): + return "trailingComma" + case (.switchCaseItem, 6): + return "unexpectedAfterTrailingComma" + case (.switchCaseLabel, 0): + return "unexpectedBeforeCaseKeyword" + case (.switchCaseLabel, 1): + return "caseKeyword" + case (.switchCaseLabel, 2): + return "unexpectedBetweenCaseKeywordAndCaseItems" + case (.switchCaseLabel, 3): + return "caseItems" + case (.switchCaseLabel, 4): + return "unexpectedBetweenCaseItemsAndColon" + case (.switchCaseLabel, 5): + return "colon" + case (.switchCaseLabel, 6): + return "unexpectedAfterColon" + case (.switchCase, 0): + return "unexpectedBeforeAttribute" + case (.switchCase, 1): + return "attribute" + case (.switchCase, 2): + return "unexpectedBetweenAttributeAndLabel" + case (.switchCase, 3): + return "label" + case (.switchCase, 4): + return "unexpectedBetweenLabelAndStatements" + case (.switchCase, 5): + return "statements" + case (.switchCase, 6): + return "unexpectedAfterStatements" + case (.switchDefaultLabel, 0): + return "unexpectedBeforeDefaultKeyword" + case (.switchDefaultLabel, 1): + return "defaultKeyword" + case (.switchDefaultLabel, 2): + return "unexpectedBetweenDefaultKeywordAndColon" + case (.switchDefaultLabel, 3): + return "colon" + case (.switchDefaultLabel, 4): + return "unexpectedAfterColon" + case (.switchExpr, 0): + return "unexpectedBeforeSwitchKeyword" + case (.switchExpr, 1): + return "switchKeyword" + case (.switchExpr, 2): + return "unexpectedBetweenSwitchKeywordAndSubject" + case (.switchExpr, 3): + return "subject" + case (.switchExpr, 4): + return "unexpectedBetweenSubjectAndLeftBrace" + case (.switchExpr, 5): + return "leftBrace" + case (.switchExpr, 6): + return "unexpectedBetweenLeftBraceAndCases" + case (.switchExpr, 7): + return "cases" + case (.switchExpr, 8): + return "unexpectedBetweenCasesAndRightBrace" + case (.switchExpr, 9): + return "rightBrace" + case (.switchExpr, 10): + return "unexpectedAfterRightBrace" + case (.ternaryExpr, 0): + return "unexpectedBeforeCondition" + case (.ternaryExpr, 1): + return "condition" + case (.ternaryExpr, 2): + return "unexpectedBetweenConditionAndQuestionMark" + case (.ternaryExpr, 3): + return "questionMark" + case (.ternaryExpr, 4): + return "unexpectedBetweenQuestionMarkAndThenExpression" + case (.ternaryExpr, 5): + return "thenExpression" + case (.ternaryExpr, 6): + return "unexpectedBetweenThenExpressionAndColon" + case (.ternaryExpr, 7): + return "colon" + case (.ternaryExpr, 8): + return "unexpectedBetweenColonAndElseExpression" + case (.ternaryExpr, 9): + return "elseExpression" + case (.ternaryExpr, 10): + return "unexpectedAfterElseExpression" + case (.thenStmt, 0): + return "unexpectedBeforeThenKeyword" + case (.thenStmt, 1): + return "thenKeyword" + case (.thenStmt, 2): + return "unexpectedBetweenThenKeywordAndExpression" + case (.thenStmt, 3): + return "expression" + case (.thenStmt, 4): + return "unexpectedAfterExpression" + case (.throwStmt, 0): + return "unexpectedBeforeThrowKeyword" + case (.throwStmt, 1): + return "throwKeyword" + case (.throwStmt, 2): + return "unexpectedBetweenThrowKeywordAndExpression" + case (.throwStmt, 3): + return "expression" + case (.throwStmt, 4): + return "unexpectedAfterExpression" + case (.throwsClause, 0): + return "unexpectedBeforeThrowsSpecifier" + case (.throwsClause, 1): + return "throwsSpecifier" + case (.throwsClause, 2): + return "unexpectedBetweenThrowsSpecifierAndLeftParen" + case (.throwsClause, 3): + return "leftParen" + case (.throwsClause, 4): + return "unexpectedBetweenLeftParenAndType" + case (.throwsClause, 5): + return "type" + case (.throwsClause, 6): + return "unexpectedBetweenTypeAndRightParen" + case (.throwsClause, 7): + return "rightParen" + case (.throwsClause, 8): + return "unexpectedAfterRightParen" + case (.tryExpr, 0): + return "unexpectedBeforeTryKeyword" + case (.tryExpr, 1): + return "tryKeyword" + case (.tryExpr, 2): + return "unexpectedBetweenTryKeywordAndQuestionOrExclamationMark" + case (.tryExpr, 3): + return "questionOrExclamationMark" + case (.tryExpr, 4): + return "unexpectedBetweenQuestionOrExclamationMarkAndExpression" + case (.tryExpr, 5): + return "expression" + case (.tryExpr, 6): + return "unexpectedAfterExpression" + case (.tupleExpr, 0): + return "unexpectedBeforeLeftParen" + case (.tupleExpr, 1): + return "leftParen" + case (.tupleExpr, 2): + return "unexpectedBetweenLeftParenAndElements" + case (.tupleExpr, 3): + return "elements" + case (.tupleExpr, 4): + return "unexpectedBetweenElementsAndRightParen" + case (.tupleExpr, 5): + return "rightParen" + case (.tupleExpr, 6): + return "unexpectedAfterRightParen" + case (.tuplePatternElement, 0): + return "unexpectedBeforeLabel" + case (.tuplePatternElement, 1): + return "label" + case (.tuplePatternElement, 2): + return "unexpectedBetweenLabelAndColon" + case (.tuplePatternElement, 3): + return "colon" + case (.tuplePatternElement, 4): + return "unexpectedBetweenColonAndPattern" + case (.tuplePatternElement, 5): + return "pattern" + case (.tuplePatternElement, 6): + return "unexpectedBetweenPatternAndTrailingComma" + case (.tuplePatternElement, 7): + return "trailingComma" + case (.tuplePatternElement, 8): + return "unexpectedAfterTrailingComma" + case (.tuplePattern, 0): + return "unexpectedBeforeLeftParen" + case (.tuplePattern, 1): + return "leftParen" + case (.tuplePattern, 2): + return "unexpectedBetweenLeftParenAndElements" + case (.tuplePattern, 3): + return "elements" + case (.tuplePattern, 4): + return "unexpectedBetweenElementsAndRightParen" + case (.tuplePattern, 5): + return "rightParen" + case (.tuplePattern, 6): + return "unexpectedAfterRightParen" + case (.tupleTypeElement, 0): + return "unexpectedBeforeInoutKeyword" + case (.tupleTypeElement, 1): + return "inoutKeyword" + case (.tupleTypeElement, 2): + return "unexpectedBetweenInoutKeywordAndFirstName" + case (.tupleTypeElement, 3): + return "firstName" + case (.tupleTypeElement, 4): + return "unexpectedBetweenFirstNameAndSecondName" + case (.tupleTypeElement, 5): + return "secondName" + case (.tupleTypeElement, 6): + return "unexpectedBetweenSecondNameAndColon" + case (.tupleTypeElement, 7): + return "colon" + case (.tupleTypeElement, 8): + return "unexpectedBetweenColonAndType" + case (.tupleTypeElement, 9): + return "type" + case (.tupleTypeElement, 10): + return "unexpectedBetweenTypeAndEllipsis" + case (.tupleTypeElement, 11): + return "ellipsis" + case (.tupleTypeElement, 12): + return "unexpectedBetweenEllipsisAndTrailingComma" + case (.tupleTypeElement, 13): + return "trailingComma" + case (.tupleTypeElement, 14): + return "unexpectedAfterTrailingComma" + case (.tupleType, 0): + return "unexpectedBeforeLeftParen" + case (.tupleType, 1): + return "leftParen" + case (.tupleType, 2): + return "unexpectedBetweenLeftParenAndElements" + case (.tupleType, 3): + return "elements" + case (.tupleType, 4): + return "unexpectedBetweenElementsAndRightParen" + case (.tupleType, 5): + return "rightParen" + case (.tupleType, 6): + return "unexpectedAfterRightParen" + case (.typeAliasDecl, 0): + return "unexpectedBeforeAttributes" + case (.typeAliasDecl, 1): + return "attributes" + case (.typeAliasDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.typeAliasDecl, 3): + return "modifiers" + case (.typeAliasDecl, 4): + return "unexpectedBetweenModifiersAndTypealiasKeyword" + case (.typeAliasDecl, 5): + return "typealiasKeyword" + case (.typeAliasDecl, 6): + return "unexpectedBetweenTypealiasKeywordAndName" + case (.typeAliasDecl, 7): + return "name" + case (.typeAliasDecl, 8): + return "unexpectedBetweenNameAndGenericParameterClause" + case (.typeAliasDecl, 9): + return "genericParameterClause" + case (.typeAliasDecl, 10): + return "unexpectedBetweenGenericParameterClauseAndInitializer" + case (.typeAliasDecl, 11): + return "initializer" + case (.typeAliasDecl, 12): + return "unexpectedBetweenInitializerAndGenericWhereClause" + case (.typeAliasDecl, 13): + return "genericWhereClause" + case (.typeAliasDecl, 14): + return "unexpectedAfterGenericWhereClause" + case (.typeAnnotation, 0): + return "unexpectedBeforeColon" + case (.typeAnnotation, 1): + return "colon" + case (.typeAnnotation, 2): + return "unexpectedBetweenColonAndType" + case (.typeAnnotation, 3): + return "type" + case (.typeAnnotation, 4): + return "unexpectedAfterType" + case (.typeEffectSpecifiers, 0): + return "unexpectedBeforeAsyncSpecifier" + case (.typeEffectSpecifiers, 1): + return "asyncSpecifier" + case (.typeEffectSpecifiers, 2): + return "unexpectedBetweenAsyncSpecifierAndThrowsClause" + case (.typeEffectSpecifiers, 3): + return "throwsClause" + case (.typeEffectSpecifiers, 4): + return "unexpectedAfterThrowsClause" + case (.typeExpr, 0): + return "unexpectedBeforeType" + case (.typeExpr, 1): + return "type" + case (.typeExpr, 2): + return "unexpectedAfterType" + case (.typeInitializerClause, 0): + return "unexpectedBeforeEqual" + case (.typeInitializerClause, 1): + return "equal" + case (.typeInitializerClause, 2): + return "unexpectedBetweenEqualAndValue" + case (.typeInitializerClause, 3): + return "value" + case (.typeInitializerClause, 4): + return "unexpectedAfterValue" + case (.unavailableFromAsyncAttributeArguments, 0): + return "unexpectedBeforeMessageLabel" + case (.unavailableFromAsyncAttributeArguments, 1): + return "messageLabel" + case (.unavailableFromAsyncAttributeArguments, 2): + return "unexpectedBetweenMessageLabelAndColon" + case (.unavailableFromAsyncAttributeArguments, 3): + return "colon" + case (.unavailableFromAsyncAttributeArguments, 4): + return "unexpectedBetweenColonAndMessage" + case (.unavailableFromAsyncAttributeArguments, 5): + return "message" + case (.unavailableFromAsyncAttributeArguments, 6): + return "unexpectedAfterMessage" + case (.underscorePrivateAttributeArguments, 0): + return "unexpectedBeforeSourceFileLabel" + case (.underscorePrivateAttributeArguments, 1): + return "sourceFileLabel" + case (.underscorePrivateAttributeArguments, 2): + return "unexpectedBetweenSourceFileLabelAndColon" + case (.underscorePrivateAttributeArguments, 3): + return "colon" + case (.underscorePrivateAttributeArguments, 4): + return "unexpectedBetweenColonAndFilename" + case (.underscorePrivateAttributeArguments, 5): + return "filename" + case (.underscorePrivateAttributeArguments, 6): + return "unexpectedAfterFilename" + case (.unresolvedAsExpr, 0): + return "unexpectedBeforeAsKeyword" + case (.unresolvedAsExpr, 1): + return "asKeyword" + case (.unresolvedAsExpr, 2): + return "unexpectedBetweenAsKeywordAndQuestionOrExclamationMark" + case (.unresolvedAsExpr, 3): + return "questionOrExclamationMark" + case (.unresolvedAsExpr, 4): + return "unexpectedAfterQuestionOrExclamationMark" + case (.unresolvedIsExpr, 0): + return "unexpectedBeforeIsKeyword" + case (.unresolvedIsExpr, 1): + return "isKeyword" + case (.unresolvedIsExpr, 2): + return "unexpectedAfterIsKeyword" + case (.unresolvedTernaryExpr, 0): + return "unexpectedBeforeQuestionMark" + case (.unresolvedTernaryExpr, 1): + return "questionMark" + case (.unresolvedTernaryExpr, 2): + return "unexpectedBetweenQuestionMarkAndThenExpression" + case (.unresolvedTernaryExpr, 3): + return "thenExpression" + case (.unresolvedTernaryExpr, 4): + return "unexpectedBetweenThenExpressionAndColon" + case (.unresolvedTernaryExpr, 5): + return "colon" + case (.unresolvedTernaryExpr, 6): + return "unexpectedAfterColon" + case (.unsafeExpr, 0): + return "unexpectedBeforeUnsafeKeyword" + case (.unsafeExpr, 1): + return "unsafeKeyword" + case (.unsafeExpr, 2): + return "unexpectedBetweenUnsafeKeywordAndExpression" + case (.unsafeExpr, 3): + return "expression" + case (.unsafeExpr, 4): + return "unexpectedAfterExpression" + case (.valueBindingPattern, 0): + return "unexpectedBeforeBindingSpecifier" + case (.valueBindingPattern, 1): + return "bindingSpecifier" + case (.valueBindingPattern, 2): + return "unexpectedBetweenBindingSpecifierAndPattern" + case (.valueBindingPattern, 3): + return "pattern" + case (.valueBindingPattern, 4): + return "unexpectedAfterPattern" + case (.variableDecl, 0): + return "unexpectedBeforeAttributes" + case (.variableDecl, 1): + return "attributes" + case (.variableDecl, 2): + return "unexpectedBetweenAttributesAndModifiers" + case (.variableDecl, 3): + return "modifiers" + case (.variableDecl, 4): + return "unexpectedBetweenModifiersAndBindingSpecifier" + case (.variableDecl, 5): + return "bindingSpecifier" + case (.variableDecl, 6): + return "unexpectedBetweenBindingSpecifierAndBindings" + case (.variableDecl, 7): + return "bindings" + case (.variableDecl, 8): + return "unexpectedAfterBindings" + case (.versionComponent, 0): + return "unexpectedBeforePeriod" + case (.versionComponent, 1): + return "period" + case (.versionComponent, 2): + return "unexpectedBetweenPeriodAndNumber" + case (.versionComponent, 3): + return "number" + case (.versionComponent, 4): + return "unexpectedAfterNumber" + case (.versionTuple, 0): + return "unexpectedBeforeMajor" + case (.versionTuple, 1): + return "major" + case (.versionTuple, 2): + return "unexpectedBetweenMajorAndComponents" + case (.versionTuple, 3): + return "components" + case (.versionTuple, 4): + return "unexpectedAfterComponents" + case (.whereClause, 0): + return "unexpectedBeforeWhereKeyword" + case (.whereClause, 1): + return "whereKeyword" + case (.whereClause, 2): + return "unexpectedBetweenWhereKeywordAndCondition" + case (.whereClause, 3): + return "condition" + case (.whereClause, 4): + return "unexpectedAfterCondition" + case (.whileStmt, 0): + return "unexpectedBeforeWhileKeyword" + case (.whileStmt, 1): + return "whileKeyword" + case (.whileStmt, 2): + return "unexpectedBetweenWhileKeywordAndConditions" + case (.whileStmt, 3): + return "conditions" + case (.whileStmt, 4): + return "unexpectedBetweenConditionsAndBody" + case (.whileStmt, 5): + return "body" + case (.whileStmt, 6): + return "unexpectedAfterBody" + case (.wildcardPattern, 0): + return "unexpectedBeforeWildcard" + case (.wildcardPattern, 1): + return "wildcard" + case (.wildcardPattern, 2): + return "unexpectedAfterWildcard" + case (.yieldStmt, 0): + return "unexpectedBeforeYieldKeyword" + case (.yieldStmt, 1): + return "yieldKeyword" + case (.yieldStmt, 2): + return "unexpectedBetweenYieldKeywordAndYieldedExpressions" + case (.yieldStmt, 3): + return "yieldedExpressions" + case (.yieldStmt, 4): + return "unexpectedAfterYieldedExpressions" + case (.yieldedExpression, 0): + return "unexpectedBeforeExpression" + case (.yieldedExpression, 1): + return "expression" + case (.yieldedExpression, 2): + return "unexpectedBetweenExpressionAndComma" + case (.yieldedExpression, 3): + return "comma" + case (.yieldedExpression, 4): + return "unexpectedAfterComma" + case (.yieldedExpressionsClause, 0): + return "unexpectedBeforeLeftParen" + case (.yieldedExpressionsClause, 1): + return "leftParen" + case (.yieldedExpressionsClause, 2): + return "unexpectedBetweenLeftParenAndElements" + case (.yieldedExpressionsClause, 3): + return "elements" + case (.yieldedExpressionsClause, 4): + return "unexpectedBetweenElementsAndRightParen" + case (.yieldedExpressionsClause, 5): + return "rightParen" + case (.yieldedExpressionsClause, 6): + return "unexpectedAfterRightParen" + default: + return nil + } + } +} diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift index 8d16c8b8715..4149a2ad504 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -28,7 +28,7 @@ #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif -public struct ABIAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ABIAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Provider: SyntaxChildChoices, SyntaxHashable { case associatedType(AssociatedTypeDeclSyntax) case deinitializer(DeinitializerDeclSyntax) @@ -402,6 +402,10 @@ public struct ABIAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .abiAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeProvider, \Self.provider, \Self.unexpectedAfterProvider]) } @@ -417,7 +421,7 @@ public struct ABIAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// /// - ``PatternBindingSyntax``.``PatternBindingSyntax/accessorBlock`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/accessorBlock`` -public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Accessors: SyntaxChildChoices, SyntaxHashable { case accessors(AccessorDeclListSyntax) case getter(CodeBlockItemListSyntax) @@ -632,6 +636,10 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo } } + public static var syntaxKind: SyntaxKind { + .accessorBlock + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftBrace, \Self.leftBrace, @@ -657,7 +665,7 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo /// ### Contained in /// /// - ``AccessorDeclListSyntax`` -public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -897,6 +905,10 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS } } + public static var syntaxKind: SyntaxKind { + .accessorDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -924,7 +936,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Contained in /// /// - ``AccessorDeclSyntax``.``AccessorDeclSyntax/effectSpecifiers`` -public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1031,6 +1043,10 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .accessorEffectSpecifiers + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, @@ -1051,7 +1067,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// ### Contained in /// /// - ``AccessorDeclSyntax``.``AccessorDeclSyntax/parameters`` -public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1183,6 +1199,10 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn } } + public static var syntaxKind: SyntaxKind { + .accessorParameters + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -1206,7 +1226,7 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `memberBlock`: ``MemberBlockSyntax`` -public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1521,6 +1541,10 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt } } + public static var syntaxKind: SyntaxKind { + .actorDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -1554,7 +1578,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// ### Contained in /// /// - ``ArrayElementListSyntax`` -public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1656,6 +1680,10 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod } } + public static var syntaxKind: SyntaxKind { + .arrayElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -1674,7 +1702,7 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod /// - `leftSquare`: `[` /// - `elements`: ``ArrayElementListSyntax`` /// - `rightSquare`: `]` -public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1830,6 +1858,10 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt } } + public static var syntaxKind: SyntaxKind { + .arrayExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftSquare, \Self.leftSquare, @@ -1848,7 +1880,7 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt /// - `leftSquare`: `[` /// - `element`: ``TypeSyntax`` /// - `rightSquare`: `]` -public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1977,6 +2009,10 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt } } + public static var syntaxKind: SyntaxKind { + .arrayType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftSquare, \Self.leftSquare, @@ -2004,7 +2040,7 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt /// /// - `effectSpecifiers`: ``TypeEffectSpecifiersSyntax``? /// - `arrow`: `->` -public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2106,6 +2142,10 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt } } + public static var syntaxKind: SyntaxKind { + .arrowExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeEffectSpecifiers, \Self.effectSpecifiers, @@ -2138,7 +2178,7 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt /// - `asKeyword`: `as` /// - `questionOrExclamationMark`: (`?` | `!`)? /// - `type`: ``TypeSyntax`` -public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2293,6 +2333,10 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN } } + public static var syntaxKind: SyntaxKind { + .asExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -2311,7 +2355,7 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN /// ### Children /// /// - `equal`: `=` -public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2381,6 +2425,10 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp } } + public static var syntaxKind: SyntaxKind { + .assignmentExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeEqual, \Self.equal, \Self.unexpectedAfterEqual]) } @@ -2421,7 +2469,7 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `initializer`: ``TypeInitializerClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2716,6 +2764,10 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .associatedTypeDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2751,7 +2803,7 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea /// /// - ``AttributeListSyntax`` /// - ``SwitchCaseSyntax``.``SwitchCaseSyntax/attribute`` -public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Arguments: SyntaxChildChoices, SyntaxHashable { case argumentList(LabeledExprListSyntax) case token(TokenSyntax) @@ -3648,6 +3700,10 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr } } + public static var syntaxKind: SyntaxKind { + .attribute + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAtSign, \Self.atSign, @@ -3670,7 +3726,7 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr /// - `specifiers`: ``TypeSpecifierListSyntax`` /// - `attributes`: ``AttributeListSyntax`` /// - `baseType`: ``TypeSyntax`` -public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3853,6 +3909,10 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp } } + public static var syntaxKind: SyntaxKind { + .attributedType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeSpecifiers, \Self.specifiers, @@ -3876,7 +3936,7 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp /// ### Contained in /// /// - ``AvailabilityArgumentListSyntax`` -public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Argument: SyntaxChildChoices, SyntaxHashable { /// ### Tokens /// @@ -4099,6 +4159,10 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } + public static var syntaxKind: SyntaxKind { + .availabilityArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeArgument, \Self.argument, @@ -4120,7 +4184,7 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafS /// ### Contained in /// /// - ``ConditionElementSyntax``.``ConditionElementSyntax/condition`` -public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4305,6 +4369,10 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .availabilityCondition + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAvailabilityKeyword, \Self.availabilityKeyword, @@ -4331,7 +4399,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// ### Contained in /// /// - ``AvailabilityArgumentSyntax``.``AvailabilityArgumentSyntax/argument`` -public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Value: SyntaxChildChoices, SyntaxHashable { case string(SimpleStringLiteralExprSyntax) case version(VersionTupleSyntax) @@ -4553,6 +4621,10 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable, } } + public static var syntaxKind: SyntaxKind { + .availabilityLabeledArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLabel, \Self.label, @@ -4570,7 +4642,7 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable, /// /// - `awaitKeyword`: `await` /// - `expression`: ``ExprSyntax`` -public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4672,6 +4744,10 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt } } + public static var syntaxKind: SyntaxKind { + .awaitExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAwaitKeyword, \Self.awaitKeyword, @@ -4694,7 +4770,7 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct BackDeployedAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct BackDeployedAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4858,6 +4934,10 @@ public struct BackDeployedAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashab } } + public static var syntaxKind: SyntaxKind { + .backDeployedAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBeforeLabel, \Self.beforeLabel, @@ -4880,7 +4960,7 @@ public struct BackDeployedAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashab /// ### Children /// /// - `operator`: `` -public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4950,6 +5030,10 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .binaryOperatorExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeOperator, \Self.operator, \Self.unexpectedAfterOperator]) } @@ -4958,7 +5042,7 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea /// ### Children /// /// - `literal`: (`true` | `false`) -public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -5030,6 +5114,10 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .booleanLiteralExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeLiteral, \Self.literal, \Self.unexpectedAfterLiteral]) } @@ -5039,7 +5127,7 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea /// /// - `borrowKeyword`: (`_borrow` | `borrow`) /// - `expression`: ``ExprSyntax`` -public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -5143,6 +5231,10 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn } } + public static var syntaxKind: SyntaxKind { + .borrowExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBorrowKeyword, \Self.borrowKeyword, @@ -5158,7 +5250,7 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn /// /// - `breakKeyword`: `break` /// - `label`: ``? -public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -5263,6 +5355,10 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } + public static var syntaxKind: SyntaxKind { + .breakStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBreakKeyword, \Self.breakKeyword, diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift index 388e1a4a1c3..fb4941d88ff 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift @@ -21,7 +21,7 @@ /// - `importPath`: `` /// - `versionInfo`: `_CanImportVersionInfoSyntax`? /// - `rightParen`: `)` -public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -204,6 +204,10 @@ public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp } } + public static var syntaxKind: SyntaxKind { + ._canImportExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCanImportKeyword, \Self.canImportKeyword, @@ -231,7 +235,7 @@ public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp /// ### Contained in /// /// - `_CanImportExprSyntax`.`_CanImportExprSyntax/versionInfo` -public struct _CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct _CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -389,6 +393,10 @@ public struct _CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + ._canImportVersionInfo + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeComma, \Self.comma, @@ -413,7 +421,7 @@ public struct _CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable, _ /// ### Contained in /// /// - ``CatchClauseListSyntax`` -public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -566,6 +574,10 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode } } + public static var syntaxKind: SyntaxKind { + .catchClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCatchKeyword, \Self.catchKeyword, @@ -588,7 +600,7 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode /// ### Contained in /// /// - ``CatchItemListSyntax`` -public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -714,6 +726,10 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr } } + public static var syntaxKind: SyntaxKind { + .catchItem + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePattern, \Self.pattern, @@ -761,7 +777,7 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `memberBlock`: ``MemberBlockSyntax`` -public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1082,6 +1098,10 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt } } + public static var syntaxKind: SyntaxKind { + .classDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -1108,7 +1128,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// ### Children /// /// - `classKeyword`: `class` -public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1178,6 +1198,10 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .classRestrictionType + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeClassKeyword, \Self.classKeyword, \Self.unexpectedAfterClassKeyword]) } @@ -1192,7 +1216,7 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _L /// ### Contained in /// /// - ``ClosureSignatureSyntax``.``ClosureSignatureSyntax/capture`` -public struct ClosureCaptureClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ClosureCaptureClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1348,6 +1372,10 @@ public struct ClosureCaptureClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } + public static var syntaxKind: SyntaxKind { + .closureCaptureClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftSquare, \Self.leftSquare, @@ -1371,7 +1399,7 @@ public struct ClosureCaptureClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafS /// ### Contained in /// /// - ``ClosureCaptureSyntax``.``ClosureCaptureSyntax/specifier`` -public struct ClosureCaptureSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ClosureCaptureSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1534,6 +1562,10 @@ public struct ClosureCaptureSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .closureCaptureSpecifier + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeSpecifier, \Self.specifier, @@ -1559,7 +1591,7 @@ public struct ClosureCaptureSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Le /// ### Contained in /// /// - ``ClosureCaptureListSyntax`` -public struct ClosureCaptureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ClosureCaptureSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1714,6 +1746,10 @@ public struct ClosureCaptureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN } } + public static var syntaxKind: SyntaxKind { + .closureCapture + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeSpecifier, \Self.specifier, @@ -1743,7 +1779,7 @@ public struct ClosureCaptureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// - ``MacroExpansionExprSyntax``.``MacroExpansionExprSyntax/trailingClosure`` /// - ``MultipleTrailingClosureElementSyntax``.``MultipleTrailingClosureElementSyntax/closure`` /// - ``SubscriptCallExprSyntax``.``SubscriptCallExprSyntax/trailingClosure`` -public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1923,6 +1959,10 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy } } + public static var syntaxKind: SyntaxKind { + .closureExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftBrace, \Self.leftBrace, @@ -1947,7 +1987,7 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy /// ### Contained in /// /// - ``ClosureSignatureSyntax``.``ClosureSignatureSyntax/parameterClause`` -public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2111,6 +2151,10 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .closureParameterClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -2138,7 +2182,7 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea /// ### Contained in /// /// - ``ClosureParameterListSyntax`` -public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2471,6 +2515,10 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .closureParameter + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2502,7 +2550,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// ### Contained in /// /// - ``ClosureShorthandParameterListSyntax`` -public struct ClosureShorthandParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ClosureShorthandParameterSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2609,6 +2657,10 @@ public struct ClosureShorthandParameterSyntax: SyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .closureShorthandParameter + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -2632,7 +2684,7 @@ public struct ClosureShorthandParameterSyntax: SyntaxProtocol, SyntaxHashable, _ /// ### Contained in /// /// - ``ClosureExprSyntax``.``ClosureExprSyntax/signature`` -public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum ParameterClause: SyntaxChildChoices, SyntaxHashable { case simpleInput(ClosureShorthandParameterListSyntax) case parameterClause(ClosureParameterClauseSyntax) @@ -2937,6 +2989,10 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .closureSignature + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2966,7 +3022,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// ### Contained in /// /// - ``CodeBlockItemListSyntax`` -public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Item: SyntaxChildChoices, SyntaxHashable { case decl(DeclSyntax) case stmt(StmtSyntax) @@ -3184,6 +3240,10 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo } } + public static var syntaxKind: SyntaxKind { + .codeBlockItem + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeItem, \Self.item, @@ -3216,7 +3276,7 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo /// - ``InitializerDeclSyntax``.``InitializerDeclSyntax/body`` /// - ``RepeatStmtSyntax``.``RepeatStmtSyntax/body`` /// - ``WhileStmtSyntax``.``WhileStmtSyntax/body`` -public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3378,6 +3438,10 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr } } + public static var syntaxKind: SyntaxKind { + .codeBlock + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftBrace, \Self.leftBrace, @@ -3399,7 +3463,7 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr /// ### Contained in /// /// - ``CompositionTypeElementListSyntax`` -public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3498,6 +3562,10 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .compositionTypeElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeType, \Self.type, @@ -3512,7 +3580,7 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _Lea /// ### Children /// /// - `elements`: ``CompositionTypeElementListSyntax`` -public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3606,6 +3674,10 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy } } + public static var syntaxKind: SyntaxKind { + .compositionType + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeElements, \Self.elements, \Self.unexpectedAfterElements]) } @@ -3619,7 +3691,7 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy /// ### Contained in /// /// - ``ConditionElementListSyntax`` -public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Condition: SyntaxChildChoices, SyntaxHashable { case expression(ExprSyntax) case availability(AvailabilityConditionSyntax) @@ -3868,6 +3940,10 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .conditionElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCondition, \Self.condition, @@ -3888,7 +3964,7 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// ### Contained in /// /// - ``GenericRequirementSyntax``.``GenericRequirementSyntax/requirement`` -public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4014,6 +4090,10 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .conformanceRequirement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftType, \Self.leftType, @@ -4031,7 +4111,7 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable, _Lea /// /// - `consumeKeyword`: (`_move` | `consume`) /// - `expression`: ``ExprSyntax`` -public struct ConsumeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct ConsumeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4135,6 +4215,10 @@ public struct ConsumeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy } } + public static var syntaxKind: SyntaxKind { + .consumeExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeConsumeKeyword, \Self.consumeKeyword, @@ -4150,7 +4234,7 @@ public struct ConsumeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy /// /// - `continueKeyword`: `continue` /// - `label`: ``? -public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4255,6 +4339,10 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtS } } + public static var syntaxKind: SyntaxKind { + .continueStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeContinueKeyword, \Self.continueKeyword, @@ -4279,7 +4367,7 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtS /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4465,6 +4553,10 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } + public static var syntaxKind: SyntaxKind { + .conventionAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeConventionLabel, \Self.conventionLabel, @@ -4493,7 +4585,7 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4634,6 +4726,10 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S } } + public static var syntaxKind: SyntaxKind { + .conventionWitnessMethodAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWitnessMethodLabel, \Self.witnessMethodLabel, @@ -4651,7 +4747,7 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S /// /// - `copyKeyword`: `copy` /// - `expression`: ``ExprSyntax`` -public struct CopyExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct CopyExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4753,6 +4849,10 @@ public struct CopyExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynta } } + public static var syntaxKind: SyntaxKind { + .copyExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCopyKeyword, \Self.copyKeyword, diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift index ce581322301..54a6d73391e 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift @@ -23,7 +23,7 @@ /// ### Contained in /// /// - ``DeclModifierSyntax``.``DeclModifierSyntax/detail`` -public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -155,6 +155,10 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn } } + public static var syntaxKind: SyntaxKind { + .declModifierDetail + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -177,7 +181,7 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn /// /// - ``AccessorDeclSyntax``.``AccessorDeclSyntax/modifier`` /// - ``DeclModifierListSyntax`` -public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -315,6 +319,10 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod } } + public static var syntaxKind: SyntaxKind { + .declModifier + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -334,7 +342,7 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod /// ### Contained in /// /// - ``DeclNameArgumentListSyntax`` -public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -436,6 +444,10 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .declNameArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -456,7 +468,7 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// ### Contained in /// /// - ``DeclReferenceExprSyntax``.``DeclReferenceExprSyntax/argumentNames`` -public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -612,6 +624,10 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .declNameArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -637,7 +653,7 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// - ``KeyPathPropertyComponentSyntax``.``KeyPathPropertyComponentSyntax/declName`` /// - ``MemberAccessExprSyntax``.``MemberAccessExprSyntax/declName`` /// - ``SpecializeTargetFunctionArgumentSyntax``.``SpecializeTargetFunctionArgumentSyntax/declName`` -public struct DeclReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct DeclReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -748,6 +764,10 @@ public struct DeclReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .declReferenceExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBaseName, \Self.baseName, @@ -763,7 +783,7 @@ public struct DeclReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf /// /// - `deferKeyword`: `defer` /// - `body`: ``CodeBlockSyntax`` -public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -865,6 +885,10 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } + public static var syntaxKind: SyntaxKind { + .deferStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDeferKeyword, \Self.deferKeyword, @@ -892,7 +916,7 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt /// - `deinitKeyword`: `deinit` /// - `effectSpecifiers`: ``DeinitializerEffectSpecifiersSyntax``? /// - `body`: ``CodeBlockSyntax``? -public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1129,6 +1153,10 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .deinitializerDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -1153,7 +1181,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Leaf /// ### Contained in /// /// - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/effectSpecifiers`` -public struct DeinitializerEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DeinitializerEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1226,6 +1254,10 @@ public struct DeinitializerEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashabl } } + public static var syntaxKind: SyntaxKind { + .deinitializerEffectSpecifiers + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, \Self.unexpectedAfterAsyncSpecifier]) } @@ -1246,7 +1278,7 @@ public struct DeinitializerEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashabl /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct DerivativeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DerivativeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1497,6 +1529,10 @@ public struct DerivativeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } + public static var syntaxKind: SyntaxKind { + .derivativeAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeOfLabel, \Self.ofLabel, @@ -1526,7 +1562,7 @@ public struct DerivativeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable /// ### Contained in /// /// - ``DesignatedTypeListSyntax`` -public struct DesignatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DesignatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1628,6 +1664,10 @@ public struct DesignatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN } } + public static var syntaxKind: SyntaxKind { + .designatedType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeadingComma, \Self.leadingComma, @@ -1651,7 +1691,7 @@ public struct DesignatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// ### Contained in /// /// - ``DictionaryElementListSyntax`` -public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1804,6 +1844,10 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .dictionaryElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeKey, \Self.key, @@ -1826,7 +1870,7 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// - `leftSquare`: `[` /// - `content`: (`:` | ``DictionaryElementListSyntax``) /// - `rightSquare`: `]` -public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Content: SyntaxChildChoices, SyntaxHashable { /// ### Tokens /// @@ -2038,6 +2082,10 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp } } + public static var syntaxKind: SyntaxKind { + .dictionaryExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftSquare, \Self.leftSquare, @@ -2058,7 +2106,7 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp /// - `colon`: `:` /// - `value`: ``TypeSyntax`` /// - `rightSquare`: `]` -public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2238,6 +2286,10 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp } } + public static var syntaxKind: SyntaxKind { + .dictionaryType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftSquare, \Self.leftSquare, @@ -2266,7 +2318,7 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp /// /// - ``DifferentiabilityArgumentListSyntax`` /// - ``DifferentiabilityWithRespectToArgumentSyntax``.``DifferentiabilityWithRespectToArgumentSyntax/arguments`` -public struct DifferentiabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DifferentiabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2374,6 +2426,10 @@ public struct DifferentiabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .differentiabilityArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeArgument, \Self.argument, @@ -2396,7 +2452,7 @@ public struct DifferentiabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ /// ### Contained in /// /// - ``DifferentiabilityWithRespectToArgumentSyntax``.``DifferentiabilityWithRespectToArgumentSyntax/arguments`` -public struct DifferentiabilityArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DifferentiabilityArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2554,6 +2610,10 @@ public struct DifferentiabilityArgumentsSyntax: SyntaxProtocol, SyntaxHashable, } } + public static var syntaxKind: SyntaxKind { + .differentiabilityArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -2579,7 +2639,7 @@ public struct DifferentiabilityArgumentsSyntax: SyntaxProtocol, SyntaxHashable, /// /// - ``DerivativeAttributeArgumentsSyntax``.``DerivativeAttributeArgumentsSyntax/arguments`` /// - ``DifferentiableAttributeArgumentsSyntax``.``DifferentiableAttributeArgumentsSyntax/arguments`` -public struct DifferentiabilityWithRespectToArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DifferentiabilityWithRespectToArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Arguments: SyntaxChildChoices, SyntaxHashable { case argument(DifferentiabilityArgumentSyntax) case argumentList(DifferentiabilityArgumentsSyntax) @@ -2794,6 +2854,10 @@ public struct DifferentiabilityWithRespectToArgumentSyntax: SyntaxProtocol, Synt } } + public static var syntaxKind: SyntaxKind { + .differentiabilityWithRespectToArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWrtLabel, \Self.wrtLabel, @@ -2820,7 +2884,7 @@ public struct DifferentiabilityWithRespectToArgumentSyntax: SyntaxProtocol, Synt /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3016,6 +3080,10 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash } } + public static var syntaxKind: SyntaxKind { + .differentiableAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeKindSpecifier, \Self.kindSpecifier, @@ -3049,7 +3117,7 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash /// ### Children /// /// - `wildcard`: `_` -public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3119,6 +3187,10 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .discardAssignmentExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeWildcard, \Self.wildcard, \Self.unexpectedAfterWildcard]) } @@ -3128,7 +3200,7 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ /// /// - `discardKeyword`: `discard` /// - `expression`: ``ExprSyntax`` -public struct DiscardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct DiscardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3230,6 +3302,10 @@ public struct DiscardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy } } + public static var syntaxKind: SyntaxKind { + .discardStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDiscardKeyword, \Self.discardKeyword, @@ -3273,7 +3349,7 @@ public struct DiscardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif -public struct DoExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct DoExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3426,6 +3502,10 @@ public struct DoExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN } } + public static var syntaxKind: SyntaxKind { + .doExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDoKeyword, \Self.doKeyword, @@ -3445,7 +3525,7 @@ public struct DoExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN /// - `throwsClause`: ``ThrowsClauseSyntax``? /// - `body`: ``CodeBlockSyntax`` /// - `catchClauses`: ``CatchClauseListSyntax`` -public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3624,6 +3704,10 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxN } } + public static var syntaxKind: SyntaxKind { + .doStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDoKeyword, \Self.doKeyword, @@ -3649,7 +3733,7 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxN /// ### Contained in /// /// - ``DocumentationAttributeArgumentListSyntax`` -public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Value: SyntaxChildChoices, SyntaxHashable { /// ### Tokens /// @@ -3899,6 +3983,10 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab } } + public static var syntaxKind: SyntaxKind { + .documentationAttributeArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLabel, \Self.label, @@ -3925,7 +4013,7 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct DynamicReplacementAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct DynamicReplacementAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4054,6 +4142,10 @@ public struct DynamicReplacementAttributeArgumentsSyntax: SyntaxProtocol, Syntax } } + public static var syntaxKind: SyntaxKind { + .dynamicReplacementAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeForLabel, \Self.forLabel, diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift index 01ac92dda70..60859aa1e44 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift @@ -23,7 +23,7 @@ /// - `attributes`: ``AttributeListSyntax`` /// - `modifiers`: ``DeclModifierListSyntax`` /// - `placeholder`: `` -public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -210,6 +210,10 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .editorPlaceholderDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -228,7 +232,7 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _ /// ### Children /// /// - `placeholder`: `` -public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -298,6 +302,10 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .editorPlaceholderExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } @@ -311,7 +319,7 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ /// - `modifiers`: ``DeclModifierListSyntax`` /// - `caseKeyword`: `case` /// - `elements`: ``EnumCaseElementListSyntax`` -public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -551,6 +559,10 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS } } + public static var syntaxKind: SyntaxKind { + .enumCaseDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -578,7 +590,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Contained in /// /// - ``EnumCaseElementListSyntax`` -public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -741,6 +753,10 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax } } + public static var syntaxKind: SyntaxKind { + .enumCaseElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -765,7 +781,7 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax /// ### Contained in /// /// - ``EnumCaseElementSyntax``.``EnumCaseElementSyntax/parameterClause`` -public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -929,6 +945,10 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .enumCaseParameterClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -955,7 +975,7 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le /// ### Contained in /// /// - ``EnumCaseParameterListSyntax`` -public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1227,6 +1247,10 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .enumCaseParameter + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeModifiers, \Self.modifiers, @@ -1260,7 +1284,7 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `memberBlock`: ``MemberBlockSyntax`` -public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1581,6 +1605,10 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta } } + public static var syntaxKind: SyntaxKind { + .enumDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -1615,7 +1643,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1741,6 +1769,10 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .exposeAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLanguage, \Self.language, @@ -1771,7 +1803,7 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _L /// ### Children /// /// - `expression`: ``ExprSyntax`` -public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPatternSyntaxNodeProtocol { +public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1838,6 +1870,10 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .expressionPattern + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeExpression, \Self.expression, \Self.unexpectedAfterExpression]) } @@ -1858,7 +1894,7 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L /// ### Contained in /// /// - ``StringLiteralSegmentListSyntax`` -public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2068,6 +2104,10 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .expressionSegment + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBackslash, \Self.backslash, @@ -2088,7 +2128,7 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// ### Children /// /// - `expression`: ``ExprSyntax`` -public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2155,6 +2195,10 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm } } + public static var syntaxKind: SyntaxKind { + .expressionStmt + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeExpression, \Self.expression, \Self.unexpectedAfterExpression]) } @@ -2181,7 +2225,7 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `memberBlock`: ``MemberBlockSyntax`` -public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2480,6 +2524,10 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl } } + public static var syntaxKind: SyntaxKind { + .extensionDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2504,7 +2552,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl /// ### Children /// /// - `fallthroughKeyword`: `fallthrough` -public struct FallThroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct FallThroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2574,6 +2622,10 @@ public struct FallThroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafSt } } + public static var syntaxKind: SyntaxKind { + .fallThroughStmt + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeFallthroughKeyword, \Self.fallthroughKeyword, \Self.unexpectedAfterFallthroughKeyword]) } @@ -2582,7 +2634,7 @@ public struct FallThroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafSt /// ### Children /// /// - `literal`: `` -public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2652,6 +2704,10 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE } } + public static var syntaxKind: SyntaxKind { + .floatLiteralExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeLiteral, \Self.literal, \Self.unexpectedAfterLiteral]) } @@ -2669,7 +2725,7 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE /// - `sequence`: ``ExprSyntax`` /// - `whereClause`: ``WhereClauseSyntax``? /// - `body`: ``CodeBlockSyntax`` -public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2975,6 +3031,10 @@ public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntax } } + public static var syntaxKind: SyntaxKind { + .forStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeForKeyword, \Self.forKeyword, @@ -3006,7 +3066,7 @@ public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntax /// /// - `expression`: ``ExprSyntax`` /// - `exclamationMark`: `!` -public struct ForceUnwrapExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct ForceUnwrapExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3108,6 +3168,10 @@ public struct ForceUnwrapExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx } } + public static var syntaxKind: SyntaxKind { + .forceUnwrapExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -3127,7 +3191,7 @@ public struct ForceUnwrapExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx /// - `rightParen`: `)`? /// - `trailingClosure`: ``ClosureExprSyntax``? /// - `additionalTrailingClosures`: ``MultipleTrailingClosureElementListSyntax`` -public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3382,6 +3446,10 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE } } + public static var syntaxKind: SyntaxKind { + .functionCallExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCalledExpression, \Self.calledExpression, @@ -3431,7 +3499,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE /// - `signature`: ``FunctionSignatureSyntax`` /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `body`: ``CodeBlockSyntax``? -public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3756,6 +3824,10 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS } } + public static var syntaxKind: SyntaxKind { + .functionDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -3787,7 +3859,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Contained in /// /// - ``FunctionSignatureSyntax``.``FunctionSignatureSyntax/effectSpecifiers`` -public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3896,6 +3968,10 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .functionEffectSpecifiers + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, @@ -3917,7 +3993,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// /// - ``FunctionSignatureSyntax``.``FunctionSignatureSyntax/parameterClause`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/parameterClause`` -public struct FunctionParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct FunctionParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4073,6 +4149,10 @@ public struct FunctionParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .functionParameterClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -4103,7 +4183,7 @@ public struct FunctionParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le /// ### Contained in /// /// - ``FunctionParameterListSyntax`` -public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4466,6 +4546,10 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .functionParameter + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -4504,7 +4588,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// - ``FunctionDeclSyntax``.``FunctionDeclSyntax/signature`` /// - ``InitializerDeclSyntax``.``InitializerDeclSyntax/signature`` /// - ``MacroDeclSyntax``.``MacroDeclSyntax/signature`` -public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4633,6 +4717,10 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .functionSignature + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeParameterClause, \Self.parameterClause, @@ -4653,7 +4741,7 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// - `rightParen`: `)` /// - `effectSpecifiers`: ``TypeEffectSpecifiersSyntax``? /// - `returnClause`: ``ReturnClauseSyntax`` -public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4857,6 +4945,10 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS } } + public static var syntaxKind: SyntaxKind { + .functionType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift index 95b544d1f33..a1695506cc9 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift @@ -28,7 +28,7 @@ /// - ``MacroExpansionDeclSyntax``.``MacroExpansionDeclSyntax/genericArgumentClause`` /// - ``MacroExpansionExprSyntax``.``MacroExpansionExprSyntax/genericArgumentClause`` /// - ``MemberTypeSyntax``.``MemberTypeSyntax/genericArgumentClause`` -public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -184,6 +184,10 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .genericArgumentClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftAngle, \Self.leftAngle, @@ -205,7 +209,7 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// ### Contained in /// /// - ``GenericArgumentListSyntax`` -public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Argument: SyntaxChildChoices, SyntaxHashable { case type(TypeSyntax) /// - Note: Requires experimental feature `valueGenerics`. @@ -399,6 +403,10 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax } } + public static var syntaxKind: SyntaxKind { + .genericArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeArgument, \Self.argument, @@ -431,7 +439,7 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax /// - ``StructDeclSyntax``.``StructDeclSyntax/genericParameterClause`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/genericParameterClause`` /// - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/genericParameterClause`` -public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -621,6 +629,10 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .genericParameterClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftAngle, \Self.leftAngle, @@ -648,7 +660,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea /// ### Contained in /// /// - ``GenericParameterListSyntax`` -public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -884,6 +896,10 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .genericParameter + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -911,7 +927,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// ### Contained in /// /// - ``GenericRequirementListSyntax`` -public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Requirement: SyntaxChildChoices, SyntaxHashable { case sameTypeRequirement(SameTypeRequirementSyntax) case conformanceRequirement(ConformanceRequirementSyntax) @@ -1124,6 +1140,10 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn } } + public static var syntaxKind: SyntaxKind { + .genericRequirement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeRequirement, \Self.requirement, @@ -1139,7 +1159,7 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn /// /// - `expression`: ``ExprSyntax`` /// - `genericArgumentClause`: ``GenericArgumentClauseSyntax`` -public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1238,6 +1258,10 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl } } + public static var syntaxKind: SyntaxKind { + .genericSpecializationExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -1273,7 +1297,7 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl /// - ``StructDeclSyntax``.``StructDeclSyntax/genericWhereClause`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/genericWhereClause`` /// - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/genericWhereClause`` -public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1407,6 +1431,10 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn } } + public static var syntaxKind: SyntaxKind { + .genericWhereClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWhereKeyword, \Self.whereKeyword, @@ -1424,7 +1452,7 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn /// - `conditions`: ``ConditionElementListSyntax`` /// - `elseKeyword`: `else` /// - `body`: ``CodeBlockSyntax`` -public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1604,6 +1632,10 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } + public static var syntaxKind: SyntaxKind { + .guardStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeGuardKeyword, \Self.guardKeyword, @@ -1633,7 +1665,7 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt /// ### Children /// /// - `identifier`: (`` | `self` | `init` | `deinit` | `subscript`) -public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPatternSyntaxNodeProtocol { +public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1708,6 +1740,10 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .identifierPattern + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeIdentifier, \Self.identifier, \Self.unexpectedAfterIdentifier]) } @@ -1717,7 +1753,7 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L /// /// - `name`: (`` | `Self` | `Any` | `_`) /// - `genericArgumentClause`: ``GenericArgumentClauseSyntax``? -public struct IdentifierTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct IdentifierTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1823,6 +1859,10 @@ public struct IdentifierTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp } } + public static var syntaxKind: SyntaxKind { + .identifierType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -1843,7 +1883,7 @@ public struct IdentifierTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp /// ### Contained in /// /// - ``IfConfigClauseListSyntax`` -public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Elements: SyntaxChildChoices, SyntaxHashable { case statements(CodeBlockItemListSyntax) case switchCases(SwitchCaseListSyntax) @@ -2151,6 +2191,10 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN } } + public static var syntaxKind: SyntaxKind { + .ifConfigClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePoundKeyword, \Self.poundKeyword, @@ -2174,7 +2218,7 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// - ``AttributeListSyntax`` /// - ``PostfixIfConfigExprSyntax``.``PostfixIfConfigExprSyntax/config`` /// - ``SwitchCaseListSyntax`` -public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2303,6 +2347,10 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS } } + public static var syntaxKind: SyntaxKind { + .ifConfigDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeClauses, \Self.clauses, @@ -2325,7 +2373,7 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Contained in /// /// - ``IfExprSyntax``.``IfExprSyntax/elseBody`` -public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum ElseBody: SyntaxChildChoices, SyntaxHashable { case ifExpr(IfExprSyntax) case codeBlock(CodeBlockSyntax) @@ -2609,6 +2657,10 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN } } + public static var syntaxKind: SyntaxKind { + .ifExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeIfKeyword, \Self.ifKeyword, @@ -2637,7 +2689,7 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2770,6 +2822,10 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } + public static var syntaxKind: SyntaxKind { + .implementsAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeType, \Self.type, @@ -2787,7 +2843,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable /// /// - `wrappedType`: ``TypeSyntax`` /// - `exclamationMark`: `!` -public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2889,6 +2945,10 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH } } + public static var syntaxKind: SyntaxKind { + .implicitlyUnwrappedOptionalType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWrappedType, \Self.wrappedType, @@ -2915,7 +2975,7 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH /// - `importKeyword`: `import` /// - `importKindSpecifier`: (`typealias` | `struct` | `class` | `enum` | `protocol` | `var` | `let` | `func` | `inout`)? /// - `path`: ``ImportPathComponentListSyntax`` -public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3196,6 +3256,10 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn } } + public static var syntaxKind: SyntaxKind { + .importDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -3221,7 +3285,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn /// ### Contained in /// /// - ``ImportPathComponentListSyntax`` -public struct ImportPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ImportPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3330,6 +3394,10 @@ public struct ImportPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy } } + public static var syntaxKind: SyntaxKind { + .importPathComponent + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -3347,7 +3415,7 @@ public struct ImportPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy /// /// - `ampersand`: `&` /// - `expression`: ``ExprSyntax`` -public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3449,6 +3517,10 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt } } + public static var syntaxKind: SyntaxKind { + .inOutExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAmpersand, \Self.ampersand, @@ -3471,7 +3543,7 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt /// - `leftOperand`: ``ExprSyntax`` /// - `operator`: ``ExprSyntax`` /// - `rightOperand`: ``ExprSyntax`` -public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3594,6 +3666,10 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .infixOperatorExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftOperand, \Self.leftOperand, @@ -3621,7 +3697,7 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf /// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/inheritanceClause`` /// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/inheritanceClause`` /// - ``StructDeclSyntax``.``StructDeclSyntax/inheritanceClause`` -public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3750,6 +3826,10 @@ public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .inheritanceClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeColon, \Self.colon, @@ -3769,7 +3849,7 @@ public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// ### Contained in /// /// - ``InheritedTypeListSyntax`` -public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3871,6 +3951,10 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo } } + public static var syntaxKind: SyntaxKind { + .inheritedType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeType, \Self.type, @@ -3897,7 +3981,7 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo /// - ``MatchingPatternConditionSyntax``.``MatchingPatternConditionSyntax/initializer`` /// - ``OptionalBindingConditionSyntax``.``OptionalBindingConditionSyntax/initializer`` /// - ``PatternBindingSyntax``.``PatternBindingSyntax/initializer`` -public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3999,6 +4083,10 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .initializerClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeEqual, \Self.equal, @@ -4031,7 +4119,7 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// - `signature`: ``FunctionSignatureSyntax`` /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `body`: ``CodeBlockSyntax``? -public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4354,6 +4442,10 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDe } } + public static var syntaxKind: SyntaxKind { + .initializerDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -4380,7 +4472,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDe /// ### Children /// /// - `literal`: `` -public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4450,6 +4542,10 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .integerLiteralExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeLiteral, \Self.literal, \Self.unexpectedAfterLiteral]) } @@ -4471,7 +4567,7 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea /// - `expression`: ``ExprSyntax`` /// - `isKeyword`: `is` /// - `type`: ``TypeSyntax`` -public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4604,6 +4700,10 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN } } + public static var syntaxKind: SyntaxKind { + .isExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -4621,7 +4721,7 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN /// /// - `isKeyword`: `is` /// - `type`: ``TypeSyntax`` -public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPatternSyntaxNodeProtocol { +public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4723,6 +4823,10 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafP } } + public static var syntaxKind: SyntaxKind { + .isTypePattern + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeIsKeyword, \Self.isKeyword, diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift index 9adb3c93d27..2c9410330f2 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift @@ -24,7 +24,7 @@ /// ### Contained in /// /// - ``KeyPathComponentListSyntax`` -public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Component: SyntaxChildChoices, SyntaxHashable { case property(KeyPathPropertyComponentSyntax) case `subscript`(KeyPathSubscriptComponentSyntax) @@ -237,6 +237,10 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .keyPathComponent + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePeriod, \Self.period, @@ -261,7 +265,7 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// - `backslash`: `\` /// - `root`: ``TypeSyntax``? /// - `components`: ``KeyPathComponentListSyntax`` -public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -414,6 +418,10 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy } } + public static var syntaxKind: SyntaxKind { + .keyPathExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBackslash, \Self.backslash, @@ -436,7 +444,7 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy /// ### Contained in /// /// - ``KeyPathComponentSyntax``.``KeyPathComponentSyntax/component`` -public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -508,6 +516,10 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .keyPathOptionalComponent + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeQuestionOrExclamationMark, \Self.questionOrExclamationMark, \Self.unexpectedAfterQuestionOrExclamationMark]) } @@ -523,7 +535,7 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable, _L /// ### Contained in /// /// - ``KeyPathComponentSyntax``.``KeyPathComponentSyntax/component`` -public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -622,6 +634,10 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .keyPathPropertyComponent + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDeclName, \Self.declName, @@ -644,7 +660,7 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable, _L /// ### Contained in /// /// - ``KeyPathComponentSyntax``.``KeyPathComponentSyntax/component`` -public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -800,6 +816,10 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .keyPathSubscriptComponent + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftSquare, \Self.leftSquare, @@ -829,7 +849,7 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable, _ /// ### Contained in /// /// - ``LabeledExprListSyntax`` -public struct LabeledExprSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct LabeledExprSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -987,6 +1007,10 @@ public struct LabeledExprSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode } } + public static var syntaxKind: SyntaxKind { + .labeledExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLabel, \Self.label, @@ -1014,7 +1038,7 @@ public struct LabeledExprSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode /// ### Contained in /// /// - ``SpecializeAttributeArgumentListSyntax`` -public struct LabeledSpecializeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct LabeledSpecializeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1187,6 +1211,10 @@ public struct LabeledSpecializeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .labeledSpecializeArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLabel, \Self.label, @@ -1207,7 +1235,7 @@ public struct LabeledSpecializeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ /// - `label`: `` /// - `colon`: `:` /// - `statement`: ``StmtSyntax`` -public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1336,6 +1364,10 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy } } + public static var syntaxKind: SyntaxKind { + .labeledStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLabel, \Self.label, @@ -1363,7 +1395,7 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy /// ### Contained in /// /// - ``GenericRequirementSyntax``.``GenericRequirementSyntax/requirement`` -public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1636,6 +1668,10 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .layoutRequirement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeType, \Self.type, @@ -1673,7 +1709,7 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif -public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1787,6 +1823,10 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .lifetimeSpecifierArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeParameter, \Self.parameter, @@ -1816,7 +1856,7 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif -public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2032,6 +2072,10 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .lifetimeTypeSpecifier + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDependsOnKeyword, \Self.dependsOnKeyword, @@ -2059,7 +2103,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// - `signature`: ``FunctionSignatureSyntax`` /// - `definition`: ``InitializerClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2366,6 +2410,10 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt } } + public static var syntaxKind: SyntaxKind { + .macroDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2403,7 +2451,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// - `rightParen`: `)`? /// - `trailingClosure`: ``ClosureExprSyntax``? /// - `additionalTrailingClosures`: ``MultipleTrailingClosureElementListSyntax`` -public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2817,6 +2865,10 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .macroExpansionDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2856,7 +2908,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea /// - `rightParen`: `)`? /// - `trailingClosure`: ``ClosureExprSyntax``? /// - `additionalTrailingClosures`: ``MultipleTrailingClosureElementListSyntax`` -public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3168,6 +3220,10 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .macroExpansionExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePound, \Self.pound, @@ -3201,7 +3257,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea /// ### Contained in /// /// - ``ConditionElementSyntax``.``ConditionElementSyntax/condition`` -public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3351,6 +3407,10 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .matchingPatternCondition + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCaseKeyword, \Self.caseKeyword, @@ -3373,7 +3433,7 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable, _L /// - `base`: ``ExprSyntax``? /// - `period`: `.` /// - `declName`: ``DeclReferenceExprSyntax`` -public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3503,6 +3563,10 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE } } + public static var syntaxKind: SyntaxKind { + .memberAccessExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBase, \Self.base, @@ -3526,7 +3590,7 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE /// ### Contained in /// /// - ``MemberBlockItemListSyntax`` -public struct MemberBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct MemberBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3633,6 +3697,10 @@ public struct MemberBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax } } + public static var syntaxKind: SyntaxKind { + .memberBlockItem + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDecl, \Self.decl, @@ -3658,7 +3726,7 @@ public struct MemberBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax /// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/memberBlock`` /// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/memberBlock`` /// - ``StructDeclSyntax``.``StructDeclSyntax/memberBlock`` -public struct MemberBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct MemberBlockSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3814,6 +3882,10 @@ public struct MemberBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode } } + public static var syntaxKind: SyntaxKind { + .memberBlock + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftBrace, \Self.leftBrace, @@ -3833,7 +3905,7 @@ public struct MemberBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode /// - `period`: `.` /// - `name`: (`` | `self`) /// - `genericArgumentClause`: ``GenericArgumentClauseSyntax``? -public struct MemberTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct MemberTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3988,6 +4060,10 @@ public struct MemberTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyn } } + public static var syntaxKind: SyntaxKind { + .memberType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBaseType, \Self.baseType, @@ -4008,7 +4084,7 @@ public struct MemberTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyn /// - `baseType`: ``TypeSyntax`` /// - `period`: `.` /// - `metatypeSpecifier`: (`Type` | `Protocol`) -public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4139,6 +4215,10 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS } } + public static var syntaxKind: SyntaxKind { + .metatypeType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBaseType, \Self.baseType, @@ -4159,7 +4239,7 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS /// - `attributes`: ``AttributeListSyntax`` /// - `modifiers`: ``DeclModifierListSyntax`` /// - `placeholder`: `` -public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4348,6 +4428,10 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSy } } + public static var syntaxKind: SyntaxKind { + .missingDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -4366,7 +4450,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSy /// ### Children /// /// - `placeholder`: `` -public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4441,6 +4525,10 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy } } + public static var syntaxKind: SyntaxKind { + .missingExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } @@ -4451,7 +4539,7 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy /// ### Children /// /// - `placeholder`: `` -public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPatternSyntaxNodeProtocol { +public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4526,6 +4614,10 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .missingPattern + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } @@ -4536,7 +4628,7 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Leaf /// ### Children /// /// - `placeholder`: `` -public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4611,6 +4703,10 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy } } + public static var syntaxKind: SyntaxKind { + .missingStmt + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } @@ -4621,7 +4717,7 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy /// ### Children /// /// - `placeholder`: `` -public struct MissingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct MissingSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4696,6 +4792,10 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProt } } + public static var syntaxKind: SyntaxKind { + .missing + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } @@ -4706,7 +4806,7 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProt /// ### Children /// /// - `placeholder`: `` -public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4781,6 +4881,10 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSy } } + public static var syntaxKind: SyntaxKind { + .missingType + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } @@ -4795,7 +4899,7 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSy /// ### Contained in /// /// - ``MultipleTrailingClosureElementListSyntax`` -public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4926,6 +5030,10 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab } } + public static var syntaxKind: SyntaxKind { + .multipleTrailingClosureElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLabel, \Self.label, @@ -4943,7 +5051,7 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab /// /// - `genericParameterClause`: ``GenericParameterClauseSyntax`` /// - `type`: ``TypeSyntax`` -public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -5044,6 +5152,10 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .namedOpaqueReturnType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeGenericParameterClause, \Self.genericParameterClause, @@ -5058,7 +5170,7 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _ /// ### Children /// /// - `nilKeyword`: `nil` -public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -5128,5 +5240,9 @@ public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp } } + public static var syntaxKind: SyntaxKind { + .nilLiteralExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeNilKeyword, \Self.nilKeyword, \Self.unexpectedAfterNilKeyword]) } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift index 86366893f9b..e6cf4edb4e8 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift @@ -24,7 +24,7 @@ /// ### Contained in /// /// - ``ObjCSelectorPieceListSyntax`` -public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -131,6 +131,10 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .objCSelectorPiece + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -153,7 +157,7 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -287,6 +291,10 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax } } + public static var syntaxKind: SyntaxKind { + .opaqueReturnTypeOfAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeMangledName, \Self.mangledName, @@ -308,7 +316,7 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax /// - `operatorKeyword`: `operator` /// - `name`: (`` | `` | ``) /// - `operatorPrecedenceAndTypes`: ``OperatorPrecedenceAndTypesSyntax``? -public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -475,6 +483,10 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS } } + public static var syntaxKind: SyntaxKind { + .operatorDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeFixitySpecifier, \Self.fixitySpecifier, @@ -501,7 +513,7 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Contained in /// /// - ``OperatorDeclSyntax``.``OperatorDeclSyntax/operatorPrecedenceAndTypes`` -public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -662,6 +674,10 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable, } } + public static var syntaxKind: SyntaxKind { + .operatorPrecedenceAndTypes + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeColon, \Self.colon, @@ -685,7 +701,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable, /// ### Contained in /// /// - ``ConditionElementSyntax``.``ConditionElementSyntax/condition`` -public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -841,6 +857,10 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .optionalBindingCondition + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBindingSpecifier, \Self.bindingSpecifier, @@ -860,7 +880,7 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable, _L /// /// - `expression`: ``ExprSyntax`` /// - `questionMark`: `?` -public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -962,6 +982,10 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .optionalChainingExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -977,7 +1001,7 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _L /// /// - `wrappedType`: ``TypeSyntax`` /// - `questionMark`: `?` -public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1079,6 +1103,10 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS } } + public static var syntaxKind: SyntaxKind { + .optionalType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWrappedType, \Self.wrappedType, @@ -1103,7 +1131,7 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct OriginallyDefinedInAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct OriginallyDefinedInAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1310,6 +1338,10 @@ public struct OriginallyDefinedInAttributeArgumentsSyntax: SyntaxProtocol, Synta } } + public static var syntaxKind: SyntaxKind { + .originallyDefinedInAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeModuleLabel, \Self.moduleLabel, @@ -1333,7 +1365,7 @@ public struct OriginallyDefinedInAttributeArgumentsSyntax: SyntaxProtocol, Synta /// /// - `eachKeyword`: `each` /// - `pack`: ``ExprSyntax`` -public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1435,6 +1467,10 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx } } + public static var syntaxKind: SyntaxKind { + .packElementExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeEachKeyword, \Self.eachKeyword, @@ -1450,7 +1486,7 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx /// /// - `eachKeyword`: `each` /// - `pack`: ``TypeSyntax`` -public struct PackElementTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct PackElementTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1552,6 +1588,10 @@ public struct PackElementTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy } } + public static var syntaxKind: SyntaxKind { + .packElementType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeEachKeyword, \Self.eachKeyword, @@ -1569,7 +1609,7 @@ public struct PackElementTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy /// /// - `repeatKeyword`: `repeat` /// - `repetitionPattern`: ``ExprSyntax`` -public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1671,6 +1711,10 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .packExpansionExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeRepeatKeyword, \Self.repeatKeyword, @@ -1686,7 +1730,7 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf /// /// - `repeatKeyword`: `repeat` /// - `repetitionPattern`: ``TypeSyntax`` -public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1788,6 +1832,10 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .packExpansionType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeRepeatKeyword, \Self.repeatKeyword, @@ -1812,7 +1860,7 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _Leaf /// ### Contained in /// /// - ``PatternBindingListSyntax`` -public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2006,6 +2054,10 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN } } + public static var syntaxKind: SyntaxKind { + .patternBinding + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePattern, \Self.pattern, @@ -2026,7 +2078,7 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// ### Children /// /// - `pattern`: ``PatternSyntax`` -public struct PatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct PatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2093,6 +2145,10 @@ public struct PatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy } } + public static var syntaxKind: SyntaxKind { + .patternExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforePattern, \Self.pattern, \Self.unexpectedAfterPattern]) } @@ -2108,7 +2164,7 @@ public struct PatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy /// ### Contained in /// /// - ``PlatformVersionItemListSyntax`` -public struct PlatformVersionItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PlatformVersionItemSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2215,6 +2271,10 @@ public struct PlatformVersionItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy } } + public static var syntaxKind: SyntaxKind { + .platformVersionItem + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePlatformVersion, \Self.platformVersion, @@ -2237,7 +2297,7 @@ public struct PlatformVersionItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy /// /// - ``AvailabilityArgumentSyntax``.``AvailabilityArgumentSyntax/argument`` /// - ``PlatformVersionItemSyntax``.``PlatformVersionItemSyntax/platformVersion`` -public struct PlatformVersionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PlatformVersionSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2348,6 +2408,10 @@ public struct PlatformVersionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax } } + public static var syntaxKind: SyntaxKind { + .platformVersion + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePlatform, \Self.platform, @@ -2363,7 +2427,7 @@ public struct PlatformVersionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax /// /// - `base`: ``ExprSyntax``? /// - `config`: ``IfConfigDeclSyntax`` -public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2462,6 +2526,10 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .postfixIfConfigExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBase, \Self.base, @@ -2477,7 +2545,7 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le /// /// - `expression`: ``ExprSyntax`` /// - `operator`: `` -public struct PostfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct PostfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2579,6 +2647,10 @@ public struct PostfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .postfixOperatorExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -2603,7 +2675,7 @@ public struct PostfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le /// ### Contained in /// /// - ``PoundSourceLocationSyntax``.``PoundSourceLocationSyntax/arguments`` -public struct PoundSourceLocationArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PoundSourceLocationArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2840,6 +2912,10 @@ public struct PoundSourceLocationArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } + public static var syntaxKind: SyntaxKind { + .poundSourceLocationArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeFileLabel, \Self.fileLabel, @@ -2867,7 +2943,7 @@ public struct PoundSourceLocationArgumentsSyntax: SyntaxProtocol, SyntaxHashable /// - `leftParen`: `(` /// - `arguments`: ``PoundSourceLocationArgumentsSyntax``? /// - `rightParen`: `)` -public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3023,6 +3099,10 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .poundSourceLocation + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePoundSourceLocation, \Self.poundSourceLocation, @@ -3049,7 +3129,7 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le /// ### Contained in /// /// - ``PrecedenceGroupAttributeListSyntax`` -public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3186,6 +3266,10 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .precedenceGroupAssignment + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAssignmentLabel, \Self.assignmentLabel, @@ -3210,7 +3294,7 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable, _ /// ### Contained in /// /// - ``PrecedenceGroupAttributeListSyntax`` -public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3348,6 +3432,10 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable } } + public static var syntaxKind: SyntaxKind { + .precedenceGroupAssociativity + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAssociativityLabel, \Self.associativityLabel, @@ -3372,7 +3460,7 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable /// - `leftBrace`: `{` /// - `groupAttributes`: ``PrecedenceGroupAttributeListSyntax`` /// - `rightBrace`: `}` -public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3693,6 +3781,10 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .precedenceGroupDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -3722,7 +3814,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le /// ### Contained in /// /// - ``PrecedenceGroupNameListSyntax`` -public struct PrecedenceGroupNameSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PrecedenceGroupNameSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3827,6 +3919,10 @@ public struct PrecedenceGroupNameSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy } } + public static var syntaxKind: SyntaxKind { + .precedenceGroupName + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -3849,7 +3945,7 @@ public struct PrecedenceGroupNameSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy /// ### Contained in /// /// - ``PrecedenceGroupAttributeListSyntax`` -public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4012,6 +4108,10 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable, _Le } } + public static var syntaxKind: SyntaxKind { + .precedenceGroupRelation + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeHigherThanOrLowerThanLabel, \Self.higherThanOrLowerThanLabel, @@ -4041,7 +4141,7 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable, _Le /// /// - `operator`: `` /// - `expression`: ``ExprSyntax`` -public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4143,6 +4243,10 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .prefixOperatorExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeOperator, \Self.operator, @@ -4163,7 +4267,7 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea /// ### Contained in /// /// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/primaryAssociatedTypeClause`` -public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4319,6 +4423,10 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, } } + public static var syntaxKind: SyntaxKind { + .primaryAssociatedTypeClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftAngle, \Self.leftAngle, @@ -4340,7 +4448,7 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, /// ### Contained in /// /// - ``PrimaryAssociatedTypeListSyntax`` -public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4445,6 +4553,10 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .primaryAssociatedType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeName, \Self.name, @@ -4476,7 +4588,7 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `memberBlock`: ``MemberBlockSyntax`` -public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4797,6 +4909,10 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS } } + public static var syntaxKind: SyntaxKind { + .protocolDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift index 21a910ba8af..42946ced189 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift @@ -21,7 +21,7 @@ /// - `regex`: `` /// - `closingSlash`: `/` /// - `closingPounds`: ``? -public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -207,6 +207,10 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE } } + public static var syntaxKind: SyntaxKind { + .regexLiteralExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeOpeningPounds, \Self.openingPounds, @@ -230,7 +234,7 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE /// - `body`: ``CodeBlockSyntax`` /// - `whileKeyword`: `while` /// - `condition`: ``ExprSyntax`` -public struct RepeatStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct RepeatStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -383,6 +387,10 @@ public struct RepeatStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn } } + public static var syntaxKind: SyntaxKind { + .repeatStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeRepeatKeyword, \Self.repeatKeyword, @@ -409,7 +417,7 @@ public struct RepeatStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn /// - ``FunctionSignatureSyntax``.``FunctionSignatureSyntax/returnClause`` /// - ``FunctionTypeSyntax``.``FunctionTypeSyntax/returnClause`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/returnClause`` -public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -516,6 +524,10 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod } } + public static var syntaxKind: SyntaxKind { + .returnClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeArrow, \Self.arrow, @@ -531,7 +543,7 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod /// /// - `returnKeyword`: `return` /// - `expression`: ``ExprSyntax``? -public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -633,6 +645,10 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn } } + public static var syntaxKind: SyntaxKind { + .returnStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeReturnKeyword, \Self.returnKeyword, @@ -653,7 +669,7 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn /// ### Contained in /// /// - ``GenericRequirementSyntax``.``GenericRequirementSyntax/requirement`` -public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum LeftType: SyntaxChildChoices, SyntaxHashable { case type(TypeSyntax) /// - Note: Requires experimental feature `valueGenerics`. @@ -966,6 +982,10 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy } } + public static var syntaxKind: SyntaxKind { + .sameTypeRequirement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftType, \Self.leftType, @@ -990,7 +1010,7 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy /// ### Children /// /// - `elements`: ``ExprListSyntax`` -public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1084,6 +1104,10 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprS } } + public static var syntaxKind: SyntaxKind { + .sequenceExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeElements, \Self.elements, \Self.unexpectedAfterElements]) } @@ -1101,7 +1125,7 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprS /// /// - ``AvailabilityLabeledArgumentSyntax``.``AvailabilityLabeledArgumentSyntax/value`` /// - ``PoundSourceLocationArgumentsSyntax``.``PoundSourceLocationArgumentsSyntax/fileName`` -public struct SimpleStringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct SimpleStringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1269,6 +1293,10 @@ public struct SimpleStringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, } } + public static var syntaxKind: SyntaxKind { + .simpleStringLiteralExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeOpeningQuote, \Self.openingQuote, @@ -1291,7 +1319,7 @@ public struct SimpleStringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, /// ### Contained in /// /// - ``TypeSpecifierListSyntax`` -public struct SimpleTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SimpleTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1372,6 +1400,10 @@ public struct SimpleTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy } } + public static var syntaxKind: SyntaxKind { + .simpleTypeSpecifier + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeSpecifier, \Self.specifier, \Self.unexpectedAfterSpecifier]) } @@ -1381,7 +1413,7 @@ public struct SimpleTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy /// /// - `someOrAnySpecifier`: (`some` | `any`) /// - `constraint`: ``TypeSyntax`` -public struct SomeOrAnyTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct SomeOrAnyTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1485,6 +1517,10 @@ public struct SomeOrAnyTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafType } } + public static var syntaxKind: SyntaxKind { + .someOrAnyType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeSomeOrAnySpecifier, \Self.someOrAnySpecifier, @@ -1501,7 +1537,7 @@ public struct SomeOrAnyTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafType /// - `shebang`: ``? /// - `statements`: ``CodeBlockItemListSyntax`` /// - `endOfFileToken`: `` -public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1660,6 +1696,10 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP } } + public static var syntaxKind: SyntaxKind { + .sourceFile + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeShebang, \Self.shebang, @@ -1685,7 +1725,7 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP /// ### Contained in /// /// - ``SpecializeAttributeArgumentListSyntax`` -public struct SpecializeAvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SpecializeAvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1874,6 +1914,10 @@ public struct SpecializeAvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashab } } + public static var syntaxKind: SyntaxKind { + .specializeAvailabilityArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAvailabilityLabel, \Self.availabilityLabel, @@ -1901,7 +1945,7 @@ public struct SpecializeAvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashab /// ### Contained in /// /// - ``SpecializeAttributeArgumentListSyntax`` -public struct SpecializeTargetFunctionArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SpecializeTargetFunctionArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2068,6 +2112,10 @@ public struct SpecializeTargetFunctionArgumentSyntax: SyntaxProtocol, SyntaxHash } } + public static var syntaxKind: SyntaxKind { + .specializeTargetFunctionArgument + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeTargetLabel, \Self.targetLabel, @@ -2109,7 +2157,7 @@ public struct SpecializeTargetFunctionArgumentSyntax: SyntaxProtocol, SyntaxHash /// - ``OriginallyDefinedInAttributeArgumentsSyntax``.``OriginallyDefinedInAttributeArgumentsSyntax/moduleName`` /// - ``UnavailableFromAsyncAttributeArgumentsSyntax``.``UnavailableFromAsyncAttributeArgumentsSyntax/message`` /// - ``UnderscorePrivateAttributeArgumentsSyntax``.``UnderscorePrivateAttributeArgumentsSyntax/filename`` -public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2325,6 +2373,10 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .stringLiteralExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeOpeningPounds, \Self.openingPounds, @@ -2354,7 +2406,7 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf /// /// - ``SimpleStringLiteralSegmentListSyntax`` /// - ``StringLiteralSegmentListSyntax`` -public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2424,6 +2476,10 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo } } + public static var syntaxKind: SyntaxKind { + .stringSegment + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeContent, \Self.content, \Self.unexpectedAfterContent]) } @@ -2497,7 +2553,7 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `memberBlock`: ``MemberBlockSyntax`` -public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2818,6 +2874,10 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn } } + public static var syntaxKind: SyntaxKind { + .structDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2849,7 +2909,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn /// - `rightSquare`: `]` /// - `trailingClosure`: ``ClosureExprSyntax``? /// - `additionalTrailingClosures`: ``MultipleTrailingClosureElementListSyntax`` -public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3104,6 +3164,10 @@ public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .subscriptCallExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCalledExpression, \Self.calledExpression, @@ -3133,7 +3197,7 @@ public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf /// - `returnClause`: ``ReturnClauseSyntax`` /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? /// - `accessorBlock`: ``AccessorBlockSyntax``? -public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3437,6 +3501,10 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl } } + public static var syntaxKind: SyntaxKind { + .subscriptDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -3463,7 +3531,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl /// ### Children /// /// - `superKeyword`: `super` -public struct SuperExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct SuperExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3533,6 +3601,10 @@ public struct SuperExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt } } + public static var syntaxKind: SyntaxKind { + .superExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeSuperKeyword, \Self.superKeyword, \Self.unexpectedAfterSuperKeyword]) } @@ -3542,7 +3614,7 @@ public struct SuperExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt /// /// - `withoutTilde`: `` /// - `type`: ``TypeSyntax`` -public struct SuppressedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct SuppressedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3644,6 +3716,10 @@ public struct SuppressedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp } } + public static var syntaxKind: SyntaxKind { + .suppressedType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWithoutTilde, \Self.withoutTilde, @@ -3664,7 +3740,7 @@ public struct SuppressedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp /// ### Contained in /// /// - ``SwitchCaseItemListSyntax`` -public struct SwitchCaseItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SwitchCaseItemSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3790,6 +3866,10 @@ public struct SwitchCaseItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN } } + public static var syntaxKind: SyntaxKind { + .switchCaseItem + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePattern, \Self.pattern, @@ -3812,7 +3892,7 @@ public struct SwitchCaseItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// ### Contained in /// /// - ``SwitchCaseSyntax``.``SwitchCaseSyntax/label`` -public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3968,6 +4048,10 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax } } + public static var syntaxKind: SyntaxKind { + .switchCaseLabel + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCaseKeyword, \Self.caseKeyword, @@ -3990,7 +4074,7 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax /// ### Contained in /// /// - ``SwitchCaseListSyntax`` -public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum Label: SyntaxChildChoices, SyntaxHashable { case `default`(SwitchDefaultLabelSyntax) case `case`(SwitchCaseLabelSyntax) @@ -4222,6 +4306,10 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP } } + public static var syntaxKind: SyntaxKind { + .switchCase + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttribute, \Self.attribute, @@ -4243,7 +4331,7 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP /// ### Contained in /// /// - ``SwitchCaseSyntax``.``SwitchCaseSyntax/label`` -public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4348,6 +4436,10 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn } } + public static var syntaxKind: SyntaxKind { + .switchDefaultLabel + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeDefaultKeyword, \Self.defaultKeyword, @@ -4379,7 +4471,7 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn /// - `leftBrace`: `{` /// - `cases`: ``SwitchCaseListSyntax`` /// - `rightBrace`: `}` -public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4599,6 +4691,10 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn } } + public static var syntaxKind: SyntaxKind { + .switchExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeSwitchKeyword, \Self.switchKeyword, diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift index 2c9705a89c0..abea795621b 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift @@ -32,7 +32,7 @@ /// - `thenExpression`: ``ExprSyntax`` /// - `colon`: `:` /// - `elseExpression`: ``ExprSyntax`` -public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -209,6 +209,10 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy } } + public static var syntaxKind: SyntaxKind { + .ternaryExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeCondition, \Self.condition, @@ -243,7 +247,7 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif -public struct ThenStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct ThenStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -345,6 +349,10 @@ public struct ThenStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynta } } + public static var syntaxKind: SyntaxKind { + .thenStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeThenKeyword, \Self.thenKeyword, @@ -360,7 +368,7 @@ public struct ThenStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynta /// /// - `throwKeyword`: `throw` /// - `expression`: ``ExprSyntax`` -public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -462,6 +470,10 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } + public static var syntaxKind: SyntaxKind { + .throwStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeThrowKeyword, \Self.throwKeyword, @@ -486,7 +498,7 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt /// - ``DoStmtSyntax``.``DoStmtSyntax/throwsClause`` /// - ``FunctionEffectSpecifiersSyntax``.``FunctionEffectSpecifiersSyntax/throwsClause`` /// - ``TypeEffectSpecifiersSyntax``.``TypeEffectSpecifiersSyntax/throwsClause`` -public struct ThrowsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ThrowsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -655,6 +667,10 @@ public struct ThrowsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod } } + public static var syntaxKind: SyntaxKind { + .throwsClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeThrowsSpecifier, \Self.throwsSpecifier, @@ -691,7 +707,7 @@ public struct ThrowsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod /// - `tryKeyword`: `try` /// - `questionOrExclamationMark`: (`?` | `!`)? /// - `expression`: ``ExprSyntax`` -public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -822,6 +838,10 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntax } } + public static var syntaxKind: SyntaxKind { + .tryExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeTryKeyword, \Self.tryKeyword, @@ -840,7 +860,7 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntax /// - `leftParen`: `(` /// - `elements`: ``LabeledExprListSyntax`` /// - `rightParen`: `)` -public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -996,6 +1016,10 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt } } + public static var syntaxKind: SyntaxKind { + .tupleExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -1021,7 +1045,7 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt /// ### Contained in /// /// - ``TuplePatternElementListSyntax`` -public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1188,6 +1212,10 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy } } + public static var syntaxKind: SyntaxKind { + .tuplePatternElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLabel, \Self.label, @@ -1219,7 +1247,7 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy /// - `leftParen`: `(` /// - `elements`: ``TuplePatternElementListSyntax`` /// - `rightParen`: `)` -public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPatternSyntaxNodeProtocol { +public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1381,6 +1409,10 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPa } } + public static var syntaxKind: SyntaxKind { + .tuplePattern + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -1407,7 +1439,7 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPa /// ### Contained in /// /// - ``TupleTypeElementListSyntax`` -public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1648,6 +1680,10 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .tupleTypeElement + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeInoutKeyword, \Self.inoutKeyword, @@ -1674,7 +1710,7 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// - `leftParen`: `(` /// - `elements`: ``TupleTypeElementListSyntax`` /// - `rightParen`: `)` -public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { +public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -1830,6 +1866,10 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt } } + public static var syntaxKind: SyntaxKind { + .tupleType + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, @@ -1852,7 +1892,7 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt /// - `genericParameterClause`: ``GenericParameterClauseSyntax``? /// - `initializer`: ``TypeInitializerClauseSyntax`` /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2135,6 +2175,10 @@ public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl } } + public static var syntaxKind: SyntaxKind { + .typeAliasDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -2167,7 +2211,7 @@ public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl /// - ``MatchingPatternConditionSyntax``.``MatchingPatternConditionSyntax/typeAnnotation`` /// - ``OptionalBindingConditionSyntax``.``OptionalBindingConditionSyntax/typeAnnotation`` /// - ``PatternBindingSyntax``.``PatternBindingSyntax/typeAnnotation`` -public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2272,6 +2316,10 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN } } + public static var syntaxKind: SyntaxKind { + .typeAnnotation + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeColon, \Self.colon, @@ -2293,7 +2341,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// - ``ArrowExprSyntax``.``ArrowExprSyntax/effectSpecifiers`` /// - ``ClosureSignatureSyntax``.``ClosureSignatureSyntax/effectSpecifiers`` /// - ``FunctionTypeSyntax``.``FunctionTypeSyntax/effectSpecifiers`` -public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2397,6 +2445,10 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } + public static var syntaxKind: SyntaxKind { + .typeEffectSpecifiers + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, @@ -2411,7 +2463,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS /// ### Children /// /// - `type`: ``TypeSyntax`` -public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2478,6 +2530,10 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynta } } + public static var syntaxKind: SyntaxKind { + .typeExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeType, \Self.type, \Self.unexpectedAfterType]) } @@ -2492,7 +2548,7 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynta /// /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/initializer`` /// - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/initializer`` -public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2594,6 +2650,10 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + public static var syntaxKind: SyntaxKind { + .typeInitializerClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeEqual, \Self.equal, @@ -2616,7 +2676,7 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct UnavailableFromAsyncAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct UnavailableFromAsyncAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2745,6 +2805,10 @@ public struct UnavailableFromAsyncAttributeArgumentsSyntax: SyntaxProtocol, Synt } } + public static var syntaxKind: SyntaxKind { + .unavailableFromAsyncAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeMessageLabel, \Self.messageLabel, @@ -2769,7 +2833,7 @@ public struct UnavailableFromAsyncAttributeArgumentsSyntax: SyntaxProtocol, Synt /// ### Contained in /// /// - ``AttributeSyntax``.``AttributeSyntax/arguments`` -public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -2898,6 +2962,10 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH } } + public static var syntaxKind: SyntaxKind { + .underscorePrivateAttributeArguments + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeSourceFileLabel, \Self.sourceFileLabel, @@ -2920,7 +2988,7 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH /// /// - `asKeyword`: `as` /// - `questionOrExclamationMark`: (`?` | `!`)? -public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3027,6 +3095,10 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE } } + public static var syntaxKind: SyntaxKind { + .unresolvedAsExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAsKeyword, \Self.asKeyword, @@ -3046,7 +3118,7 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE /// ### Children /// /// - `isKeyword`: `is` -public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3116,6 +3188,10 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE } } + public static var syntaxKind: SyntaxKind { + .unresolvedIsExpr + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeIsKeyword, \Self.isKeyword, \Self.unexpectedAfterIsKeyword]) } @@ -3132,7 +3208,7 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE /// - `questionMark`: `?` /// - `thenExpression`: ``ExprSyntax`` /// - `colon`: `:` -public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3261,6 +3337,10 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ } } + public static var syntaxKind: SyntaxKind { + .unresolvedTernaryExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeQuestionMark, \Self.questionMark, @@ -3283,7 +3363,7 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif -public struct UnsafeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol { +public struct UnsafeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3385,6 +3465,10 @@ public struct UnsafeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn } } + public static var syntaxKind: SyntaxKind { + .unsafeExpr + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeUnsafeKeyword, \Self.unsafeKeyword, @@ -3400,7 +3484,7 @@ public struct UnsafeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn /// /// - `bindingSpecifier`: (`let` | `var` | `inout` | `_mutating` | `_borrowing` | `_consuming` | `borrowing`) /// - `pattern`: ``PatternSyntax`` -public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPatternSyntaxNodeProtocol { +public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3509,6 +3593,10 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, } } + public static var syntaxKind: SyntaxKind { + .valueBindingPattern + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeBindingSpecifier, \Self.bindingSpecifier, @@ -3531,7 +3619,7 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, /// - `modifiers`: ``DeclModifierListSyntax`` /// - `bindingSpecifier`: (`let` | `var` | `inout` | `_mutating` | `_borrowing` | `_consuming`) /// - `bindings`: ``PatternBindingListSyntax`` -public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3785,6 +3873,10 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS } } + public static var syntaxKind: SyntaxKind { + .variableDecl + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, @@ -3810,7 +3902,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Contained in /// /// - ``VersionComponentListSyntax`` -public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -3921,6 +4013,10 @@ public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } + public static var syntaxKind: SyntaxKind { + .versionComponent + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforePeriod, \Self.period, @@ -3944,7 +4040,7 @@ public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// - ``AvailabilityLabeledArgumentSyntax``.``AvailabilityLabeledArgumentSyntax/value`` /// - `_CanImportVersionInfoSyntax`.`_CanImportVersionInfoSyntax/version` /// - ``PlatformVersionSyntax``.``PlatformVersionSyntax/version`` -public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4078,6 +4174,10 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod } } + public static var syntaxKind: SyntaxKind { + .versionTuple + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeMajor, \Self.major, @@ -4099,7 +4199,7 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod /// - ``CatchItemSyntax``.``CatchItemSyntax/whereClause`` /// - ``ForStmtSyntax``.``ForStmtSyntax/whereClause`` /// - ``SwitchCaseItemSyntax``.``SwitchCaseItemSyntax/whereClause`` -public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4201,6 +4301,10 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode } } + public static var syntaxKind: SyntaxKind { + .whereClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWhereKeyword, \Self.whereKeyword, @@ -4217,7 +4321,7 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode /// - `whileKeyword`: `while` /// - `conditions`: ``ConditionElementListSyntax`` /// - `body`: ``CodeBlockSyntax`` -public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4370,6 +4474,10 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } + public static var syntaxKind: SyntaxKind { + .whileStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeWhileKeyword, \Self.whileKeyword, @@ -4399,7 +4507,7 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt /// ### Children /// /// - `wildcard`: `_` -public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPatternSyntaxNodeProtocol { +public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4469,6 +4577,10 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Lea } } + public static var syntaxKind: SyntaxKind { + .wildcardPattern + } + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeWildcard, \Self.wildcard, \Self.unexpectedAfterWildcard]) } @@ -4478,7 +4590,7 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Lea /// /// - `yieldKeyword`: `yield` /// - `yieldedExpressions`: (``YieldedExpressionsClauseSyntax`` | ``ExprSyntax``) -public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxNodeProtocol { +public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public enum YieldedExpressions: SyntaxChildChoices, SyntaxHashable { case multiple(YieldedExpressionsClauseSyntax) case single(ExprSyntax) @@ -4660,6 +4772,10 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } + public static var syntaxKind: SyntaxKind { + .yieldStmt + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeYieldKeyword, \Self.yieldKeyword, @@ -4679,7 +4795,7 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt /// ### Contained in /// /// - ``YieldedExpressionListSyntax`` -public struct YieldedExpressionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct YieldedExpressionSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4781,6 +4897,10 @@ public struct YieldedExpressionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt } } + public static var syntaxKind: SyntaxKind { + .yieldedExpression + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeExpression, \Self.expression, @@ -4801,7 +4921,7 @@ public struct YieldedExpressionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// ### Contained in /// /// - ``YieldStmtSyntax``.``YieldStmtSyntax/yieldedExpressions`` -public struct YieldedExpressionsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct YieldedExpressionsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LayoutSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { @@ -4957,6 +5077,10 @@ public struct YieldedExpressionsClauseSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public static var syntaxKind: SyntaxKind { + .yieldedExpressionsClause + } + public static let structure: SyntaxNodeStructure = .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, diff --git a/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift b/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift index 34d02b48426..69d1fb0de28 100644 --- a/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift +++ b/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift @@ -211,21 +211,19 @@ extension SyntaxProtocol { } } ) - } else if case .layout(let layout) = self.syntaxNodeType.structure { + } else if case .layout = self.syntaxNodeType.structure { let typeName = String(describing: type(of: self)) return ExprSyntax( FunctionCallExprSyntax(callee: DeclReferenceExprSyntax(baseName: .identifier(typeName))) { - for keyPath in layout { - let label = childName(keyPath) ?? "" - let value = self[keyPath: keyPath as! PartialKeyPath] as! SyntaxProtocol? + for child in children(viewMode: .all) { + let property = child.propertyInParent! + let label = property.name! let isUnexpected = label.hasPrefix("unexpected") - if value != nil { - LabeledExprSyntax( - label: isUnexpected ? nil : .identifier(label), - colon: isUnexpected ? nil : .colonToken(), - expression: value?.debugInitCallExpr(includeTrivia: includeTrivia) ?? ExprSyntax(NilLiteralExprSyntax()) - ) - } + LabeledExprSyntax( + label: isUnexpected ? nil : .identifier(label), + colon: isUnexpected ? nil : .colonToken(), + expression: child.debugInitCallExpr(includeTrivia: includeTrivia) + ) } } )