From aa0b9a7a6f65cd1f4ea89f44e82fb7ab6a447992 Mon Sep 17 00:00:00 2001 From: Becca Royal-Gordon Date: Mon, 4 Nov 2024 18:18:11 -0800 Subject: [PATCH 1/7] Conform NamedDeclSyntax to DeclSyntaxProtocol MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This is accurate for all NamedDeclSyntax conformers so far, so I feel comfortable doing it. This also improves the accuracy of the “conforms if it can” validation by also checking the trait’s base kind against the node. That eliminates several false positives in the test. --- .../Sources/SyntaxSupport/Traits.swift | 1 + .../ValidateSyntaxNodes.swift | 36 +++++++++++++------ .../SwiftSyntax/generated/SyntaxTraits.swift | 2 +- 3 files changed, 27 insertions(+), 12 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index c9eb2828931..705e685693f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -111,6 +111,7 @@ public let TRAITS: [Trait] = [ ), Trait( traitName: "NamedDecl", + baseKind: .decl, children: [ Child(name: "name", kind: .token(choices: [.token(.identifier)])) ] diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift index c9f81c34a9b..87fb450e66a 100644 --- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift +++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift @@ -116,6 +116,30 @@ fileprivate extension Array where Element: Hashable, Element: Comparable { } } +extension LayoutNode { + /// True if `self` satisfies all of the requirements of `trait`, regardless + /// of whether it actually declares conformance to it. + func canConform(to trait: Trait) -> Bool { + if let traitBaseKind = trait.baseKind { + guard traitBaseKind == self.base else { + return false + } + } + + return trait.children.allSatisfy { traitChild in + self.children.contains { nodeChild in + traitChild.hasSameType(as: nodeChild) + } + } + } + + /// True if `self` declares conformance to `trait`, regardless of whether + /// it satisfies the trait's requirements. + func conforms(to trait: Trait) -> Bool { + self.traits.contains(trait.traitName) + } +} + class ValidateSyntaxNodes: XCTestCase { /// All nodes with base kind e.g. `ExprSyntax` should end with `ExprSyntax`. func testBaseKindSuffix() { @@ -514,12 +538,7 @@ class ValidateSyntaxNodes: XCTestCase { for node in SYNTAX_NODES.compactMap(\.layoutNode) { for trait in TRAITS { - let canConformToTrait = trait.children.allSatisfy { traitChild in - node.children.contains { nodeChild in - traitChild.hasSameType(as: nodeChild) - } - } - if canConformToTrait && !node.traits.contains(trait.traitName) { + if node.canConform(to: trait) && !node.conforms(to: trait) { failures.append( ValidationFailure( node: node.kind, @@ -533,7 +552,6 @@ class ValidateSyntaxNodes: XCTestCase { assertFailuresMatchXFails( failures, expectedFailures: [ - ValidationFailure(node: .accessorParameters, message: "could conform to trait 'NamedDecl' but does not"), ValidationFailure(node: .availabilityCondition, message: "could conform to trait 'Parenthesized' but does not"), ValidationFailure(node: ._canImportExpr, message: "could conform to trait 'Parenthesized' but does not"), ValidationFailure( @@ -542,10 +560,6 @@ class ValidateSyntaxNodes: XCTestCase { ), ValidationFailure(node: .editorPlaceholderDecl, message: "could conform to trait 'MissingNode' but does not"), ValidationFailure(node: .editorPlaceholderExpr, message: "could conform to trait 'MissingNode' but does not"), - ValidationFailure(node: .enumCaseElement, message: "could conform to trait 'NamedDecl' but does not"), - ValidationFailure(node: .genericParameter, message: "could conform to trait 'NamedDecl' but does not"), - ValidationFailure(node: .precedenceGroupName, message: "could conform to trait 'NamedDecl' but does not"), - ValidationFailure(node: .primaryAssociatedType, message: "could conform to trait 'NamedDecl' but does not"), ValidationFailure( node: .yieldedExpressionsClause, message: "could conform to trait 'Parenthesized' but does not" diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index 68f8ad515c9..a541b00e77c 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -278,7 +278,7 @@ extension SyntaxProtocol { // MARK: - NamedDeclSyntax -public protocol NamedDeclSyntax: SyntaxProtocol { +public protocol NamedDeclSyntax: SyntaxProtocol, DeclSyntaxProtocol { /// ### Tokens /// /// For syntax trees generated by the parser, this is guaranteed to be ``. From df991ae2a920f410801e97073951d04148694ac3 Mon Sep 17 00:00:00 2001 From: Becca Royal-Gordon Date: Mon, 4 Nov 2024 18:18:53 -0800 Subject: [PATCH 2/7] Introduce DeclGroupHeaderSyntax This is the base node for the headers we are about to extract. Unlike other base nodes, DeclGroupHeaderSyntax has children, which are treated as protocol requirements for derived nodes. --- .../Sources/SyntaxSupport/CommonNodes.swift | 85 +++++ .../SyntaxSupport/CompatibilityLayer.swift | 2 +- .../Sources/SyntaxSupport/Node.swift | 6 +- .../SyntaxSupport/SyntaxNodeKind.swift | 15 +- .../swiftsyntax/RawSyntaxNodesFile.swift | 2 +- .../swiftsyntax/SyntaxBaseNodesFile.swift | 58 ++- .../swiftsyntax/SyntaxNodesFile.swift | 2 +- .../BuildableNodesFile.swift | 2 +- ...amedChildrenBuilderCompatibilityFile.swift | 2 +- .../ValidateSyntaxNodes.swift | 9 +- Sources/SwiftParser/Declarations.swift | 110 ++++++ .../generated/LayoutNodes+Parsable.swift | 18 + .../generated/Parser+TokenSpecSet.swift | 88 +++++ .../ParseDiagnosticsGenerator.swift | 1 + .../SyntaxKindNameForDiagnostics.swift | 2 + Sources/SwiftSyntax/CustomTraits.swift | 11 + .../generated/SwiftSyntax.md | 2 + .../generated/ChildNameForKeyPath.swift | 22 ++ .../generated/SyntaxAnyVisitor.swift | 8 + .../generated/SyntaxBaseNodes.swift | 361 ++++++++++++++++++ .../generated/SyntaxCollections.swift | 4 + .../SwiftSyntax/generated/SyntaxEnum.swift | 20 + .../SwiftSyntax/generated/SyntaxKind.swift | 5 + .../generated/SyntaxRewriter.swift | 22 ++ .../SwiftSyntax/generated/SyntaxTraits.swift | 4 + .../SwiftSyntax/generated/SyntaxVisitor.swift | 18 + .../generated/raw/RawSyntaxNodesD.swift | 42 ++ .../generated/raw/RawSyntaxNodesJKLMN.swift | 106 +++++ .../generated/raw/RawSyntaxValidation.swift | 13 + .../syntaxNodes/SyntaxNodesGHI.swift | 4 + .../syntaxNodes/SyntaxNodesJKLMN.swift | 260 +++++++++++++ ...bleByStringInterpolationConformances.swift | 6 + 32 files changed, 1293 insertions(+), 17 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index 7247e17a909..b96cebedb4b 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -180,6 +180,46 @@ public let COMMON_NODES: [Node] = [ parserFunction: "parseDeclaration" ), + Node( + kind: .declGroupHeader, + base: .syntax, + nameForDiagnostics: "declaration group header", + parserFunction: "parseDeclarationGroupHeader", + traits: [ + "WithAttributes", + "WithModifiers", + ], + children: [ + Child( + name: "attributes", + kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true), + nameForDiagnostics: "attributes" + ), + Child( + name: "modifiers", + kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true), + nameForDiagnostics: "modifiers", + documentation: "Modifiers like `public` that are attached to the actor declaration." + ), + Child( + name: "introducer", + kind: .token(choices: [ + .keyword(.actor), .keyword(.class), .keyword(.enum), .keyword(.extension), .keyword(.protocol), + .keyword(.struct), + ]), + documentation: "The token that introduces this declaration, eg. `class` for a class declaration." + ), + Child(name: "inheritanceClause", kind: .node(kind: .inheritanceClause), isOptional: true), + Child( + name: "genericWhereClause", + kind: .node(kind: .genericWhereClause), + documentation: + "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.", + isOptional: true + ), + ] + ), + Node( kind: .expr, base: .syntax, @@ -187,6 +227,51 @@ public let COMMON_NODES: [Node] = [ parserFunction: "parseExpression" ), + Node( + kind: .missingDeclHeader, + base: .declGroupHeader, + nameForDiagnostics: "declaration group header", + documentation: + "In case the source code is missing a declaration group header, this node stands in place of the missing header.", + traits: [ + "MissingNode", + "WithAttributes", + "WithModifiers", + ], + children: [ + Child( + name: "attributes", + kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true), + documentation: + "If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these." + ), + Child( + name: "modifiers", + kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true), + documentation: + "If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these." + ), + Child( + name: "placeholder", + kind: .token(choices: [.token(.identifier)], requiresLeadingSpace: false, requiresTrailingSpace: false), + documentation: """ + A placeholder, i.e. `<#decl#>`, that can be inserted into the source code to represent the missing declaration. + + This token should always have `presence = .missing`. + """ + ), + Child(name: "inheritanceClause", kind: .node(kind: .inheritanceClause), isOptional: true), + Child( + name: "genericWhereClause", + kind: .node(kind: .genericWhereClause), + documentation: + "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.", + isOptional: true + ), + + ] + ), + Node( kind: .missingDecl, base: .decl, diff --git a/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift b/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift index f95f3143669..a3fe70dd372 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift @@ -94,7 +94,7 @@ public struct CompatibilityLayer { typeName: layoutNode.kind.rawValue, initialChildren: layoutNode.children, history: layoutNode.childHistory, - areRequirements: false + areRequirements: layoutNode.kind.isBase ) deprecatedMembersByNode[node.syntaxNodeKind] = result diff --git a/CodeGeneration/Sources/SyntaxSupport/Node.swift b/CodeGeneration/Sources/SyntaxSupport/Node.swift index 5c7aba135fa..6f8f313a40e 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Node.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Node.swift @@ -69,11 +69,7 @@ public class Node: NodeChoiceConvertible { public var layoutNode: LayoutNode? { switch data { case .layout: - if kind.isBase { - return nil - } else { - return LayoutNode(node: self) - } + return LayoutNode(node: self) default: return nil } diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index aca5c52aa86..dbacbca5fc2 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -81,6 +81,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case conventionWitnessMethodAttributeArguments case copyExpr case decl + case declGroupHeader case declModifier case declModifierDetail case declModifierList @@ -197,6 +198,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case metatypeType case missing case missingDecl + case missingDeclHeader case missingExpr case missingPattern case missingStmt @@ -320,7 +322,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon /// `true` if this is one of the `missing*` cases. public var isMissing: Bool { switch self { - case .missingDecl, .missingExpr, .missingPattern, .missingStmt, .missing, .missingType: + case .missingDecl, .missingDeclHeader, .missingExpr, .missingPattern, .missingStmt, .missing, .missingType: return true default: return false @@ -329,7 +331,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon public var isBase: Bool { switch self { - case .decl, .expr, .pattern, .stmt, .syntax, .syntaxCollection, .type: + case .decl, .declGroupHeader, .expr, .pattern, .stmt, .syntax, .syntaxCollection, .type: return true default: return false @@ -351,6 +353,15 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon } } + public var baseTypeSuffix: String? { + switch self { + case .declGroupHeader: + return "DeclHeaderSyntax" + default: + return isBase ? syntaxType.description : nil + } + } + public var isAvailableInDocc: Bool { if let node = SYNTAX_NODE_MAP[self], node.isExperimental { return false diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift index cdc29c9cad5..c376a8b1012 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift @@ -142,7 +142,7 @@ func rawSyntaxNodesFile(nodesStartingWith: [Character]) -> SourceFileSyntax { ) } - if let node = node.layoutNode { + if !node.kind.isBase, let node = node.layoutNode { let params = FunctionParameterListSyntax { for child in node.children { FunctionParameterSyntax( diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift index e308b4364e6..77cb3611dc5 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift @@ -21,7 +21,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { node.documentation, node.subtypes, ]) - DeclSyntax( + try! ProtocolDeclSyntax( """ // MARK: - \(node.kind.syntaxType) @@ -31,9 +31,26 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { /// /// - Warning: Do not conform to this protocol yourself. \(node.apiAttributes())\ - public protocol \(node.kind.protocolType): \(node.base.protocolType) {} + public protocol \(node.kind.protocolType): \(node.base.protocolType) """ - ) + ) { + for child in node.layoutNode?.children ?? [] { + // ================================== + // Children properties (requirements) + // ================================== + + let childType: TypeSyntax = + child.kind.isNodeChoicesEmpty ? child.syntaxNodeKind.syntaxType : child.syntaxChoicesType + let type = child.isOptional ? TypeSyntax("\(childType)?") : TypeSyntax("\(childType)") + + DeclSyntax( + """ + \(child.documentation)\ + \(child.apiAttributes) var \(child.varDeclName): \(type) { get set } + """ + ) + } + } DeclSyntax( #""" @@ -285,6 +302,41 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { StmtSyntax("return .choices(\(choices))") } + + for child in node.layoutNode?.children ?? [] { + // ================================================= + // Children properties (type-erased implementations) + // ================================================= + + let childType: TypeSyntax = + child.kind.isNodeChoicesEmpty ? child.syntaxNodeKind.syntaxType : child.syntaxChoicesType + let type = child.isOptional ? TypeSyntax("\(childType)?") : TypeSyntax("\(childType)") + + try! VariableDeclSyntax( + """ + \(child.documentation)\ + \(child.apiAttributes)public var \(child.varDeclName): \(type) + """ + ) { + AccessorDeclSyntax( + """ + get { + return self.asProtocol(\(node.kind.protocolType).self).\(child.baseCallName) + } + """ + ) + + AccessorDeclSyntax( + """ + set(value) { + var existentialCopy = self.asProtocol(\(node.kind.protocolType).self) + existentialCopy.\(child.baseCallName) = value + self = \(node.kind.syntaxType)(fromProtocol: existentialCopy) + } + """ + ) + } + } } leafProtocolDecl(type: node.kind.leafProtocolType, inheritedType: node.kind.protocolType) diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift index 214ca0ce2c6..476b86ea16e 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift @@ -21,7 +21,7 @@ import Utils /// It then only emits those syntax nodes whose base kind are that specified kind. func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax { SourceFileSyntax(leadingTrivia: copyrightHeader) { - for node in SYNTAX_NODES.compactMap(\.layoutNode) + for node in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode) where nodesStartingWith.contains(node.kind.syntaxType.description.droppingLeadingUnderscores.first!) { // We are actually handling this node now try! StructDeclSyntax( diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift index de35ac4c8d4..0f308f7b3ef 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift @@ -26,7 +26,7 @@ let buildableNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { """ ) - for node in SYNTAX_NODES.compactMap(\.layoutNode) { + for node in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode) { let type = node.type if let convenienceInit = try! InitSignature(node).createConvenienceBuilderInitializer() { diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift index 1785144c1d0..95abbe48c60 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift @@ -26,7 +26,7 @@ let renamedChildrenBuilderCompatibilityFile = try! SourceFileSyntax(leadingTrivi """ ) - for layoutNode in SYNTAX_NODES.compactMap(\.layoutNode).filter({ !$0.childHistory.isEmpty }) { + for layoutNode in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode).filter({ !$0.childHistory.isEmpty }) { let deprecatedMembers = SYNTAX_COMPATIBILITY_LAYER.deprecatedMembers(for: layoutNode) for signature in deprecatedMembers.inits { diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift index 87fb450e66a..8922d5be648 100644 --- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift +++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift @@ -145,12 +145,12 @@ class ValidateSyntaxNodes: XCTestCase { func testBaseKindSuffix() { var failures: [ValidationFailure] = [] for node in SYNTAX_NODES where node.base != .syntaxCollection { - if !node.kind.syntaxType.description.hasSuffix(node.base.syntaxType.description) { + if !node.kind.syntaxType.description.hasSuffix(node.base.baseTypeSuffix!) { failures.append( ValidationFailure( node: node.kind, message: - "has base kind '\(node.base.syntaxType)' but type name doesn’t have '\(node.base.syntaxType)' suffix" + "has base kind '\(node.base.syntaxType)' but type name doesn’t have '\(node.base.baseTypeSuffix!)' suffix" ) ) } @@ -461,6 +461,11 @@ class ValidateSyntaxNodes: XCTestCase { node: .declModifier, message: "child 'name' only has keywords as its token choices and should thus end with 'Specifier'" ), + // An extension member for '*DeclSyntax.introducer' already existed; we're just formalizing it + ValidationFailure( + node: .declGroupHeader, + message: "child 'introducer' only has keywords as its token choices and should thus end with 'Specifier'" + ), ] ) } diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index 6d8845d52a0..3aa8dc75ec4 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -311,6 +311,116 @@ extension Parser { ) } + /// Parse the standalone header of a declaration group (a header that won't have a member block attached to it). + /// For a header that will have a member list attached, use ``Parser/parseHeaderForDeclarationGroup(attrs:keyword:handle:)``, which this method wraps. + /// + /// If `inMemberDeclList` is `true`, we know that the next item must be a + /// declaration and thus start with a keyword. This allows further recovery. + mutating func parseDeclarationGroupHeader(inMemberDeclList: Bool = false) -> RawDeclGroupHeaderSyntax { + // If we are at a `#if` of attributes, the `#if` directive should be + // parsed when we're parsing the attributes. + if self.at(.poundIf) && !self.withLookahead({ $0.consumeIfConfigOfAttributes() }) { + // If we're at a #if, that's not actually allowed here; parse it and add + // it as an unexpected node of a MissingDeclGroupHeaderSyntax. + let directive = self.parsePoundIfDirective { (parser, _) in + let parsedDecl = parser.parseDeclaration() + let semicolon = parser.consume(if: .semicolon) + return RawMemberBlockItemSyntax( + decl: parsedDecl, + semicolon: semicolon, + arena: parser.arena + ) + } addSemicolonIfNeeded: { lastElement, newItemAtStartOfLine, parser in + if lastElement.semicolon == nil && !newItemAtStartOfLine { + return RawMemberBlockItemSyntax( + lastElement.unexpectedBeforeDecl, + decl: lastElement.decl, + lastElement.unexpectedBetweenDeclAndSemicolon, + semicolon: parser.missingToken(.semicolon), + lastElement.unexpectedAfterSemicolon, + arena: parser.arena + ) + } else { + return nil + } + } syntax: { parser, elements in + return .decls(RawMemberBlockItemListSyntax(elements: elements, arena: parser.arena)) + } + return RawDeclGroupHeaderSyntax( + RawMissingDeclHeaderSyntax( + RawUnexpectedNodesSyntax([directive], arena: self.arena), + attributes: emptyCollection(RawAttributeListSyntax.self), + modifiers: emptyCollection(RawDeclModifierListSyntax.self), + placeholder: missingToken(.identifier, text: "decl"), + inheritanceClause: nil, + genericWhereClause: nil, + arena: self.arena + ) + ) + } + + let attrs = DeclAttributes( + attributes: self.parseAttributeList(), + modifiers: self.parseDeclModifierList() + ) + + let recoveryResult: (match: DeclGroupHeaderSyntax.IntroducerOptions, handle: RecoveryConsumptionHandle)? + if let atResult = self.at(anyIn: DeclGroupHeaderSyntax.IntroducerOptions.self) { + // We are at a keyword that starts a declaration. Parse that declaration. + recoveryResult = (atResult.spec, .noRecovery(atResult.handle)) + } else { + // In all other cases, use standard token recovery to find the declaration + // to parse. + // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context) + // while recovering to the declaration start. + let recoveryPrecedence = inMemberDeclList ? TokenPrecedence.closingBrace : nil + recoveryResult = self.canRecoverTo( + anyIn: DeclGroupHeaderSyntax.IntroducerOptions.self, + overrideRecoveryPrecedence: recoveryPrecedence + ) + } + + if let (match, handle) = recoveryResult { + return parseHeaderForDeclarationGroup(attrs: attrs, introducer: match, introducerHandle: handle).0 + } + + if inMemberDeclList { + if self.currentToken.isEditorPlaceholder { + let placeholder = self.parseAnyIdentifier() + return RawDeclGroupHeaderSyntax( + RawMissingDeclHeaderSyntax( + attributes: attrs.attributes, + modifiers: attrs.modifiers, + placeholder: placeholder, + inheritanceClause: nil, + genericWhereClause: nil, + arena: self.arena + ) + ) + } + } + + return RawDeclGroupHeaderSyntax( + RawMissingDeclHeaderSyntax( + attributes: attrs.attributes, + modifiers: attrs.modifiers, + placeholder: missingToken(.identifier, text: "decl"), + inheritanceClause: nil, + genericWhereClause: nil, + arena: self.arena + ) + ) + } + + /// Parse the header of a declaration group that will eventually have a member block attached. + mutating func parseHeaderForDeclarationGroup( + attrs: DeclAttributes, + introducer: DeclGroupHeaderSyntax.IntroducerOptions, + introducerHandle: RecoveryConsumptionHandle + ) -> (RawDeclGroupHeaderSyntax, shouldContinueParsing: Bool) { + fatalError("not yet implemented") + } + /// Returns `true` if it looks like the parser is positioned at a function declaration that’s missing the `func` keyword. fileprivate mutating func atFunctionDeclarationWithoutFuncKeyword() -> Bool { var nextTokenIsLeftParenOrLeftAngle: Bool { diff --git a/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift b/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift index d3a703ed22a..12af615f705 100644 --- a/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift +++ b/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift @@ -148,6 +148,24 @@ extension CodeBlockSyntax: SyntaxParseable { } } +extension DeclGroupHeaderSyntax: SyntaxParseable { + public static func parse(from parser: inout Parser) -> Self { + // Keep the parser alive so that the arena in which `raw` is allocated + // doesn’t get deallocated before we have a chance to create a syntax node + // from it. We can’t use `parser.arena` as the parameter to + // `Syntax(raw:arena:)` because the node might have been re-used during an + // incremental parse and would then live in a different arena than + // `parser.arena`. + defer { + withExtendedLifetime(parser) { + } + } + let node = parser.parseDeclarationGroupHeader() + let raw = RawSyntax(parser.parseRemainder(into: node)) + return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self) + } +} + extension DeclSyntax: SyntaxParseable { public static func parse(from parser: inout Parser) -> Self { // Keep the parser alive so that the arena in which `raw` is allocated diff --git a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift index 0ddbdbd54c0..f1687f64374 100644 --- a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift +++ b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift @@ -844,6 +844,94 @@ extension ConsumeExprSyntax { } } +extension DeclGroupHeaderSyntax { + @_spi(Diagnostics) + public enum IntroducerOptions: TokenSpecSet { + case actor + case `class` + case `enum` + case `extension` + case `protocol` + case `struct` + + init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.actor): + self = .actor + case TokenSpec(.class): + self = .class + case TokenSpec(.enum): + self = .enum + case TokenSpec(.extension): + self = .extension + case TokenSpec(.protocol): + self = .protocol + case TokenSpec(.struct): + self = .struct + default: + return nil + } + } + + public init?(token: TokenSyntax) { + switch token { + case TokenSpec(.actor): + self = .actor + case TokenSpec(.class): + self = .class + case TokenSpec(.enum): + self = .enum + case TokenSpec(.extension): + self = .extension + case TokenSpec(.protocol): + self = .protocol + case TokenSpec(.struct): + self = .struct + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .actor: + return .keyword(.actor) + case .class: + return .keyword(.class) + case .enum: + return .keyword(.enum) + case .extension: + return .keyword(.extension) + case .protocol: + return .keyword(.protocol) + case .struct: + return .keyword(.struct) + } + } + + /// Returns a token that satisfies the `TokenSpec` of this case. + /// + /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text. + @_spi(Diagnostics) + public var tokenSyntax: TokenSyntax { + switch self { + case .actor: + return .keyword(.actor) + case .class: + return .keyword(.class) + case .enum: + return .keyword(.enum) + case .extension: + return .keyword(.extension) + case .protocol: + return .keyword(.protocol) + case .struct: + return .keyword(.struct) + } + } + } +} + extension DeclModifierSyntax { @_spi(Diagnostics) public enum NameOptions: TokenSpecSet { diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index 13030c5143e..6ce8dd76032 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -415,6 +415,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { let previousToken = node.previousToken(viewMode: .sourceAccurate), previousToken.tokenKind.isIdentifier, previousToken.parent?.is(DeclSyntax.self) == true + || previousToken.parent?.is(DeclGroupHeaderSyntax.self) == true || previousToken.parent?.is(IdentifierPatternSyntax.self) == true { // If multiple identifiers are used for a declaration name, offer to join them together. diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index 4006f445c54..feeeb2bc6cd 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -269,6 +269,8 @@ extension SyntaxKind { return "member type" case .metatypeType: return "metatype" + case .missingDeclHeader: + return "declaration group header" case .missingDecl: return "declaration" case .missingExpr: diff --git a/Sources/SwiftSyntax/CustomTraits.swift b/Sources/SwiftSyntax/CustomTraits.swift index f1daddf5722..9111462c609 100644 --- a/Sources/SwiftSyntax/CustomTraits.swift +++ b/Sources/SwiftSyntax/CustomTraits.swift @@ -54,6 +54,17 @@ extension ExtensionDeclSyntax { } } +extension MissingDeclHeaderSyntax { + public var introducer: TokenSyntax { + get { + return placeholder + } + set { + placeholder = newValue + } + } +} + extension ProtocolDeclSyntax { public var introducer: TokenSyntax { get { diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md index 10a71a658da..5cb22e1b2c7 100644 --- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md @@ -344,6 +344,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - @@ -361,6 +362,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index 31a6ac2cac5..c5ed1770f99 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -2225,6 +2225,28 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "metatypeSpecifier" case \MetatypeTypeSyntax.unexpectedAfterMetatypeSpecifier: return "unexpectedAfterMetatypeSpecifier" + case \MissingDeclHeaderSyntax.unexpectedBeforeAttributes: + return "unexpectedBeforeAttributes" + case \MissingDeclHeaderSyntax.attributes: + return "attributes" + case \MissingDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers: + return "unexpectedBetweenAttributesAndModifiers" + case \MissingDeclHeaderSyntax.modifiers: + return "modifiers" + case \MissingDeclHeaderSyntax.unexpectedBetweenModifiersAndPlaceholder: + return "unexpectedBetweenModifiersAndPlaceholder" + case \MissingDeclHeaderSyntax.placeholder: + return "placeholder" + case \MissingDeclHeaderSyntax.unexpectedBetweenPlaceholderAndInheritanceClause: + return "unexpectedBetweenPlaceholderAndInheritanceClause" + case \MissingDeclHeaderSyntax.inheritanceClause: + return "inheritanceClause" + case \MissingDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: + return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" + case \MissingDeclHeaderSyntax.genericWhereClause: + return "genericWhereClause" + case \MissingDeclHeaderSyntax.unexpectedAfterGenericWhereClause: + return "unexpectedAfterGenericWhereClause" case \MissingDeclSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" case \MissingDeclSyntax.attributes: diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 6b4a238d8cf..46d64fb2696 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -1464,6 +1464,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: MissingDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: MissingDeclHeaderSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: MissingDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index 4341ca1bc2f..bf1b9a45d7d 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -12,6 +12,366 @@ // //===----------------------------------------------------------------------===// +// MARK: - DeclGroupHeaderSyntax + +/// Protocol to which all ``DeclGroupHeaderSyntax`` nodes conform. +/// +/// Extension point to add common methods to all ``DeclGroupHeaderSyntax`` nodes. +/// +/// - Warning: Do not conform to this protocol yourself. +public protocol DeclGroupHeaderSyntaxProtocol: SyntaxProtocol { + var attributes: AttributeListSyntax { + get + set + } + + /// Modifiers like `public` that are attached to the actor declaration. + var modifiers: DeclModifierListSyntax { + get + set + } + + /// The token that introduces this declaration, eg. `class` for a class declaration. + /// + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds: + /// - `actor` + /// - `class` + /// - `enum` + /// - `extension` + /// - `protocol` + /// - `struct` + var introducer: TokenSyntax { + get + set + } + + var inheritanceClause: InheritanceClauseSyntax? { + get + set + } + + /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`. + var genericWhereClause: GenericWhereClauseSyntax? { + get + set + } +} + +/// Extension of ``DeclGroupHeaderSyntaxProtocol`` to provide casting methods. +/// +/// These methods enable casting between syntax node types within the same +/// base node protocol hierarchy (e.g., ``DeclSyntaxProtocol``). +/// +/// While ``SyntaxProtocol`` offers general casting methods (``SyntaxProtocol.as(_:)``, +/// ``SyntaxProtocol.is(_:)``, and ``SyntaxProtocol.cast(_:)``), these often aren't +/// appropriate for use on types conforming to a specific base node protocol +/// like ``DeclGroupHeaderSyntaxProtocol``. That's because at this level, +/// we know that the cast to another base node type (e.g., ``DeclSyntaxProtocol`` +/// when working with ``ExprSyntaxProtocol``) is guaranteed to fail. +/// +/// To guide developers toward correct usage, this extension provides overloads +/// of these casting methods that are restricted to the same base node type. +/// Furthermore, it marks the inherited casting methods from ``SyntaxProtocol`` as +/// deprecated, indicating that they will always fail when used in this context. +extension DeclGroupHeaderSyntaxProtocol { + /// Checks if the current syntax node can be cast to a given specialized syntax type. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: S.Type) -> Bool { + return self.as(syntaxType) != nil + } + + + /// Attempts to cast the current syntax node to a given specialized syntax type. + /// + /// - Returns: An instance of the specialized type, or `nil` if the cast fails. + public func `as`(_ syntaxType: S.Type) -> S? { + return S.init(self) + } + + + /// Force-casts the current syntax node to a given specialized syntax type. + /// + /// - Returns: An instance of the specialized type. + /// + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: S.Type) -> S { + return self.as(S.self)! + } + + + /// Checks if the current syntax node can be upcast to its base node type (``DeclGroupHeaderSyntax``). + /// + /// - Returns: `true` since the node can always be upcast to its base node. + @available(*, deprecated, message: "This cast will always succeed") + public func `is`(_ syntaxType: DeclGroupHeaderSyntax.Type) -> Bool { + return true + } + + + /// Attempts to upcast the current syntax node to its base node type (``DeclGroupHeaderSyntax``). + /// + /// - Returns: The base node created from the current syntax node, as the node can always be upcast to its base type. + @available(*, deprecated, message: "Use `DeclGroupHeaderSyntax.init` for upcasting") + public func `as`(_ syntaxType: DeclGroupHeaderSyntax.Type) -> DeclGroupHeaderSyntax? { + return DeclGroupHeaderSyntax(self) + } + + + /// Force-upcast the current syntax node to its base node type (``DeclGroupHeaderSyntax``). + /// + /// - Returns: The base node created from the current syntax node, as the node can always be upcast to its base type. + @available(*, deprecated, message: "Use `DeclGroupHeaderSyntax.init` for upcasting") + public func cast(_ syntaxType: DeclGroupHeaderSyntax.Type) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(self) + } + + + /// Checks if the current syntax node can be cast to a given node type from a base node protocol hierarchy other + /// than ``DeclGroupHeaderSyntaxProtocol``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + /// + /// - Note: In most cases, this is comparing a ``DeclGroupHeaderSyntaxProtocol`` to a node that is not a + /// ``DeclGroupHeaderSyntaxProtocol``, which will always fail. If the `syntaxType` argument is a generic type, + /// constrain it to ``DeclGroupHeaderSyntaxProtocol`` instead of ``SyntaxProtocol``. + @available(*, deprecated, message: "Type argument should be part of the 'DeclGroupHeaderSyntaxProtocol' hierarchy") + public func `is`(_ syntaxType: S.Type) -> Bool { + return self.as(syntaxType) != nil + } + + + /// Attempts to cast the current syntax node to a given node type from the a base node protocol hierarchy other than + /// ``DeclGroupHeaderSyntaxProtocol``. + /// + /// - Returns: An instance of the specialized type, or `nil` if the cast fails. + /// + /// - Note: In most cases, this is casting a ``DeclGroupHeaderSyntaxProtocol`` to a node that is not a + /// ``DeclGroupHeaderSyntaxProtocol``, which will always fail. If the `syntaxType` argument is a generic type, + /// constrain it to ``DeclGroupHeaderSyntaxProtocol`` instead of ``SyntaxProtocol``. + @available(*, deprecated, message: "Type argument should be part of the 'DeclGroupHeaderSyntaxProtocol' hierarchy") + public func `as`(_ syntaxType: S.Type) -> S? { + return S.init(self) + } + + + /// Force-casts the current syntax node to a given node type from a base node protocol hierarchy other than + /// ``DeclGroupHeaderSyntaxProtocol``. + /// + /// - Returns: An instance of the specialized type. + /// + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + /// + /// - Note: In most cases, this is casting a ``DeclGroupHeaderSyntaxProtocol`` to a node that is not a + /// ``DeclGroupHeaderSyntaxProtocol``, which will always fail. If the `syntaxType` argument is a generic type, + /// constrain it to ``DeclGroupHeaderSyntaxProtocol`` instead of ``SyntaxProtocol``. + @available(*, deprecated, message: "Type argument should be part of the 'DeclGroupHeaderSyntaxProtocol' hierarchy") + public func cast(_ syntaxType: S.Type) -> S { + return self.as(S.self)! + } +} + +extension Syntax { + /// Check whether the non-type erased version of this syntax node conforms to + /// DeclGroupHeaderSyntaxProtocol. + /// + /// - Note: This will incur an existential conversion. + public func isProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> Bool { + return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self) != nil + } + + /// Return the non-type erased version of this syntax node if it conforms to + /// DeclGroupHeaderSyntaxProtocol. Otherwise return nil. + /// + /// - Note: This will incur an existential conversion. + public func asProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> DeclGroupHeaderSyntaxProtocol? { + return self.asProtocol(SyntaxProtocol.self) as? DeclGroupHeaderSyntaxProtocol + } +} + +/// ### Subtypes +/// +/// - ``MissingDeclHeaderSyntax`` +public struct DeclGroupHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + /// Create a ``DeclGroupHeaderSyntax`` node from a specialized syntax node. + public init(_ syntax: __shared some DeclGroupHeaderSyntaxProtocol) { + // We know this cast is going to succeed. Go through init(_: SyntaxData) + // to do a sanity check and verify the kind matches in debug builds and get + // maximum performance in release builds. + self = Syntax(syntax).cast(Self.self) + } + + /// Create a ``DeclGroupHeaderSyntax`` node from a specialized optional syntax node. + public init?(_ syntax: __shared (some DeclGroupHeaderSyntaxProtocol)?) { + guard let syntax = syntax else { + return nil + } + self.init(syntax) + } + + public init(fromProtocol syntax: __shared DeclGroupHeaderSyntaxProtocol) { + // We know this cast is going to succeed. Go through init(_: SyntaxData) + // to do a sanity check and verify the kind matches in debug builds and get + // maximum performance in release builds. + self = Syntax(syntax).cast(Self.self) + } + + /// Create a ``DeclGroupHeaderSyntax`` node from a specialized optional syntax node. + public init?(fromProtocol syntax: __shared DeclGroupHeaderSyntaxProtocol?) { + guard let syntax = syntax else { + return nil + } + self.init(fromProtocol: syntax) + } + + public init?(_ node: __shared some SyntaxProtocol) { + switch node.raw.kind { + case .missingDeclHeader: + self._syntaxNode = node._syntaxNode + default: + return nil + } + } + + /// Syntax nodes always conform to `DeclGroupHeaderSyntaxProtocol`. This API is just + /// added for consistency. + /// + /// - Note: This will incur an existential conversion. + @available(*, deprecated, message: "Expression always evaluates to true") + public func isProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> Bool { + return true + } + + /// Return the non-type erased version of this syntax node. + /// + /// - Note: This will incur an existential conversion. + public func asProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> DeclGroupHeaderSyntaxProtocol { + return Syntax(self).asProtocol(DeclGroupHeaderSyntaxProtocol.self)! + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(MissingDeclHeaderSyntax.self)]) + } + + public var attributes: AttributeListSyntax { + get { + return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).attributes + } + set(value) { + var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self) + existentialCopy.attributes = value + self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy) + } + } + + /// Modifiers like `public` that are attached to the actor declaration. + public var modifiers: DeclModifierListSyntax { + get { + return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).modifiers + } + set(value) { + var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self) + existentialCopy.modifiers = value + self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy) + } + } + + /// The token that introduces this declaration, eg. `class` for a class declaration. + /// + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds: + /// - `actor` + /// - `class` + /// - `enum` + /// - `extension` + /// - `protocol` + /// - `struct` + public var introducer: TokenSyntax { + get { + return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).introducer + } + set(value) { + var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self) + existentialCopy.introducer = value + self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy) + } + } + + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).inheritanceClause + } + set(value) { + var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self) + existentialCopy.inheritanceClause = value + self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy) + } + } + + /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`. + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).genericWhereClause + } + set(value) { + var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self) + existentialCopy.genericWhereClause = value + self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy) + } + } +} + +/// 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 _LeafDeclGroupHeaderSyntaxNodeProtocol: DeclGroupHeaderSyntaxProtocol {} + +extension _LeafDeclGroupHeaderSyntaxNodeProtocol { + /// 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. + /// + /// - Note: This method overloads the general `is` method and is marked as deprecated to produce a warning, + /// informing the user that the cast will always fail. + @available(*, deprecated, message: "This cast will always fail") + public func `is`(_ syntaxType: S.Type) -> Bool { + return false + } + + + /// Attempts to cast the current leaf syntax node to a different specified type. + /// + /// - Returns: `nil` since the leaf node cannot be cast to a different specified type. + /// + /// - Note: This method overloads the general `as` method and is marked as deprecated to produce a warning, + /// informing the user that the cast will always fail. + @available(*, deprecated, message: "This cast will always fail") + public func `as`(_ syntaxType: S.Type) -> S? { + return nil + } + + + /// Force-casts the current leaf syntax node to a different specified type. + /// + /// - Returns: This method will always trigger a runtime crash and never return. + /// + /// - Note: This method overloads the general `cast` method and is marked as deprecated to produce a warning, + /// informing the user that the cast will always fail. + /// - Warning: Invoking this method will lead to a fatal error. + @available(*, deprecated, message: "This cast will always fail") + public func cast(_ syntaxType: S.Type) -> S { + fatalError("\(Self.self) cannot be cast to \(S.self)") + } +} + // MARK: - DeclSyntax /// Protocol to which all ``DeclSyntax`` nodes conform. @@ -1690,6 +2050,7 @@ extension Syntax { .node(MemberBlockSyntax.self), .node(MemberTypeSyntax.self), .node(MetatypeTypeSyntax.self), + .node(MissingDeclHeaderSyntax.self), .node(MissingDeclSyntax.self), .node(MissingExprSyntax.self), .node(MissingPatternSyntax.self), diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift index 096d0512165..6240a612ab1 100644 --- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift +++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift @@ -82,6 +82,7 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { /// - ``ClassDeclSyntax``.``ClassDeclSyntax/attributes`` /// - ``ClosureParameterSyntax``.``ClosureParameterSyntax/attributes`` /// - ``ClosureSignatureSyntax``.``ClosureSignatureSyntax/attributes`` +/// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/attributes`` /// - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/attributes`` /// - ``EditorPlaceholderDeclSyntax``.``EditorPlaceholderDeclSyntax/attributes`` /// - ``EnumCaseDeclSyntax``.``EnumCaseDeclSyntax/attributes`` @@ -95,6 +96,7 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { /// - ``InitializerDeclSyntax``.``InitializerDeclSyntax/attributes`` /// - ``MacroDeclSyntax``.``MacroDeclSyntax/attributes`` /// - ``MacroExpansionDeclSyntax``.``MacroExpansionDeclSyntax/attributes`` +/// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/attributes`` /// - ``MissingDeclSyntax``.``MissingDeclSyntax/attributes`` /// - ``PrecedenceGroupDeclSyntax``.``PrecedenceGroupDeclSyntax/attributes`` /// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/attributes`` @@ -426,6 +428,7 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/modifiers`` /// - ``ClassDeclSyntax``.``ClassDeclSyntax/modifiers`` /// - ``ClosureParameterSyntax``.``ClosureParameterSyntax/modifiers`` +/// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/modifiers`` /// - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/modifiers`` /// - ``EditorPlaceholderDeclSyntax``.``EditorPlaceholderDeclSyntax/modifiers`` /// - ``EnumCaseDeclSyntax``.``EnumCaseDeclSyntax/modifiers`` @@ -438,6 +441,7 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { /// - ``InitializerDeclSyntax``.``InitializerDeclSyntax/modifiers`` /// - ``MacroDeclSyntax``.``MacroDeclSyntax/modifiers`` /// - ``MacroExpansionDeclSyntax``.``MacroExpansionDeclSyntax/modifiers`` +/// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/modifiers`` /// - ``MissingDeclSyntax``.``MissingDeclSyntax/modifiers`` /// - ``PrecedenceGroupDeclSyntax``.``PrecedenceGroupDeclSyntax/modifiers`` /// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/modifiers`` diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index fef31916caa..fbd2638a217 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -200,6 +200,7 @@ public enum SyntaxEnum: Sendable { case memberBlock(MemberBlockSyntax) case memberType(MemberTypeSyntax) case metatypeType(MetatypeTypeSyntax) + case missingDeclHeader(MissingDeclHeaderSyntax) case missingDecl(MissingDeclSyntax) case missingExpr(MissingExprSyntax) case missingPattern(MissingPatternSyntax) @@ -667,6 +668,8 @@ extension Syntax { return .memberType(MemberTypeSyntax(self)!) case .metatypeType: return .metatypeType(MetatypeTypeSyntax(self)!) + case .missingDeclHeader: + return .missingDeclHeader(MissingDeclHeaderSyntax(self)!) case .missingDecl: return .missingDecl(MissingDeclSyntax(self)!) case .missingExpr: @@ -891,6 +894,23 @@ extension Syntax { } } +/// Enum to exhaustively switch over all different DeclGroupHeader syntax nodes. +public enum DeclGroupHeaderSyntaxEnum { + case missingDeclHeader(MissingDeclHeaderSyntax) +} + +extension DeclGroupHeaderSyntax { + /// Get an enum that can be used to exhaustively switch over all DeclGroupHeader syntax nodes. + public func `as`(_: DeclGroupHeaderSyntaxEnum.Type) -> DeclGroupHeaderSyntaxEnum { + switch raw.kind { + case .missingDeclHeader: + return .missingDeclHeader(MissingDeclHeaderSyntax(self)!) + default: + preconditionFailure("unknown DeclGroupHeader syntax kind") + } + } +} + /// Enum to exhaustively switch over all different Decl syntax nodes. public enum DeclSyntaxEnum { case accessorDecl(AccessorDeclSyntax) diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index e8efa17158f..a5e7c0a3a52 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -200,6 +200,7 @@ public enum SyntaxKind: Sendable { case memberBlock case memberType case metatypeType + case missingDeclHeader case missingDecl case missingExpr case missingPattern @@ -429,6 +430,8 @@ public enum SyntaxKind: Sendable { return true case .missingDecl: return true + case .missingDeclHeader: + return true case .missingExpr: return true case .missingPattern: @@ -792,6 +795,8 @@ public enum SyntaxKind: Sendable { return MemberTypeSyntax.self case .metatypeType: return MetatypeTypeSyntax.self + case .missingDeclHeader: + return MissingDeclHeaderSyntax.self case .missingDecl: return MissingDeclSyntax.self case .missingExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index ade68592503..a484df0190a 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -1329,6 +1329,13 @@ open class SyntaxRewriter { return TypeSyntax(visitChildren(node._syntaxNode).cast(MetatypeTypeSyntax.self)) } + /// Visit a ``MissingDeclHeaderSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MissingDeclHeaderSyntax) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(MissingDeclHeaderSyntax.self)) + } + /// Visit a ``MissingDeclSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2102,6 +2109,15 @@ open class SyntaxRewriter { return visitChildren(node._syntaxNode).cast(YieldedExpressionsClauseSyntax.self) } + /// Visit any DeclGroupHeaderSyntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + public func visit(_ node: DeclGroupHeaderSyntax) -> DeclGroupHeaderSyntax { + var node: Syntax = Syntax(node) + dispatchVisit(&node) + return node.cast(DeclGroupHeaderSyntax.self) + } + /// Visit any DeclSyntax node. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2883,6 +2899,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, MetatypeTypeSyntax.self, self.visit) } + case .missingDeclHeader: + return { + self.visitImpl(&$0, MissingDeclHeaderSyntax.self, self.visit) + } case .missingDecl: return { self.visitImpl(&$0, MissingDeclSyntax.self, self.visit) @@ -3679,6 +3699,8 @@ open class SyntaxRewriter { return visitImpl(&node, MemberTypeSyntax.self, visit) case .metatypeType: return visitImpl(&node, MetatypeTypeSyntax.self, visit) + case .missingDeclHeader: + return visitImpl(&node, MissingDeclHeaderSyntax.self, visit) case .missingDecl: return visitImpl(&node, MissingDeclSyntax.self, visit) case .missingExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index a541b00e77c..d91d41b47e5 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -711,6 +711,8 @@ extension CodeBlockSyntax: BracedSyntax, WithStatementsSyntax {} extension ConditionElementSyntax: WithTrailingCommaSyntax {} +extension DeclGroupHeaderSyntax: WithAttributesSyntax, WithModifiersSyntax {} + extension DeclModifierDetailSyntax: ParenthesizedSyntax {} extension DeclNameArgumentsSyntax: ParenthesizedSyntax {} @@ -787,6 +789,8 @@ extension MacroExpansionExprSyntax: FreestandingMacroExpansionSyntax {} extension MemberBlockSyntax: BracedSyntax {} +extension MissingDeclHeaderSyntax: MissingNodeSyntax, WithAttributesSyntax, WithModifiersSyntax {} + extension MissingDeclSyntax: MissingNodeSyntax, WithAttributesSyntax, WithModifiersSyntax {} extension MissingExprSyntax: MissingNodeSyntax {} diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index 67092f4ac60..6bd63289b51 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -2138,6 +2138,18 @@ open class SyntaxVisitor { open func visitPost(_ node: MetatypeTypeSyntax) { } + /// Visiting ``MissingDeclHeaderSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: MissingDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``MissingDeclHeaderSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: MissingDeclHeaderSyntax) { + } + /// Visiting ``MissingDeclSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -4227,6 +4239,10 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, MetatypeTypeSyntax.self, self.visit, self.visitPost) } + case .missingDeclHeader: + return { + self.visitImpl(&$0, MissingDeclHeaderSyntax.self, self.visit, self.visitPost) + } case .missingDecl: return { self.visitImpl(&$0, MissingDeclSyntax.self, self.visit, self.visitPost) @@ -5027,6 +5043,8 @@ open class SyntaxVisitor { visitImpl(&node, MemberTypeSyntax.self, visit, visitPost) case .metatypeType: visitImpl(&node, MetatypeTypeSyntax.self, visit, visitPost) + case .missingDeclHeader: + visitImpl(&node, MissingDeclHeaderSyntax.self, visit, visitPost) case .missingDecl: visitImpl(&node, MissingDeclSyntax.self, visit, visitPost) case .missingExpr: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift index 9f181d4a185..8929ca7569d 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift @@ -12,9 +12,51 @@ // //===----------------------------------------------------------------------===// +@_spi(RawSyntax) +public protocol RawDeclGroupHeaderSyntaxNodeProtocol: RawSyntaxNodeProtocol {} + @_spi(RawSyntax) public protocol RawDeclSyntaxNodeProtocol: RawSyntaxNodeProtocol {} +@_spi(RawSyntax) +public struct RawDeclGroupHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + switch raw.kind { + case .missingDeclHeader: + return true + default: + return false + } + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init(_ other: some RawDeclGroupHeaderSyntaxNodeProtocol) { + self.init(unchecked: other.raw) + } +} + @_spi(RawSyntax) public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift index ea8497a3da5..2e5f92bfb14 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift @@ -2158,6 +2158,112 @@ public struct RawMetatypeTypeSyntax: RawTypeSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawMissingDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .missingDeclHeader + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawDeclModifierListSyntax, + _ unexpectedBetweenModifiersAndPlaceholder: RawUnexpectedNodesSyntax? = nil, + placeholder: RawTokenSyntax, + _ unexpectedBetweenPlaceholderAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, + inheritanceClause: RawInheritanceClauseSyntax?, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + genericWhereClause: RawGenericWhereClauseSyntax?, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .missingDeclHeader, uninitializedCount: 11, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers.raw + layout[4] = unexpectedBetweenModifiersAndPlaceholder?.raw + layout[5] = placeholder.raw + layout[6] = unexpectedBetweenPlaceholderAndInheritanceClause?.raw + layout[7] = inheritanceClause?.raw + layout[8] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw + layout[9] = genericWhereClause?.raw + layout[10] = unexpectedAfterGenericWhereClause?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var attributes: RawAttributeListSyntax { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:))! + } + + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var modifiers: RawDeclModifierListSyntax { + layoutView.children[3].map(RawDeclModifierListSyntax.init(raw:))! + } + + public var unexpectedBetweenModifiersAndPlaceholder: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var placeholder: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenPlaceholderAndInheritanceClause: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var inheritanceClause: RawInheritanceClauseSyntax? { + layoutView.children[7].map(RawInheritanceClauseSyntax.init(raw:)) + } + + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var genericWhereClause: RawGenericWhereClauseSyntax? { + layoutView.children[9].map(RawGenericWhereClauseSyntax.init(raw:)) + } + + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawMissingDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index a5430c16f4a..166a32ae78f 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -1858,6 +1858,19 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.keyword("Type"), .keyword("Protocol")])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + case .missingDeclHeader: + assert(layout.count == 11) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawDeclModifierListSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawInheritanceClauseSyntax?.self)) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 9, verify(layout[9], as: RawGenericWhereClauseSyntax?.self)) + assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) case .missingDecl: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift index 435fb46b38d..a1ca4fa7d77 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift @@ -1139,6 +1139,7 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl /// - ``ActorDeclSyntax``.``ActorDeclSyntax/genericWhereClause`` /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/genericWhereClause`` /// - ``ClassDeclSyntax``.``ClassDeclSyntax/genericWhereClause`` +/// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/genericWhereClause`` /// - ``DifferentiableAttributeArgumentsSyntax``.``DifferentiableAttributeArgumentsSyntax/genericWhereClause`` /// - ``EnumDeclSyntax``.``EnumDeclSyntax/genericWhereClause`` /// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/genericWhereClause`` @@ -1146,6 +1147,7 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl /// - ``GenericParameterClauseSyntax``.``GenericParameterClauseSyntax/genericWhereClause`` /// - ``InitializerDeclSyntax``.``InitializerDeclSyntax/genericWhereClause`` /// - ``MacroDeclSyntax``.``MacroDeclSyntax/genericWhereClause`` +/// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/genericWhereClause`` /// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/genericWhereClause`` /// - ``SpecializeAttributeArgumentListSyntax`` /// - ``StructDeclSyntax``.``StructDeclSyntax/genericWhereClause`` @@ -3430,8 +3432,10 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf /// - ``ActorDeclSyntax``.``ActorDeclSyntax/inheritanceClause`` /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/inheritanceClause`` /// - ``ClassDeclSyntax``.``ClassDeclSyntax/inheritanceClause`` +/// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/inheritanceClause`` /// - ``EnumDeclSyntax``.``EnumDeclSyntax/inheritanceClause`` /// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/inheritanceClause`` +/// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/inheritanceClause`` /// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/inheritanceClause`` /// - ``StructDeclSyntax``.``StructDeclSyntax/inheritanceClause`` public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift index 9f48aab9adf..619ba52ef5f 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift @@ -4050,6 +4050,266 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS ]) } +// MARK: - MissingDeclHeaderSyntax + +/// In case the source code is missing a declaration group header, this node stands in place of the missing header. +/// +/// ### Children +/// +/// - `attributes`: ``AttributeListSyntax`` +/// - `modifiers`: ``DeclModifierListSyntax`` +/// - `placeholder`: `` +/// - `inheritanceClause`: ``InheritanceClauseSyntax``? +/// - `genericWhereClause`: ``GenericWhereClauseSyntax``? +public struct MissingDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .missingDeclHeader else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - attributes: If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these. + /// - modifiers: If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these. + /// - placeholder: A placeholder, i.e. `<#decl#>`, that can be inserted into the source code to represent the missing declaration. + /// - genericWhereClause: A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + _ unexpectedBetweenModifiersAndPlaceholder: UnexpectedNodesSyntax? = nil, + placeholder: TokenSyntax, + _ unexpectedBetweenPlaceholderAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeAttributes, + attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers, + unexpectedBetweenModifiersAndPlaceholder, + placeholder, + unexpectedBetweenPlaceholderAndInheritanceClause, + inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause, + unexpectedAfterGenericWhereClause + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeAttributes?.raw, + attributes.raw, + unexpectedBetweenAttributesAndModifiers?.raw, + modifiers.raw, + unexpectedBetweenModifiersAndPlaceholder?.raw, + placeholder.raw, + unexpectedBetweenPlaceholderAndInheritanceClause?.raw, + inheritanceClause?.raw, + unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, + genericWhereClause?.raw, + unexpectedAfterGenericWhereClause?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.missingDeclHeader, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + /// If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these. + public var attributes: AttributeListSyntax { + get { + return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + /// Adds the provided `element` to the node's `attributes` + /// collection. + /// + /// - param element: The new `Attribute` to add to the node's + /// `attributes` collection. + /// - returns: A copy of the receiver with the provided `Attribute` + /// appended to its `attributes` collection. + @available(*, deprecated, message: "Use node.attributes.append(newElement) instead") + public func addAttribute(_ element: Syntax) -> MissingDeclHeaderSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[1] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) + } + return Syntax(self) + .replacingChild( + at: 1, + with: collection, + rawNodeArena: arena, + allocationArena: arena + ) + .cast(MissingDeclHeaderSyntax.self) + } + + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + /// If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these. + public var modifiers: DeclModifierListSyntax { + get { + return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + /// Adds the provided `element` to the node's `modifiers` + /// collection. + /// + /// - param element: The new `Modifier` to add to the node's + /// `modifiers` collection. + /// - returns: A copy of the receiver with the provided `Modifier` + /// appended to its `modifiers` collection. + @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead") + public func addModifier(_ element: DeclModifierSyntax) -> MissingDeclHeaderSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, + from: [element.raw], arena: arena) + } + return Syntax(self) + .replacingChild( + at: 3, + with: collection, + rawNodeArena: arena, + allocationArena: arena + ) + .cast(MissingDeclHeaderSyntax.self) + } + + public var unexpectedBetweenModifiersAndPlaceholder: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + /// A placeholder, i.e. `<#decl#>`, that can be inserted into the source code to represent the missing declaration. + /// + /// This token should always have `presence = .missing`. + /// + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be ``. + public var placeholder: TokenSyntax { + get { + return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + public var unexpectedBetweenPlaceholderAndInheritanceClause: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return Syntax(self).child(at: 7)?.cast(InheritanceClauseSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`. + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return Syntax(self).child(at: 9)?.cast(GenericWhereClauseSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndModifiers, + \Self.modifiers, + \Self.unexpectedBetweenModifiersAndPlaceholder, + \Self.placeholder, + \Self.unexpectedBetweenPlaceholderAndInheritanceClause, + \Self.inheritanceClause, + \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, + \Self.genericWhereClause, + \Self.unexpectedAfterGenericWhereClause + ]) +} + // MARK: - MissingDeclSyntax /// In case the source code is missing a declaration, this node stands in place of the missing declaration. diff --git a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift index 0db493dbdf4..5452d63eb0e 100644 --- a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift +++ b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift @@ -60,6 +60,12 @@ extension CodeBlockSyntax: SyntaxExpressibleByStringInterpolation {} extension CodeBlockSyntax: Swift.ExpressibleByStringInterpolation {} #endif +extension DeclGroupHeaderSyntax: SyntaxExpressibleByStringInterpolation {} + +#if compiler(>=6) +extension DeclGroupHeaderSyntax: Swift.ExpressibleByStringInterpolation {} +#endif + extension DeclSyntax: SyntaxExpressibleByStringInterpolation {} #if compiler(>=6) From 2c57e11900c51ef9baed2e78b5f14cbc9ba07b5e Mon Sep 17 00:00:00 2001 From: Becca Royal-Gordon Date: Mon, 4 Nov 2024 18:21:47 -0800 Subject: [PATCH 3/7] [NFC] Refactor DeclarationKeyword It actually ought to be the union of three token kind subsets; turn it into a custom type so we can do that. --- Sources/SwiftParser/Declarations.swift | 50 ++++----- Sources/SwiftParser/TokenSpecSet.swift | 150 ++++++++++++++----------- 2 files changed, 110 insertions(+), 90 deletions(-) diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index 3aa8dc75ec4..c4ddb0a467b 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -110,7 +110,7 @@ extension TokenConsumer { declStartKeyword = subparser.at(anyIn: DeclarationKeyword.self)?.0 } switch declStartKeyword { - case .lhs(.actor): + case .group(.actor): // actor Foo {} if subparser.peek().rawTokenKind == .identifier { return true @@ -123,16 +123,16 @@ extension TokenConsumer { lookahead.consumeAnyToken() } while lookahead.atStartOfDeclaration(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl) return lookahead.at(.identifier) - case .lhs(.case): + case .simple(.case): // When 'case' appears inside a function, it's probably a switch // case, not an enum case declaration. return false - case .lhs(.`init`): + case .simple(.`init`): return allowInitDecl - case .lhs(.macro): + case .simple(.macro): // macro Foo ... return subparser.peek().rawTokenKind == .identifier - case .lhs(.pound): + case .simple(.pound): // Force parsing '#' after attributes as a macro expansion decl. if hasAttribute || hasModifier { return true @@ -215,7 +215,7 @@ extension Parser { } else if atFunctionDeclarationWithoutFuncKeyword() { // We aren't at a declaration keyword and it looks like we are at a function // declaration. Parse a function declaration. - recoveryResult = (.lhs(.func), .missing(.keyword(.func))) + recoveryResult = (.simple(.func), .missing(.keyword(.func))) } else { // In all other cases, use standard token recovery to find the declaration // to parse. @@ -226,53 +226,53 @@ extension Parser { } switch recoveryResult { - case (.lhs(.import), let handle)?: + case (.simple(.import), let handle)?: return RawDeclSyntax(self.parseImportDeclaration(attrs, handle)) - case (.lhs(.class), let handle)?: + case (.group(.class), let handle)?: return RawDeclSyntax( self.parseNominalTypeDeclaration(for: RawClassDeclSyntax.self, attrs: attrs, introucerHandle: handle) ) - case (.lhs(.enum), let handle)?: + case (.group(.enum), let handle)?: return RawDeclSyntax( self.parseNominalTypeDeclaration(for: RawEnumDeclSyntax.self, attrs: attrs, introucerHandle: handle) ) - case (.lhs(.case), let handle)?: + case (.simple(.case), let handle)?: return RawDeclSyntax(self.parseEnumCaseDeclaration(attrs, handle)) - case (.lhs(.struct), let handle)?: + case (.group(.struct), let handle)?: return RawDeclSyntax( self.parseNominalTypeDeclaration(for: RawStructDeclSyntax.self, attrs: attrs, introucerHandle: handle) ) - case (.lhs(.protocol), let handle)?: + case (.group(.protocol), let handle)?: return RawDeclSyntax( self.parseNominalTypeDeclaration(for: RawProtocolDeclSyntax.self, attrs: attrs, introucerHandle: handle) ) - case (.lhs(.associatedtype), let handle)?: + case (.simple(.associatedtype), let handle)?: return RawDeclSyntax(self.parseAssociatedTypeDeclaration(attrs, handle)) - case (.lhs(.typealias), let handle)?: + case (.simple(.typealias), let handle)?: return RawDeclSyntax(self.parseTypealiasDeclaration(attrs, handle)) - case (.lhs(.extension), let handle)?: + case (.group(.extension), let handle)?: return RawDeclSyntax(self.parseExtensionDeclaration(attrs, handle)) - case (.lhs(.func), let handle)?: + case (.simple(.func), let handle)?: return RawDeclSyntax(self.parseFuncDeclaration(attrs, handle)) - case (.lhs(.subscript), let handle)?: + case (.simple(.subscript), let handle)?: return RawDeclSyntax(self.parseSubscriptDeclaration(attrs, handle)) - case (.lhs(.`init`), let handle)?: + case (.simple(.`init`), let handle)?: return RawDeclSyntax(self.parseInitializerDeclaration(attrs, handle)) - case (.lhs(.deinit), let handle)?: + case (.simple(.deinit), let handle)?: return RawDeclSyntax(self.parseDeinitializerDeclaration(attrs, handle)) - case (.lhs(.operator), let handle)?: + case (.simple(.operator), let handle)?: return RawDeclSyntax(self.parseOperatorDeclaration(attrs, handle)) - case (.lhs(.precedencegroup), let handle)?: + case (.simple(.precedencegroup), let handle)?: return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs, handle)) - case (.lhs(.actor), let handle)?: + case (.group(.actor), let handle)?: return RawDeclSyntax( self.parseNominalTypeDeclaration(for: RawActorDeclSyntax.self, attrs: attrs, introucerHandle: handle) ) - case (.lhs(.macro), let handle)?: + case (.simple(.macro), let handle)?: return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle)) - case (.lhs(.pound), let handle)?: + case (.simple(.pound), let handle)?: return RawDeclSyntax(self.parseMacroExpansionDeclaration(attrs, handle)) - case (.rhs, let handle)?: + case (.binding, let handle)?: return RawDeclSyntax(self.parseBindingDeclaration(attrs, handle, inMemberDeclList: inMemberDeclList)) case nil: break diff --git a/Sources/SwiftParser/TokenSpecSet.swift b/Sources/SwiftParser/TokenSpecSet.swift index e2b46112829..8402d624ec1 100644 --- a/Sources/SwiftParser/TokenSpecSet.swift +++ b/Sources/SwiftParser/TokenSpecSet.swift @@ -267,82 +267,102 @@ enum ContextualDeclKeyword: TokenSpecSet { } } -/// A `DeclarationKeyword` that is not a `ValueBindingPatternSyntax.BindingSpecifierOptions`. -/// -/// `ValueBindingPatternSyntax.BindingSpecifierOptions` are injected into -/// `DeclarationKeyword` via an `EitherTokenSpecSet`. -enum PureDeclarationKeyword: TokenSpecSet { - case actor - case `associatedtype` - case `case` - case `class` - case `deinit` - case `enum` - case `extension` - case `func` - case `import` - case `init` - case macro - case `operator` - case `precedencegroup` - case `protocol` - case `struct` - case `subscript` - case `typealias` - case pound +/// Union of the following token kind subsets: +/// - `ValueBindingPatternSyntax.BindingSpecifierOptions` +/// - `DeclGroupHeaderSyntax.IntroducerOptions` +/// - `DeclarationKeyword.Simple` (containing other declaration keywords) +enum DeclarationKeyword: TokenSpecSet { + /// A keyword introducing a binding declaration (a declaration which binds patterns to values). + case binding(Binding) + + /// A keyword introducing a declaration group (a declaration with a member block). + case group(Group) + + /// A keyword introducing a simple declaration (a declaration which is neither a group nor a binding). + case simple(Simple) init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(.actor): self = .actor - case TokenSpec(.macro): self = .macro - case TokenSpec(.associatedtype): self = .associatedtype - case TokenSpec(.case): self = .case - case TokenSpec(.class): self = .class - case TokenSpec(.deinit): self = .deinit - case TokenSpec(.enum): self = .enum - case TokenSpec(.extension): self = .extension - case TokenSpec(.func): self = .func - case TokenSpec(.import): self = .import - case TokenSpec(.`init`): self = .`init` - case TokenSpec(.operator): self = .operator - case TokenSpec(.precedencegroup): self = .precedencegroup - case TokenSpec(.protocol): self = .protocol - case TokenSpec(.struct): self = .struct - case TokenSpec(.subscript): self = .subscript - case TokenSpec(.typealias): self = .typealias - case TokenSpec(.pound): self = .pound - default: return nil + if let simple = Simple(lexeme: lexeme, experimentalFeatures: experimentalFeatures) { + self = .simple(simple) + } else if let group = Group(lexeme: lexeme, experimentalFeatures: experimentalFeatures) { + self = .group(group) + } else if let binding = Binding(lexeme: lexeme, experimentalFeatures: experimentalFeatures) { + self = .binding(binding) + } else { + return nil } } var spec: TokenSpec { switch self { - case .actor: return TokenSpec(.actor, recoveryPrecedence: .declKeyword) - case .associatedtype: return .keyword(.associatedtype) - case .case: return TokenSpec(.case, recoveryPrecedence: .declKeyword) - case .class: return .keyword(.class) - case .deinit: return .keyword(.deinit) - case .enum: return .keyword(.enum) - case .extension: return .keyword(.extension) - case .func: return .keyword(.func) - case .import: return .keyword(.import) - case .`init`: return .keyword(.`init`) - case .macro: return TokenSpec(.macro, recoveryPrecedence: .declKeyword) - case .operator: return .keyword(.operator) - case .precedencegroup: return .keyword(.precedencegroup) - case .protocol: return .keyword(.protocol) - case .struct: return .keyword(.struct) - case .subscript: return .keyword(.subscript) - case .typealias: return .keyword(.typealias) - case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf) + case .simple(let simple): return simple.spec + case .group(let group): return group.spec + case .binding(let binding): return binding.spec } } + + static let allCases: [DeclarationKeyword] = + Binding.allCases.map { .binding($0) } + Group.allCases.map { .group($0) } + Simple.allCases.map { .simple($0) } } -typealias DeclarationKeyword = EitherTokenSpecSet< - PureDeclarationKeyword, - ValueBindingPatternSyntax.BindingSpecifierOptions -> +extension DeclarationKeyword { + /// Type for a keyword introducing a binding declaration (a declaration which binds patterns to values). + typealias Binding = ValueBindingPatternSyntax.BindingSpecifierOptions + + /// Type for a keyword introducing a declaration group (a declaration with a member block). + typealias Group = DeclGroupHeaderSyntax.IntroducerOptions + + /// Type for a keyword introducing a simple declaration (a declaration which is neither a group nor a binding). + enum Simple: TokenSpecSet { + case `associatedtype` + case `case` + case `deinit` + case `func` + case `import` + case `init` + case macro + case `operator` + case `precedencegroup` + case `subscript` + case `typealias` + case pound + + init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.macro): self = .macro + case TokenSpec(.associatedtype): self = .associatedtype + case TokenSpec(.case): self = .case + case TokenSpec(.deinit): self = .deinit + case TokenSpec(.func): self = .func + case TokenSpec(.import): self = .import + case TokenSpec(.`init`): self = .`init` + case TokenSpec(.operator): self = .operator + case TokenSpec(.precedencegroup): self = .precedencegroup + case TokenSpec(.subscript): self = .subscript + case TokenSpec(.typealias): self = .typealias + case TokenSpec(.pound): self = .pound + default: return nil + } + } + + var spec: TokenSpec { + switch self { + case .associatedtype: return .keyword(.associatedtype) + case .case: return TokenSpec(.case, recoveryPrecedence: .declKeyword) + case .deinit: return .keyword(.deinit) + case .func: return .keyword(.func) + case .import: return .keyword(.import) + case .`init`: return .keyword(.`init`) + case .macro: return TokenSpec(.macro, recoveryPrecedence: .declKeyword) + case .operator: return .keyword(.operator) + case .precedencegroup: return .keyword(.precedencegroup) + case .subscript: return .keyword(.subscript) + case .typealias: return .keyword(.typealias) + case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf) + } + } + } +} enum DeclarationModifier: TokenSpecSet { case __consuming From c335d65b56a9aa579cdee5896bf8a2950bd1019a Mon Sep 17 00:00:00 2001 From: Becca Royal-Gordon Date: Wed, 30 Oct 2024 19:26:58 -0700 Subject: [PATCH 4/7] Extract header nodes from DeclGroups MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This also involves changing Child.Refactoring to support a new kind of change: “extracted”, in which a group of adjacent children are moved into a new child node. Future commits will introduce clients that use the new *DeclHeaderSyntax nodes directly. --- .../Sources/SyntaxSupport/DeclNodes.swift | 379 +++- .../SyntaxSupport/SyntaxNodeKind.swift | 6 + .../Sources/SyntaxSupport/Traits.swift | 30 +- .../ValidateSyntaxNodes.swift | 2 +- Sources/SwiftParser/Declarations.swift | 193 +- Sources/SwiftParser/Nominals.swift | 127 +- .../generated/ChildNameForDiagnostics.swift | 58 +- .../SyntaxKindNameForDiagnostics.swift | 12 + Sources/SwiftSyntax/CustomTraits.swift | 78 +- .../generated/SwiftSyntax.md | 7 + .../generated/ChildNameForKeyPath.swift | 224 ++- .../RenamedChildrenCompatibility.swift | 1574 +++++++++++++++-- .../generated/SyntaxAnyVisitor.swift | 48 + .../generated/SyntaxBaseNodes.swift | 23 +- .../generated/SyntaxCollections.swift | 24 +- .../SwiftSyntax/generated/SyntaxEnum.swift | 36 + .../SwiftSyntax/generated/SyntaxKind.swift | 18 + .../generated/SyntaxRewriter.swift | 78 + .../SwiftSyntax/generated/SyntaxTraits.swift | 86 +- .../SwiftSyntax/generated/SyntaxVisitor.swift | 108 ++ .../generated/raw/RawSyntaxNodesAB.swift | 82 +- .../generated/raw/RawSyntaxNodesC.swift | 82 +- .../generated/raw/RawSyntaxNodesD.swift | 2 +- .../generated/raw/RawSyntaxNodesEF.swift | 164 +- .../generated/raw/RawSyntaxNodesOP.swift | 82 +- .../generated/raw/RawSyntaxNodesQRS.swift | 82 +- .../generated/raw/RawSyntaxValidation.swift | 78 +- .../generated/syntaxNodes/SyntaxNodesAB.swift | 194 +- .../generated/syntaxNodes/SyntaxNodesC.swift | 242 ++- .../generated/syntaxNodes/SyntaxNodesEF.swift | 408 +++-- .../syntaxNodes/SyntaxNodesGHI.swift | 32 +- .../generated/syntaxNodes/SyntaxNodesOP.swift | 216 ++- .../syntaxNodes/SyntaxNodesQRS.swift | 305 +++- .../generated/BuildableNodes.swift | 212 +-- .../RenamedChildrenBuilderCompatibility.swift | 300 +++- Tests/SwiftSyntaxTest/RawSyntaxTests.swift | 10 +- 36 files changed, 4372 insertions(+), 1230 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift index 0dea2d63426..46c58ca3b4c 100644 --- a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift @@ -179,12 +179,11 @@ public let DECL_NODES: [Node] = [ ), Node( - kind: .actorDecl, - base: .decl, + kind: .actorDeclHeader, + base: .declGroupHeader, nameForDiagnostics: "actor", traits: [ - "DeclGroup", - "NamedDecl", + "NamedDeclHeader", "WithAttributes", "WithGenericParameters", "WithModifiers", @@ -232,15 +231,38 @@ public let DECL_NODES: [Node] = [ "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.", isOptional: true ), + ] + ), + + Node( + kind: .actorDecl, + base: .decl, + nameForDiagnostics: "actor", + traits: [ + "DeclGroup", + "NamedDecl", + "WithAttributes", + "WithGenericParameters", + "WithModifiers", + ], + children: [ + Child( + name: "actorHeader", + kind: .node(kind: .actorDeclHeader), + documentation: "The header of the actor declaration." + ), Child( name: "memberBlock", kind: .node(kind: .memberBlock) ), ], childHistory: [ + [ + "actorHeader": .extracted + ], [ "name": .renamed(from: "identifier") - ] + ], ] ), @@ -333,37 +355,20 @@ public let DECL_NODES: [Node] = [ ), Node( - kind: .classDecl, - base: .decl, + kind: .classDeclHeader, + base: .declGroupHeader, nameForDiagnostics: "class", documentation: """ - A `class` declaration + A `class` declaration header - An example of a class declaration is + An example of a class declaration header is ```swift - class SomeClass { - let someMember: String - - init(someMember: String) { - self.someMember = someMember - } - - func foo() { - print(someMember) - } - - static func bar() -> Int { - return 1 - } - } + class SomeClass ``` - - A class declaration may be declared without any members. """, traits: [ - "DeclGroup", - "NamedDecl", + "NamedDeclHeader", "WithAttributes", "WithGenericParameters", "WithModifiers", @@ -412,6 +417,51 @@ public let DECL_NODES: [Node] = [ documentation: "The `where` clause that applies to the generic parameters of this class declaration.", isOptional: true ), + ] + ), + + Node( + kind: .classDecl, + base: .decl, + nameForDiagnostics: "class", + documentation: """ + A `class` declaration + + An example of a class declaration is + + ```swift + class SomeClass { + let someMember: String + + init(someMember: String) { + self.someMember = someMember + } + + func foo() { + print(someMember) + } + + static func bar() -> Int { + return 1 + } + } + ``` + + A class declaration may be declared without any members. + """, + traits: [ + "DeclGroup", + "NamedDecl", + "WithAttributes", + "WithGenericParameters", + "WithModifiers", + ], + children: [ + Child( + name: "classHeader", + kind: .node(kind: .classDeclHeader), + documentation: "The header of the class declaration." + ), Child( name: "memberBlock", kind: .node(kind: .memberBlock), @@ -420,9 +470,12 @@ public let DECL_NODES: [Node] = [ ), ], childHistory: [ + [ + "classHeader": .extracted + ], [ "name": .renamed(from: "identifier") - ] + ], ] ), @@ -801,13 +854,12 @@ public let DECL_NODES: [Node] = [ ), Node( - kind: .enumDecl, - base: .decl, + kind: .enumDeclHeader, + base: .declGroupHeader, nameForDiagnostics: "enum", - documentation: "A Swift `enum` declaration.", + documentation: "A Swift `enum` declaration header.", traits: [ - "DeclGroup", - "NamedDecl", + "NamedDeclHeader", "WithAttributes", "WithGenericParameters", "WithModifiers", @@ -857,6 +909,27 @@ public let DECL_NODES: [Node] = [ documentation: "The `where` clause that applies to the generic parameters of this enum declaration.", isOptional: true ), + ] + ), + + Node( + kind: .enumDecl, + base: .decl, + nameForDiagnostics: "enum", + documentation: "A Swift `enum` declaration.", + traits: [ + "DeclGroup", + "NamedDecl", + "WithAttributes", + "WithGenericParameters", + "WithModifiers", + ], + children: [ + Child( + name: "enumHeader", + kind: .node(kind: .enumDeclHeader), + documentation: "The header of the enum declaration." + ), Child( name: "memberBlock", kind: .node(kind: .memberBlock), @@ -865,32 +938,30 @@ public let DECL_NODES: [Node] = [ ), ], childHistory: [ + [ + "enumHeader": .extracted + ], [ "name": .renamed(from: "identifier"), "genericParameterClause": .renamed(from: "genericParameters"), - ] + ], ] ), Node( - kind: .extensionDecl, - base: .decl, + kind: .extensionDeclHeader, + base: .declGroupHeader, nameForDiagnostics: "extension", documentation: """ - An `extension` declaration. + An `extension` declaration header. ### Example ```swift - extension String { - var url: URL? { - URL(string: self) - } - } + extension String ``` """, traits: [ - "DeclGroup", "WithAttributes", "WithModifiers", ], @@ -942,12 +1013,48 @@ public let DECL_NODES: [Node] = [ "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.", isOptional: true ), + ] + ), + + Node( + kind: .extensionDecl, + base: .decl, + nameForDiagnostics: "extension", + documentation: """ + An `extension` declaration. + + ### Example + + ```swift + extension String { + var url: URL? { + URL(string: self) + } + } + ``` + """, + traits: [ + "DeclGroup", + "WithAttributes", + "WithModifiers", + ], + children: [ + Child( + name: "extensionHeader", + kind: .node(kind: .extensionDeclHeader), + documentation: "The header of the extension declaration." + ), Child( name: "memberBlock", kind: .node(kind: .memberBlock), documentation: "The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type." ), + ], + childHistory: [ + [ + "extensionHeader": .extracted + ] ] ), @@ -2047,23 +2154,20 @@ public let DECL_NODES: [Node] = [ ), Node( - kind: .protocolDecl, - base: .decl, + kind: .protocolDeclHeader, + base: .declGroupHeader, nameForDiagnostics: "protocol", documentation: """ - A `protocol` declaration + A `protocol` declaration header - An example of a protocol declaration is + An example of a protocol declaration header is ```swift - protocol Example { - var isValid: Bool { get } - } + protocol Example ``` """, traits: [ - "DeclGroup", - "NamedDecl", + "NamedDeclHeader", "WithAttributes", "WithModifiers", ], @@ -2111,6 +2215,36 @@ public let DECL_NODES: [Node] = [ documentation: "The `where` clause that applies to the generic parameters of this protocol declaration.", isOptional: true ), + ] + ), + + Node( + kind: .protocolDecl, + base: .decl, + nameForDiagnostics: "protocol", + documentation: """ + A `protocol` declaration + + An example of a protocol declaration is + + ```swift + protocol Example { + var isValid: Bool { get } + } + ``` + """, + traits: [ + "DeclGroup", + "NamedDecl", + "WithAttributes", + "WithModifiers", + ], + children: [ + Child( + name: "protocolHeader", + kind: .node(kind: .protocolDeclHeader), + documentation: "The header of the protocol." + ), Child( name: "memberBlock", kind: .node(kind: .memberBlock), @@ -2118,9 +2252,12 @@ public let DECL_NODES: [Node] = [ ), ], childHistory: [ + [ + "protocolHeader": .extracted + ], [ "name": .renamed(from: "identifier") - ] + ], ] ), @@ -2177,6 +2314,89 @@ public let DECL_NODES: [Node] = [ ] ), + Node( + kind: .structDeclHeader, + base: .declGroupHeader, + nameForDiagnostics: "struct", + documentation: """ + A `struct` declaration header + + An example of a struct declaration header is + + ```swift + struct SomeStruct + ``` + + A struct declaration may include a type inheritance clause listing + one or more protocols the struct conforms to. The example below uses + Hashable and Equatable protocols. + + ```swift + struct AdvancedStruct: Hashable, Equatable + ``` + + A struct declaration may include a generic parameter clause as well + as a generic where clause. + + ```swift + struct Stack + ``` + """, + traits: [ + "NamedDeclHeader", + "WithAttributes", + "WithGenericParameters", + "WithModifiers", + ], + children: [ + Child( + name: "attributes", + kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true), + nameForDiagnostics: "attributes", + documentation: "Attributes that are attached to the struct declaration." + ), + Child( + name: "modifiers", + kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true), + nameForDiagnostics: "modifiers", + documentation: "Modifiers like `public` that are attached to the struct declaration." + ), + Child( + name: "structKeyword", + kind: .token(choices: [.keyword(.struct)]), + documentation: "The `struct` keyword for this declaration." + ), + Child( + name: "name", + kind: .token(choices: [.token(.identifier)]), + documentation: + "Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it." + ), + Child( + name: "genericParameterClause", + kind: .node(kind: .genericParameterClause), + nameForDiagnostics: "generic parameter clause", + documentation: "The generic parameters, if any, of the struct declaration.", + isOptional: true + ), + Child( + name: "inheritanceClause", + kind: .node(kind: .inheritanceClause), + nameForDiagnostics: "inheritance clause", + documentation: + "The struct declaration inheritance clause describing one or more conformances for this struct declaration.", + isOptional: true + ), + Child( + name: "genericWhereClause", + kind: .node(kind: .genericWhereClause), + nameForDiagnostics: "generic where clause", + documentation: "The `where` clause that applies to the generic parameters of this struct declaration.", + isOptional: true + ), + ] + ), + Node( kind: .structDecl, base: .decl, @@ -2249,61 +2469,24 @@ public let DECL_NODES: [Node] = [ ], children: [ Child( - name: "attributes", - kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true), - nameForDiagnostics: "attributes", - documentation: "Attributes that are attached to the struct declaration." - ), - Child( - name: "modifiers", - kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true), - nameForDiagnostics: "modifiers", - documentation: "Modifiers like `public` that are attached to the struct declaration." - ), - Child( - name: "structKeyword", - kind: .token(choices: [.keyword(.struct)]), - documentation: "The `struct` keyword for this declaration." - ), - Child( - name: "name", - kind: .token(choices: [.token(.identifier)]), + name: "structHeader", + kind: .node(kind: .structDeclHeader), documentation: "Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it." ), - Child( - name: "genericParameterClause", - kind: .node(kind: .genericParameterClause), - nameForDiagnostics: "generic parameter clause", - documentation: "The generic parameters, if any, of the struct declaration.", - isOptional: true - ), - Child( - name: "inheritanceClause", - kind: .node(kind: .inheritanceClause), - nameForDiagnostics: "inheritance clause", - documentation: - "The struct declaration inheritance clause describing one or more conformances for this struct declaration.", - isOptional: true - ), - Child( - name: "genericWhereClause", - kind: .node(kind: .genericWhereClause), - nameForDiagnostics: "generic where clause", - documentation: "The `where` clause that applies to the generic parameters of this struct declaration.", - isOptional: true - ), Child( name: "memberBlock", kind: .node(kind: .memberBlock), - documentation: - "The members of the struct declaration. Because struct extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type." + documentation: "The header of the struct declaration." ), ], childHistory: [ + [ + "structHeader": .extracted + ], [ "name": .renamed(from: "identifier") - ] + ], ] ), diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index dbacbca5fc2..b6e97d92050 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -28,6 +28,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case accessorEffectSpecifiers case accessorParameters case actorDecl + case actorDeclHeader case arrayElement case arrayElementList case arrayExpr @@ -54,6 +55,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case catchItem case catchItemList case classDecl + case classDeclHeader case classRestrictionType case closureCapture case closureCaptureClause @@ -121,6 +123,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case enumCaseParameterClause case enumCaseParameterList case enumDecl + case enumDeclHeader case exposeAttributeArguments case expr case expressionPattern @@ -128,6 +131,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case expressionStmt case exprList case extensionDecl + case extensionDeclHeader case fallThroughStmt case floatLiteralExpr case forceUnwrapExpr @@ -243,6 +247,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case primaryAssociatedTypeClause case primaryAssociatedTypeList case protocolDecl + case protocolDeclHeader case regexLiteralExpr case repeatStmt case returnClause @@ -262,6 +267,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case stringLiteralSegmentList case stringSegment case structDecl + case structDeclHeader case subscriptCallExpr case subscriptDecl case superExpr diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index 705e685693f..baeb30f09bc 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -53,25 +53,18 @@ public let TRAITS: [Trait] = [ traitName: "DeclGroup", baseKind: .decl, children: [ - Child(name: "attributes", kind: .node(kind: .attributeList)), - Child(name: "modifiers", kind: .node(kind: .declModifierList)), Child( - name: "introducer", - kind: .token(choices: [ - .keyword(.actor), .keyword(.class), .keyword(.enum), .keyword(.extension), .keyword(.protocol), - .keyword(.struct), - ]), - documentation: "The token that introduces this declaration, eg. `class` for a class declaration." - ), - Child(name: "inheritanceClause", kind: .node(kind: .inheritanceClause), isOptional: true), - Child( - name: "genericWhereClause", - kind: .node(kind: .genericWhereClause), + name: "header", + kind: .node(kind: .declGroupHeader), documentation: - "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.", - isOptional: true + "The header of the declaration." ), Child(name: "memberBlock", kind: .node(kind: .memberBlock)), + ], + childHistory: [ + [ + "header": .extracted + ] ] ), Trait( @@ -116,6 +109,13 @@ public let TRAITS: [Trait] = [ Child(name: "name", kind: .token(choices: [.token(.identifier)])) ] ), + Trait( + traitName: "NamedDeclHeader", + baseKind: .declGroupHeader, + children: [ + Child(name: "name", kind: .token(choices: [.token(.identifier)])) + ] + ), Trait( traitName: "MissingNode", documentation: """ diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift index 8922d5be648..ac15f5f2843 100644 --- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift +++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift @@ -736,7 +736,7 @@ class ValidateSyntaxNodes: XCTestCase { ValidationFailure(node: .attributedType, message: "child 'baseType' should not end with 'Type'"), ValidationFailure(node: .conformanceRequirement, message: "child 'leftType' should not end with 'Type'"), ValidationFailure(node: .conformanceRequirement, message: "child 'rightType' should not end with 'Type'"), - ValidationFailure(node: .extensionDecl, message: "child 'extendedType' should not end with 'Type'"), + ValidationFailure(node: .extensionDeclHeader, message: "child 'extendedType' should not end with 'Type'"), ValidationFailure(node: .genericParameter, message: "child 'inheritedType' should not end with 'Type'"), ValidationFailure( node: .implicitlyUnwrappedOptionalType, diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index c4ddb0a467b..9722bafd4af 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -226,32 +226,21 @@ extension Parser { } switch recoveryResult { + case (.group(let introducer), let handle)?: + let (header, shouldContinueParsing) = parseHeaderForDeclarationGroup( + attrs: attrs, + introducer: introducer, + introducerHandle: handle + ) + return parseDeclarationGroup(for: header, shouldParseMemberBlock: shouldContinueParsing) case (.simple(.import), let handle)?: return RawDeclSyntax(self.parseImportDeclaration(attrs, handle)) - case (.group(.class), let handle)?: - return RawDeclSyntax( - self.parseNominalTypeDeclaration(for: RawClassDeclSyntax.self, attrs: attrs, introucerHandle: handle) - ) - case (.group(.enum), let handle)?: - return RawDeclSyntax( - self.parseNominalTypeDeclaration(for: RawEnumDeclSyntax.self, attrs: attrs, introucerHandle: handle) - ) case (.simple(.case), let handle)?: return RawDeclSyntax(self.parseEnumCaseDeclaration(attrs, handle)) - case (.group(.struct), let handle)?: - return RawDeclSyntax( - self.parseNominalTypeDeclaration(for: RawStructDeclSyntax.self, attrs: attrs, introucerHandle: handle) - ) - case (.group(.protocol), let handle)?: - return RawDeclSyntax( - self.parseNominalTypeDeclaration(for: RawProtocolDeclSyntax.self, attrs: attrs, introucerHandle: handle) - ) case (.simple(.associatedtype), let handle)?: return RawDeclSyntax(self.parseAssociatedTypeDeclaration(attrs, handle)) case (.simple(.typealias), let handle)?: return RawDeclSyntax(self.parseTypealiasDeclaration(attrs, handle)) - case (.group(.extension), let handle)?: - return RawDeclSyntax(self.parseExtensionDeclaration(attrs, handle)) case (.simple(.func), let handle)?: return RawDeclSyntax(self.parseFuncDeclaration(attrs, handle)) case (.simple(.subscript), let handle)?: @@ -264,10 +253,6 @@ extension Parser { return RawDeclSyntax(self.parseOperatorDeclaration(attrs, handle)) case (.simple(.precedencegroup), let handle)?: return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs, handle)) - case (.group(.actor), let handle)?: - return RawDeclSyntax( - self.parseNominalTypeDeclaration(for: RawActorDeclSyntax.self, attrs: attrs, introucerHandle: handle) - ) case (.simple(.macro), let handle)?: return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle)) case (.simple(.pound), let handle)?: @@ -418,7 +403,56 @@ extension Parser { introducer: DeclGroupHeaderSyntax.IntroducerOptions, introducerHandle: RecoveryConsumptionHandle ) -> (RawDeclGroupHeaderSyntax, shouldContinueParsing: Bool) { - fatalError("not yet implemented") + func eraseToRawDeclGroupHeaderSyntax( + _ result: (some RawDeclGroupHeaderSyntaxNodeProtocol, Bool) + ) -> (RawDeclGroupHeaderSyntax, shouldContinueParsing: Bool) { + return (RawDeclGroupHeaderSyntax(result.0), result.1) + } + + switch introducer { + case .class: + return eraseToRawDeclGroupHeaderSyntax( + self.parseNominalTypeDeclarationHeader( + for: RawClassDeclHeaderSyntax.self, + attrs: attrs, + introducerHandle: introducerHandle + ) + ) + case .enum: + return eraseToRawDeclGroupHeaderSyntax( + self.parseNominalTypeDeclarationHeader( + for: RawEnumDeclHeaderSyntax.self, + attrs: attrs, + introducerHandle: introducerHandle + ) + ) + case .struct: + return eraseToRawDeclGroupHeaderSyntax( + self.parseNominalTypeDeclarationHeader( + for: RawStructDeclHeaderSyntax.self, + attrs: attrs, + introducerHandle: introducerHandle + ) + ) + case .protocol: + return eraseToRawDeclGroupHeaderSyntax( + self.parseNominalTypeDeclarationHeader( + for: RawProtocolDeclHeaderSyntax.self, + attrs: attrs, + introducerHandle: introducerHandle + ) + ) + case .extension: + return (RawDeclGroupHeaderSyntax(self.parseExtensionDeclarationHeader(attrs, introducerHandle)), true) + case .actor: + return eraseToRawDeclGroupHeaderSyntax( + self.parseNominalTypeDeclarationHeader( + for: RawActorDeclHeaderSyntax.self, + attrs: attrs, + introducerHandle: introducerHandle + ) + ) + } } /// Returns `true` if it looks like the parser is positioned at a function declaration that’s missing the `func` keyword. @@ -483,12 +517,121 @@ extension Parser { } } +protocol DeclarationGroupHeaderTrait { + var introducer: RawTokenSyntax { get } + + associatedtype Declaration: RawDeclSyntaxNodeProtocol + + func makeDeclaration( + memberBlock: RawMemberBlockSyntax, + arena: __shared SyntaxArena + ) -> Declaration +} + +extension RawExtensionDeclHeaderSyntax: DeclarationGroupHeaderTrait { + var introducer: RawTokenSyntax { + return self.extensionKeyword + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawExtensionDeclSyntax { + RawExtensionDeclSyntax(extensionHeader: self, memberBlock: memberBlock, arena: arena) + } +} + +extension RawMissingDeclHeaderSyntax: DeclarationGroupHeaderTrait { + var introducer: RawTokenSyntax { + return self.placeholder + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawMissingDeclSyntax { + RawMissingDeclSyntax( + self.unexpectedBeforeAttributes, + attributes: self.attributes, + self.unexpectedBetweenAttributesAndModifiers, + modifiers: self.modifiers, + self.unexpectedBetweenModifiersAndPlaceholder, + placeholder: self.placeholder, + RawUnexpectedNodesSyntax( + combining: [ + self.unexpectedBetweenPlaceholderAndInheritanceClause, + RawUnexpectedNodesSyntax([self.inheritanceClause], arena: arena), + self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, + RawUnexpectedNodesSyntax([self.genericWhereClause], arena: arena), + self.unexpectedAfterGenericWhereClause, + ], + RawUnexpectedNodesSyntax([memberBlock], arena: arena)!, + arena: arena + ), + arena: arena + ) + } +} + +extension RawDeclGroupHeaderSyntax: DeclarationGroupHeaderTrait { + private typealias ConcreteExistentialSelf = RawSyntaxNodeProtocol & DeclarationGroupHeaderTrait + private var asConcreteExistentialSelf: any ConcreteExistentialSelf { + let subtypes: [any ConcreteExistentialSelf.Type] = [ + RawExtensionDeclHeaderSyntax.self, + RawProtocolDeclHeaderSyntax.self, + RawClassDeclHeaderSyntax.self, + RawActorDeclHeaderSyntax.self, + RawStructDeclHeaderSyntax.self, + RawEnumDeclHeaderSyntax.self, + RawMissingDeclHeaderSyntax.self, + ] + + for subtype in subtypes { + if let result = subtype.init(self) { + return result + } + } + + fatalError("Node \(self) does not have a known subtype") + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawDeclSyntax { + return RawDeclSyntax(asConcreteExistentialSelf.makeDeclaration(memberBlock: memberBlock, arena: arena)) + } + + var introducer: RawTokenSyntax { + return asConcreteExistentialSelf.introducer + } +} + extension Parser { + /// Parse a declaration group (class, struct, enum, actor, protocol, extension) body given its header. + mutating func parseDeclarationGroup( + for header: T, + shouldParseMemberBlock: Bool = true + ) -> T.Declaration where T: DeclarationGroupHeaderTrait { + let memberBlock = + if shouldParseMemberBlock { + self.parseMemberBlock(introducer: header.introducer) + } else { + RawMemberBlockSyntax( + leftBrace: missingToken(.leftBrace), + members: RawMemberBlockItemListSyntax(elements: [], arena: self.arena), + rightBrace: missingToken(.rightBrace), + arena: self.arena + ) + } + return header.makeDeclaration(memberBlock: memberBlock, arena: self.arena) + } + /// Parse an extension declaration. mutating func parseExtensionDeclaration( _ attrs: DeclAttributes, _ handle: RecoveryConsumptionHandle ) -> RawExtensionDeclSyntax { + let header = parseExtensionDeclarationHeader(attrs, handle) + return parseDeclarationGroup(for: header) + } + + /// Parse the header of an extension declaration. + mutating func parseExtensionDeclarationHeader( + _ attrs: DeclAttributes, + _ handle: RecoveryConsumptionHandle + ) -> RawExtensionDeclHeaderSyntax { let (unexpectedBeforeExtensionKeyword, extensionKeyword) = self.eat(handle) let type = self.parseType() @@ -505,8 +648,7 @@ extension Parser { } else { whereClause = nil } - let memberBlock = self.parseMemberBlock(introducer: extensionKeyword) - return RawExtensionDeclSyntax( + return RawExtensionDeclHeaderSyntax( attributes: attrs.attributes, modifiers: attrs.modifiers, unexpectedBeforeExtensionKeyword, @@ -514,7 +656,6 @@ extension Parser { extendedType: type, inheritanceClause: inheritance, genericWhereClause: whereClause, - memberBlock: memberBlock, arena: self.arena ) } diff --git a/Sources/SwiftParser/Nominals.swift b/Sources/SwiftParser/Nominals.swift index 3f9a240c8dd..1ac9d1eeeaf 100644 --- a/Sources/SwiftParser/Nominals.swift +++ b/Sources/SwiftParser/Nominals.swift @@ -16,7 +16,7 @@ @_spi(RawSyntax) import SwiftSyntax #endif -protocol NominalTypeDeclarationTrait { +protocol NominalTypeDeclarationHeaderTrait: DeclarationGroupHeaderTrait { associatedtype PrimaryOrGenerics init( @@ -29,14 +29,13 @@ protocol NominalTypeDeclarationTrait { primaryOrGenerics: PrimaryOrGenerics?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, - memberBlock: RawMemberBlockSyntax, arena: __shared SyntaxArena ) static func parsePrimaryOrGenerics(_ parser: inout Parser) -> PrimaryOrGenerics? } -extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait { +extension RawProtocolDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { init( attributes: RawAttributeListSyntax, modifiers: RawDeclModifierListSyntax, @@ -47,7 +46,6 @@ extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait { primaryOrGenerics: RawPrimaryAssociatedTypeClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, - memberBlock: RawMemberBlockSyntax, arena: __shared SyntaxArena ) { self.init( @@ -60,7 +58,6 @@ extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait { primaryAssociatedTypeClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, - memberBlock: memberBlock, arena: arena ) } @@ -68,9 +65,17 @@ extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait { static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawPrimaryAssociatedTypeClauseSyntax? { return parser.parsePrimaryAssociatedTypes() } + + var introducer: RawTokenSyntax { + return self.protocolKeyword + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawProtocolDeclSyntax { + RawProtocolDeclSyntax(protocolHeader: self, memberBlock: memberBlock, arena: arena) + } } -extension RawClassDeclSyntax: NominalTypeDeclarationTrait { +extension RawClassDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { init( attributes: RawAttributeListSyntax, modifiers: RawDeclModifierListSyntax, @@ -81,7 +86,6 @@ extension RawClassDeclSyntax: NominalTypeDeclarationTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, - memberBlock: RawMemberBlockSyntax, arena: __shared SyntaxArena ) { self.init( @@ -94,7 +98,6 @@ extension RawClassDeclSyntax: NominalTypeDeclarationTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, - memberBlock: memberBlock, arena: arena ) } @@ -102,9 +105,17 @@ extension RawClassDeclSyntax: NominalTypeDeclarationTrait { static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? { return parser.parseGenericParameters() } + + var introducer: RawTokenSyntax { + return self.classKeyword + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawClassDeclSyntax { + RawClassDeclSyntax(classHeader: self, memberBlock: memberBlock, arena: arena) + } } -extension RawActorDeclSyntax: NominalTypeDeclarationTrait { +extension RawActorDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { init( attributes: RawAttributeListSyntax, modifiers: RawDeclModifierListSyntax, @@ -115,7 +126,6 @@ extension RawActorDeclSyntax: NominalTypeDeclarationTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, - memberBlock: RawMemberBlockSyntax, arena: __shared SyntaxArena ) { self.init( @@ -128,7 +138,6 @@ extension RawActorDeclSyntax: NominalTypeDeclarationTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, - memberBlock: memberBlock, arena: arena ) } @@ -136,9 +145,17 @@ extension RawActorDeclSyntax: NominalTypeDeclarationTrait { static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? { return parser.parseGenericParameters() } + + var introducer: RawTokenSyntax { + return self.actorKeyword + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawActorDeclSyntax { + RawActorDeclSyntax(actorHeader: self, memberBlock: memberBlock, arena: arena) + } } -extension RawStructDeclSyntax: NominalTypeDeclarationTrait { +extension RawStructDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { init( attributes: RawAttributeListSyntax, modifiers: RawDeclModifierListSyntax, @@ -149,7 +166,6 @@ extension RawStructDeclSyntax: NominalTypeDeclarationTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, - memberBlock: RawMemberBlockSyntax, arena: __shared SyntaxArena ) { self.init( @@ -162,7 +178,6 @@ extension RawStructDeclSyntax: NominalTypeDeclarationTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, - memberBlock: memberBlock, arena: arena ) } @@ -170,9 +185,17 @@ extension RawStructDeclSyntax: NominalTypeDeclarationTrait { static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? { return parser.parseGenericParameters() } + + var introducer: RawTokenSyntax { + return self.structKeyword + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawStructDeclSyntax { + RawStructDeclSyntax(structHeader: self, memberBlock: memberBlock, arena: arena) + } } -extension RawEnumDeclSyntax: NominalTypeDeclarationTrait { +extension RawEnumDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { init( attributes: RawAttributeListSyntax, modifiers: RawDeclModifierListSyntax, @@ -183,7 +206,6 @@ extension RawEnumDeclSyntax: NominalTypeDeclarationTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, - memberBlock: RawMemberBlockSyntax, arena: __shared SyntaxArena ) { self.init( @@ -196,7 +218,6 @@ extension RawEnumDeclSyntax: NominalTypeDeclarationTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, - memberBlock: memberBlock, arena: arena ) } @@ -204,35 +225,40 @@ extension RawEnumDeclSyntax: NominalTypeDeclarationTrait { static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? { return parser.parseGenericParameters() } + + var introducer: RawTokenSyntax { + return self.enumKeyword + } + + func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawEnumDeclSyntax { + RawEnumDeclSyntax(enumHeader: self, memberBlock: memberBlock, arena: arena) + } } extension Parser { - /// Parse a nominal type decl declaration - class, struct, enum, or actor. - mutating func parseNominalTypeDeclaration( + /// Parse the header of a nominal type decl declaration - class, struct, enum, or actor. + mutating func parseNominalTypeDeclarationHeader( for T: T.Type, attrs: DeclAttributes, - introucerHandle: RecoveryConsumptionHandle - ) -> T where T: NominalTypeDeclarationTrait { - let (unexpectedBeforeIntroducerKeyword, introducerKeyword) = self.eat(introucerHandle) + introducerHandle: RecoveryConsumptionHandle + ) -> (T, shouldContinueParsing: Bool) where T: NominalTypeDeclarationHeaderTrait { + let (unexpectedBeforeIntroducerKeyword, introducerKeyword) = self.eat(introducerHandle) let (unexpectedBeforeName, name) = self.expectIdentifier(keywordRecovery: true) if unexpectedBeforeName == nil && name.isMissing && self.atStartOfLine { - return T.init( - attributes: attrs.attributes, - modifiers: attrs.modifiers, - unexpectedBeforeIntroducerKeyword, - introducerKeyword: introducerKeyword, - unexpectedBeforeName, - name: name, - primaryOrGenerics: nil, - inheritanceClause: nil, - genericWhereClause: nil, - memberBlock: RawMemberBlockSyntax( - leftBrace: missingToken(.leftBrace), - members: RawMemberBlockItemListSyntax(elements: [], arena: self.arena), - rightBrace: missingToken(.rightBrace), + return ( + T.init( + attributes: attrs.attributes, + modifiers: attrs.modifiers, + unexpectedBeforeIntroducerKeyword, + introducerKeyword: introducerKeyword, + unexpectedBeforeName, + name: name, + primaryOrGenerics: nil, + inheritanceClause: nil, + genericWhereClause: nil, arena: self.arena ), - arena: self.arena + shouldContinueParsing: false ) } @@ -258,19 +284,20 @@ extension Parser { whereClause = nil } - let memberBlock = self.parseMemberBlock(introducer: introducerKeyword) - return T.init( - attributes: attrs.attributes, - modifiers: attrs.modifiers, - unexpectedBeforeIntroducerKeyword, - introducerKeyword: introducerKeyword, - unexpectedBeforeName, - name: name, - primaryOrGenerics: primaryOrGenerics, - inheritanceClause: inheritance, - genericWhereClause: whereClause, - memberBlock: memberBlock, - arena: self.arena + return ( + T.init( + attributes: attrs.attributes, + modifiers: attrs.modifiers, + unexpectedBeforeIntroducerKeyword, + introducerKeyword: introducerKeyword, + unexpectedBeforeName, + name: name, + primaryOrGenerics: primaryOrGenerics, + inheritanceClause: inheritance, + genericWhereClause: whereClause, + arena: self.arena + ), + shouldContinueParsing: true ) } diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift index 1d7488f2861..07b9a284f32 100644 --- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift @@ -28,15 +28,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "parameter" case \AccessorParametersSyntax.name: return "name" - case \ActorDeclSyntax.attributes: + case \ActorDeclHeaderSyntax.attributes: return "attributes" - case \ActorDeclSyntax.modifiers: + case \ActorDeclHeaderSyntax.modifiers: return "modifiers" - case \ActorDeclSyntax.genericParameterClause: + case \ActorDeclHeaderSyntax.genericParameterClause: return "generic parameter clause" - case \ActorDeclSyntax.inheritanceClause: + case \ActorDeclHeaderSyntax.inheritanceClause: return "inheritance clause" - case \ActorDeclSyntax.genericWhereClause: + case \ActorDeclHeaderSyntax.genericWhereClause: return "generic where clause" case \ArrayElementSyntax.expression: return "value" @@ -56,15 +56,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "value" case \BreakStmtSyntax.label: return "label" - case \ClassDeclSyntax.attributes: + case \ClassDeclHeaderSyntax.attributes: return "attributes" - case \ClassDeclSyntax.modifiers: + case \ClassDeclHeaderSyntax.modifiers: return "modifiers" - case \ClassDeclSyntax.genericParameterClause: + case \ClassDeclHeaderSyntax.genericParameterClause: return "generic parameter clause" - case \ClassDeclSyntax.inheritanceClause: + case \ClassDeclHeaderSyntax.inheritanceClause: return "inheritance clause" - case \ClassDeclSyntax.genericWhereClause: + case \ClassDeclHeaderSyntax.genericWhereClause: return "generic where clause" case \ClosureParameterClauseSyntax.parameters: return "parameters" @@ -118,23 +118,23 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "type" case \EnumCaseParameterSyntax.defaultValue: return "default value" - case \EnumDeclSyntax.attributes: + case \EnumDeclHeaderSyntax.attributes: return "attributes" - case \EnumDeclSyntax.modifiers: + case \EnumDeclHeaderSyntax.modifiers: return "modifiers" - case \EnumDeclSyntax.genericParameterClause: + case \EnumDeclHeaderSyntax.genericParameterClause: return "generic parameter clause" - case \EnumDeclSyntax.inheritanceClause: + case \EnumDeclHeaderSyntax.inheritanceClause: return "inheritance clause" - case \EnumDeclSyntax.genericWhereClause: + case \EnumDeclHeaderSyntax.genericWhereClause: return "generic where clause" - case \ExtensionDeclSyntax.attributes: + case \ExtensionDeclHeaderSyntax.attributes: return "attributes" - case \ExtensionDeclSyntax.modifiers: + case \ExtensionDeclHeaderSyntax.modifiers: return "modifiers" - case \ExtensionDeclSyntax.inheritanceClause: + case \ExtensionDeclHeaderSyntax.inheritanceClause: return "inheritance clause" - case \ExtensionDeclSyntax.genericWhereClause: + case \ExtensionDeclHeaderSyntax.genericWhereClause: return "generic where clause" case \ForStmtSyntax.body: return "body" @@ -280,15 +280,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "name" case \PrimaryAssociatedTypeSyntax.name: return "name" - case \ProtocolDeclSyntax.attributes: + case \ProtocolDeclHeaderSyntax.attributes: return "attributes" - case \ProtocolDeclSyntax.modifiers: + case \ProtocolDeclHeaderSyntax.modifiers: return "modifiers" - case \ProtocolDeclSyntax.primaryAssociatedTypeClause: + case \ProtocolDeclHeaderSyntax.primaryAssociatedTypeClause: return "primary associated type clause" - case \ProtocolDeclSyntax.inheritanceClause: + case \ProtocolDeclHeaderSyntax.inheritanceClause: return "inheritance clause" - case \ProtocolDeclSyntax.genericWhereClause: + case \ProtocolDeclHeaderSyntax.genericWhereClause: return "generic where clause" case \RepeatStmtSyntax.body: return "body" @@ -306,15 +306,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "label" case \SpecializeTargetFunctionArgumentSyntax.declName: return "declaration name" - case \StructDeclSyntax.attributes: + case \StructDeclHeaderSyntax.attributes: return "attributes" - case \StructDeclSyntax.modifiers: + case \StructDeclHeaderSyntax.modifiers: return "modifiers" - case \StructDeclSyntax.genericParameterClause: + case \StructDeclHeaderSyntax.genericParameterClause: return "generic parameter clause" - case \StructDeclSyntax.inheritanceClause: + case \StructDeclHeaderSyntax.inheritanceClause: return "inheritance clause" - case \StructDeclSyntax.genericWhereClause: + case \StructDeclHeaderSyntax.genericWhereClause: return "generic where clause" case \SubscriptCallExprSyntax.calledExpression: return "called expression" diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index feeeb2bc6cd..bdc38c52543 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -27,6 +27,8 @@ extension SyntaxKind { return "accessor" case .accessorEffectSpecifiers: return "accessor specifiers" + case .actorDeclHeader: + return "actor" case .actorDecl: return "actor" case .arrayElement: @@ -71,6 +73,8 @@ extension SyntaxKind { return "'catch' clause" case .catchClause: return "'catch' clause" + case .classDeclHeader: + return "class" case .classDecl: return "class" case .closureCaptureClause: @@ -159,6 +163,8 @@ extension SyntaxKind { return "parameter list" case .enumCaseParameter: return "parameter" + case .enumDeclHeader: + return "enum" case .enumDecl: return "enum" case .exposeAttributeArguments: @@ -167,6 +173,8 @@ extension SyntaxKind { return "pattern" case .expressionStmt: return "expression" + case .extensionDeclHeader: + return "extension" case .extensionDecl: return "extension" case .fallThroughStmt: @@ -329,6 +337,8 @@ extension SyntaxKind { return "operator" case .primaryAssociatedTypeClause: return "primary associated type clause" + case .protocolDeclHeader: + return "protocol" case .protocolDecl: return "protocol" case .regexLiteralExpr: @@ -355,6 +365,8 @@ extension SyntaxKind { return "attribute argument" case .stringLiteralExpr: return "string literal" + case .structDeclHeader: + return "struct" case .structDecl: return "struct" case .subscriptCallExpr: diff --git a/Sources/SwiftSyntax/CustomTraits.swift b/Sources/SwiftSyntax/CustomTraits.swift index 9111462c609..f47b3b43580 100644 --- a/Sources/SwiftSyntax/CustomTraits.swift +++ b/Sources/SwiftSyntax/CustomTraits.swift @@ -10,7 +10,7 @@ // //===----------------------------------------------------------------------===// -extension ActorDeclSyntax { +extension ActorDeclHeaderSyntax { public var introducer: TokenSyntax { get { return actorKeyword @@ -21,7 +21,18 @@ extension ActorDeclSyntax { } } -extension ClassDeclSyntax { +extension ActorDeclSyntax { + public var header: DeclGroupHeaderSyntax { + get { + return DeclGroupHeaderSyntax(actorHeader) + } + set { + actorHeader = newValue.cast(ActorDeclHeaderSyntax.self) + } + } +} + +extension ClassDeclHeaderSyntax { public var introducer: TokenSyntax { get { return classKeyword @@ -32,7 +43,18 @@ extension ClassDeclSyntax { } } -extension EnumDeclSyntax { +extension ClassDeclSyntax { + public var header: DeclGroupHeaderSyntax { + get { + return DeclGroupHeaderSyntax(classHeader) + } + set { + classHeader = newValue.cast(ClassDeclHeaderSyntax.self) + } + } +} + +extension EnumDeclHeaderSyntax { public var introducer: TokenSyntax { get { return enumKeyword @@ -43,7 +65,18 @@ extension EnumDeclSyntax { } } -extension ExtensionDeclSyntax { +extension EnumDeclSyntax { + public var header: DeclGroupHeaderSyntax { + get { + return DeclGroupHeaderSyntax(enumHeader) + } + set { + enumHeader = newValue.cast(EnumDeclHeaderSyntax.self) + } + } +} + +extension ExtensionDeclHeaderSyntax { public var introducer: TokenSyntax { get { return extensionKeyword @@ -54,6 +87,17 @@ extension ExtensionDeclSyntax { } } +extension ExtensionDeclSyntax { + public var header: DeclGroupHeaderSyntax { + get { + return DeclGroupHeaderSyntax(extensionHeader) + } + set { + extensionHeader = newValue.cast(ExtensionDeclHeaderSyntax.self) + } + } +} + extension MissingDeclHeaderSyntax { public var introducer: TokenSyntax { get { @@ -65,7 +109,7 @@ extension MissingDeclHeaderSyntax { } } -extension ProtocolDeclSyntax { +extension ProtocolDeclHeaderSyntax { public var introducer: TokenSyntax { get { return protocolKeyword @@ -76,7 +120,18 @@ extension ProtocolDeclSyntax { } } -extension StructDeclSyntax { +extension ProtocolDeclSyntax { + public var header: DeclGroupHeaderSyntax { + get { + return DeclGroupHeaderSyntax(protocolHeader) + } + set { + protocolHeader = newValue.cast(ProtocolDeclHeaderSyntax.self) + } + } +} + +extension StructDeclHeaderSyntax { public var introducer: TokenSyntax { get { return structKeyword @@ -87,6 +142,17 @@ extension StructDeclSyntax { } } +extension StructDeclSyntax { + public var header: DeclGroupHeaderSyntax { + get { + return DeclGroupHeaderSyntax(structHeader) + } + set { + structHeader = newValue.cast(StructDeclHeaderSyntax.self) + } + } +} + //==========================================================================// // IMPORTANT: If you are tempted to add an extension here, please insert // // it in alphabetical order above // diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md index 5cb22e1b2c7..1904874c547 100644 --- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md @@ -336,8 +336,10 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - +- - - - @@ -349,6 +351,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- - - - @@ -369,9 +373,11 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - +- - - - @@ -389,6 +395,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index c5ed1770f99..7fd90ae8297 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -81,36 +81,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "rightParen" case \AccessorParametersSyntax.unexpectedAfterRightParen: return "unexpectedAfterRightParen" - case \ActorDeclSyntax.unexpectedBeforeAttributes: + case \ActorDeclHeaderSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" - case \ActorDeclSyntax.attributes: + case \ActorDeclHeaderSyntax.attributes: return "attributes" - case \ActorDeclSyntax.unexpectedBetweenAttributesAndModifiers: + case \ActorDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers: return "unexpectedBetweenAttributesAndModifiers" - case \ActorDeclSyntax.modifiers: + case \ActorDeclHeaderSyntax.modifiers: return "modifiers" - case \ActorDeclSyntax.unexpectedBetweenModifiersAndActorKeyword: + case \ActorDeclHeaderSyntax.unexpectedBetweenModifiersAndActorKeyword: return "unexpectedBetweenModifiersAndActorKeyword" - case \ActorDeclSyntax.actorKeyword: + case \ActorDeclHeaderSyntax.actorKeyword: return "actorKeyword" - case \ActorDeclSyntax.unexpectedBetweenActorKeywordAndName: + case \ActorDeclHeaderSyntax.unexpectedBetweenActorKeywordAndName: return "unexpectedBetweenActorKeywordAndName" - case \ActorDeclSyntax.name: + case \ActorDeclHeaderSyntax.name: return "name" - case \ActorDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: + case \ActorDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause: return "unexpectedBetweenNameAndGenericParameterClause" - case \ActorDeclSyntax.genericParameterClause: + case \ActorDeclHeaderSyntax.genericParameterClause: return "genericParameterClause" - case \ActorDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: + case \ActorDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \ActorDeclSyntax.inheritanceClause: + case \ActorDeclHeaderSyntax.inheritanceClause: return "inheritanceClause" - case \ActorDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: + case \ActorDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ActorDeclSyntax.genericWhereClause: + case \ActorDeclHeaderSyntax.genericWhereClause: return "genericWhereClause" - case \ActorDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case \ActorDeclHeaderSyntax.unexpectedAfterGenericWhereClause: + return "unexpectedAfterGenericWhereClause" + case \ActorDeclSyntax.unexpectedBeforeActorHeader: + return "unexpectedBeforeActorHeader" + case \ActorDeclSyntax.actorHeader: + return "actorHeader" + case \ActorDeclSyntax.unexpectedBetweenActorHeaderAndMemberBlock: + return "unexpectedBetweenActorHeaderAndMemberBlock" case \ActorDeclSyntax.memberBlock: return "memberBlock" case \ActorDeclSyntax.unexpectedAfterMemberBlock: @@ -419,36 +425,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "trailingComma" case \CatchItemSyntax.unexpectedAfterTrailingComma: return "unexpectedAfterTrailingComma" - case \ClassDeclSyntax.unexpectedBeforeAttributes: + case \ClassDeclHeaderSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" - case \ClassDeclSyntax.attributes: + case \ClassDeclHeaderSyntax.attributes: return "attributes" - case \ClassDeclSyntax.unexpectedBetweenAttributesAndModifiers: + case \ClassDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers: return "unexpectedBetweenAttributesAndModifiers" - case \ClassDeclSyntax.modifiers: + case \ClassDeclHeaderSyntax.modifiers: return "modifiers" - case \ClassDeclSyntax.unexpectedBetweenModifiersAndClassKeyword: + case \ClassDeclHeaderSyntax.unexpectedBetweenModifiersAndClassKeyword: return "unexpectedBetweenModifiersAndClassKeyword" - case \ClassDeclSyntax.classKeyword: + case \ClassDeclHeaderSyntax.classKeyword: return "classKeyword" - case \ClassDeclSyntax.unexpectedBetweenClassKeywordAndName: + case \ClassDeclHeaderSyntax.unexpectedBetweenClassKeywordAndName: return "unexpectedBetweenClassKeywordAndName" - case \ClassDeclSyntax.name: + case \ClassDeclHeaderSyntax.name: return "name" - case \ClassDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: + case \ClassDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause: return "unexpectedBetweenNameAndGenericParameterClause" - case \ClassDeclSyntax.genericParameterClause: + case \ClassDeclHeaderSyntax.genericParameterClause: return "genericParameterClause" - case \ClassDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: + case \ClassDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \ClassDeclSyntax.inheritanceClause: + case \ClassDeclHeaderSyntax.inheritanceClause: return "inheritanceClause" - case \ClassDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: + case \ClassDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ClassDeclSyntax.genericWhereClause: + case \ClassDeclHeaderSyntax.genericWhereClause: return "genericWhereClause" - case \ClassDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case \ClassDeclHeaderSyntax.unexpectedAfterGenericWhereClause: + return "unexpectedAfterGenericWhereClause" + case \ClassDeclSyntax.unexpectedBeforeClassHeader: + return "unexpectedBeforeClassHeader" + case \ClassDeclSyntax.classHeader: + return "classHeader" + case \ClassDeclSyntax.unexpectedBetweenClassHeaderAndMemberBlock: + return "unexpectedBetweenClassHeaderAndMemberBlock" case \ClassDeclSyntax.memberBlock: return "memberBlock" case \ClassDeclSyntax.unexpectedAfterMemberBlock: @@ -1171,36 +1183,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "trailingComma" case \EnumCaseParameterSyntax.unexpectedAfterTrailingComma: return "unexpectedAfterTrailingComma" - case \EnumDeclSyntax.unexpectedBeforeAttributes: + case \EnumDeclHeaderSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" - case \EnumDeclSyntax.attributes: + case \EnumDeclHeaderSyntax.attributes: return "attributes" - case \EnumDeclSyntax.unexpectedBetweenAttributesAndModifiers: + case \EnumDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers: return "unexpectedBetweenAttributesAndModifiers" - case \EnumDeclSyntax.modifiers: + case \EnumDeclHeaderSyntax.modifiers: return "modifiers" - case \EnumDeclSyntax.unexpectedBetweenModifiersAndEnumKeyword: + case \EnumDeclHeaderSyntax.unexpectedBetweenModifiersAndEnumKeyword: return "unexpectedBetweenModifiersAndEnumKeyword" - case \EnumDeclSyntax.enumKeyword: + case \EnumDeclHeaderSyntax.enumKeyword: return "enumKeyword" - case \EnumDeclSyntax.unexpectedBetweenEnumKeywordAndName: + case \EnumDeclHeaderSyntax.unexpectedBetweenEnumKeywordAndName: return "unexpectedBetweenEnumKeywordAndName" - case \EnumDeclSyntax.name: + case \EnumDeclHeaderSyntax.name: return "name" - case \EnumDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: + case \EnumDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause: return "unexpectedBetweenNameAndGenericParameterClause" - case \EnumDeclSyntax.genericParameterClause: + case \EnumDeclHeaderSyntax.genericParameterClause: return "genericParameterClause" - case \EnumDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: + case \EnumDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \EnumDeclSyntax.inheritanceClause: + case \EnumDeclHeaderSyntax.inheritanceClause: return "inheritanceClause" - case \EnumDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: + case \EnumDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \EnumDeclSyntax.genericWhereClause: + case \EnumDeclHeaderSyntax.genericWhereClause: return "genericWhereClause" - case \EnumDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case \EnumDeclHeaderSyntax.unexpectedAfterGenericWhereClause: + return "unexpectedAfterGenericWhereClause" + case \EnumDeclSyntax.unexpectedBeforeEnumHeader: + return "unexpectedBeforeEnumHeader" + case \EnumDeclSyntax.enumHeader: + return "enumHeader" + case \EnumDeclSyntax.unexpectedBetweenEnumHeaderAndMemberBlock: + return "unexpectedBetweenEnumHeaderAndMemberBlock" case \EnumDeclSyntax.memberBlock: return "memberBlock" case \EnumDeclSyntax.unexpectedAfterMemberBlock: @@ -1253,32 +1271,38 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "expression" case \ExpressionStmtSyntax.unexpectedAfterExpression: return "unexpectedAfterExpression" - case \ExtensionDeclSyntax.unexpectedBeforeAttributes: + case \ExtensionDeclHeaderSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" - case \ExtensionDeclSyntax.attributes: + case \ExtensionDeclHeaderSyntax.attributes: return "attributes" - case \ExtensionDeclSyntax.unexpectedBetweenAttributesAndModifiers: + case \ExtensionDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers: return "unexpectedBetweenAttributesAndModifiers" - case \ExtensionDeclSyntax.modifiers: + case \ExtensionDeclHeaderSyntax.modifiers: return "modifiers" - case \ExtensionDeclSyntax.unexpectedBetweenModifiersAndExtensionKeyword: + case \ExtensionDeclHeaderSyntax.unexpectedBetweenModifiersAndExtensionKeyword: return "unexpectedBetweenModifiersAndExtensionKeyword" - case \ExtensionDeclSyntax.extensionKeyword: + case \ExtensionDeclHeaderSyntax.extensionKeyword: return "extensionKeyword" - case \ExtensionDeclSyntax.unexpectedBetweenExtensionKeywordAndExtendedType: + case \ExtensionDeclHeaderSyntax.unexpectedBetweenExtensionKeywordAndExtendedType: return "unexpectedBetweenExtensionKeywordAndExtendedType" - case \ExtensionDeclSyntax.extendedType: + case \ExtensionDeclHeaderSyntax.extendedType: return "extendedType" - case \ExtensionDeclSyntax.unexpectedBetweenExtendedTypeAndInheritanceClause: + case \ExtensionDeclHeaderSyntax.unexpectedBetweenExtendedTypeAndInheritanceClause: return "unexpectedBetweenExtendedTypeAndInheritanceClause" - case \ExtensionDeclSyntax.inheritanceClause: + case \ExtensionDeclHeaderSyntax.inheritanceClause: return "inheritanceClause" - case \ExtensionDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: + case \ExtensionDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ExtensionDeclSyntax.genericWhereClause: + case \ExtensionDeclHeaderSyntax.genericWhereClause: return "genericWhereClause" - case \ExtensionDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case \ExtensionDeclHeaderSyntax.unexpectedAfterGenericWhereClause: + return "unexpectedAfterGenericWhereClause" + case \ExtensionDeclSyntax.unexpectedBeforeExtensionHeader: + return "unexpectedBeforeExtensionHeader" + case \ExtensionDeclSyntax.extensionHeader: + return "extensionHeader" + case \ExtensionDeclSyntax.unexpectedBetweenExtensionHeaderAndMemberBlock: + return "unexpectedBetweenExtensionHeaderAndMemberBlock" case \ExtensionDeclSyntax.memberBlock: return "memberBlock" case \ExtensionDeclSyntax.unexpectedAfterMemberBlock: @@ -2709,36 +2733,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "trailingComma" case \PrimaryAssociatedTypeSyntax.unexpectedAfterTrailingComma: return "unexpectedAfterTrailingComma" - case \ProtocolDeclSyntax.unexpectedBeforeAttributes: + case \ProtocolDeclHeaderSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" - case \ProtocolDeclSyntax.attributes: + case \ProtocolDeclHeaderSyntax.attributes: return "attributes" - case \ProtocolDeclSyntax.unexpectedBetweenAttributesAndModifiers: + case \ProtocolDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers: return "unexpectedBetweenAttributesAndModifiers" - case \ProtocolDeclSyntax.modifiers: + case \ProtocolDeclHeaderSyntax.modifiers: return "modifiers" - case \ProtocolDeclSyntax.unexpectedBetweenModifiersAndProtocolKeyword: + case \ProtocolDeclHeaderSyntax.unexpectedBetweenModifiersAndProtocolKeyword: return "unexpectedBetweenModifiersAndProtocolKeyword" - case \ProtocolDeclSyntax.protocolKeyword: + case \ProtocolDeclHeaderSyntax.protocolKeyword: return "protocolKeyword" - case \ProtocolDeclSyntax.unexpectedBetweenProtocolKeywordAndName: + case \ProtocolDeclHeaderSyntax.unexpectedBetweenProtocolKeywordAndName: return "unexpectedBetweenProtocolKeywordAndName" - case \ProtocolDeclSyntax.name: + case \ProtocolDeclHeaderSyntax.name: return "name" - case \ProtocolDeclSyntax.unexpectedBetweenNameAndPrimaryAssociatedTypeClause: + case \ProtocolDeclHeaderSyntax.unexpectedBetweenNameAndPrimaryAssociatedTypeClause: return "unexpectedBetweenNameAndPrimaryAssociatedTypeClause" - case \ProtocolDeclSyntax.primaryAssociatedTypeClause: + case \ProtocolDeclHeaderSyntax.primaryAssociatedTypeClause: return "primaryAssociatedTypeClause" - case \ProtocolDeclSyntax.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: + case \ProtocolDeclHeaderSyntax.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: return "unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause" - case \ProtocolDeclSyntax.inheritanceClause: + case \ProtocolDeclHeaderSyntax.inheritanceClause: return "inheritanceClause" - case \ProtocolDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: + case \ProtocolDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \ProtocolDeclSyntax.genericWhereClause: + case \ProtocolDeclHeaderSyntax.genericWhereClause: return "genericWhereClause" - case \ProtocolDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case \ProtocolDeclHeaderSyntax.unexpectedAfterGenericWhereClause: + return "unexpectedAfterGenericWhereClause" + case \ProtocolDeclSyntax.unexpectedBeforeProtocolHeader: + return "unexpectedBeforeProtocolHeader" + case \ProtocolDeclSyntax.protocolHeader: + return "protocolHeader" + case \ProtocolDeclSyntax.unexpectedBetweenProtocolHeaderAndMemberBlock: + return "unexpectedBetweenProtocolHeaderAndMemberBlock" case \ProtocolDeclSyntax.memberBlock: return "memberBlock" case \ProtocolDeclSyntax.unexpectedAfterMemberBlock: @@ -2931,36 +2961,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "content" case \StringSegmentSyntax.unexpectedAfterContent: return "unexpectedAfterContent" - case \StructDeclSyntax.unexpectedBeforeAttributes: + case \StructDeclHeaderSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" - case \StructDeclSyntax.attributes: + case \StructDeclHeaderSyntax.attributes: return "attributes" - case \StructDeclSyntax.unexpectedBetweenAttributesAndModifiers: + case \StructDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers: return "unexpectedBetweenAttributesAndModifiers" - case \StructDeclSyntax.modifiers: + case \StructDeclHeaderSyntax.modifiers: return "modifiers" - case \StructDeclSyntax.unexpectedBetweenModifiersAndStructKeyword: + case \StructDeclHeaderSyntax.unexpectedBetweenModifiersAndStructKeyword: return "unexpectedBetweenModifiersAndStructKeyword" - case \StructDeclSyntax.structKeyword: + case \StructDeclHeaderSyntax.structKeyword: return "structKeyword" - case \StructDeclSyntax.unexpectedBetweenStructKeywordAndName: + case \StructDeclHeaderSyntax.unexpectedBetweenStructKeywordAndName: return "unexpectedBetweenStructKeywordAndName" - case \StructDeclSyntax.name: + case \StructDeclHeaderSyntax.name: return "name" - case \StructDeclSyntax.unexpectedBetweenNameAndGenericParameterClause: + case \StructDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause: return "unexpectedBetweenNameAndGenericParameterClause" - case \StructDeclSyntax.genericParameterClause: + case \StructDeclHeaderSyntax.genericParameterClause: return "genericParameterClause" - case \StructDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: + case \StructDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause: return "unexpectedBetweenGenericParameterClauseAndInheritanceClause" - case \StructDeclSyntax.inheritanceClause: + case \StructDeclHeaderSyntax.inheritanceClause: return "inheritanceClause" - case \StructDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: + case \StructDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause: return "unexpectedBetweenInheritanceClauseAndGenericWhereClause" - case \StructDeclSyntax.genericWhereClause: + case \StructDeclHeaderSyntax.genericWhereClause: return "genericWhereClause" - case \StructDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock: - return "unexpectedBetweenGenericWhereClauseAndMemberBlock" + case \StructDeclHeaderSyntax.unexpectedAfterGenericWhereClause: + return "unexpectedAfterGenericWhereClause" + case \StructDeclSyntax.unexpectedBeforeStructHeader: + return "unexpectedBeforeStructHeader" + case \StructDeclSyntax.structHeader: + return "structHeader" + case \StructDeclSyntax.unexpectedBetweenStructHeaderAndMemberBlock: + return "unexpectedBetweenStructHeaderAndMemberBlock" case \StructDeclSyntax.memberBlock: return "memberBlock" case \StructDeclSyntax.unexpectedAfterMemberBlock: diff --git a/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift b/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift index fb3cd840904..e4baf12569e 100644 --- a/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift +++ b/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift @@ -103,37 +103,235 @@ extension AccessorDeclSyntax { } extension ActorDeclSyntax { - @available(*, deprecated, renamed: "unexpectedBetweenActorKeywordAndName") + @available(*, deprecated, renamed: "unexpectedBeforeActorHeader") + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return unexpectedBeforeActorHeader + } + set { + unexpectedBeforeActorHeader = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.attributes") + public var attributes: AttributeListSyntax { + get { + return actorHeader.attributes + } + set { + actorHeader.attributes = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenAttributesAndModifiers") + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return actorHeader.unexpectedBetweenAttributesAndModifiers + } + set { + actorHeader.unexpectedBetweenAttributesAndModifiers = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.modifiers") + public var modifiers: DeclModifierListSyntax { + get { + return actorHeader.modifiers + } + set { + actorHeader.modifiers = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenModifiersAndActorKeyword") + public var unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? { + get { + return actorHeader.unexpectedBetweenModifiersAndActorKeyword + } + set { + actorHeader.unexpectedBetweenModifiersAndActorKeyword = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.actorKeyword") + public var actorKeyword: TokenSyntax { + get { + return actorHeader.actorKeyword + } + set { + actorHeader.actorKeyword = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenActorKeywordAndName") + public var unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? { + get { + return actorHeader.unexpectedBetweenActorKeywordAndName + } + set { + actorHeader.unexpectedBetweenActorKeywordAndName = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.name") + public var name: TokenSyntax { + get { + return actorHeader.name + } + set { + actorHeader.name = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenNameAndGenericParameterClause") + public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? { + get { + return actorHeader.unexpectedBetweenNameAndGenericParameterClause + } + set { + actorHeader.unexpectedBetweenNameAndGenericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.genericParameterClause") + public var genericParameterClause: GenericParameterClauseSyntax? { + get { + return actorHeader.genericParameterClause + } + set { + actorHeader.genericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause") + public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? { + get { + return actorHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause + } + set { + actorHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.inheritanceClause") + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return actorHeader.inheritanceClause + } + set { + actorHeader.inheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause") + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? { + get { + return actorHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause + } + set { + actorHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.genericWhereClause") + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return actorHeader.genericWhereClause + } + set { + actorHeader.genericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedBetweenActorHeaderAndMemberBlock") + public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + get { + return unexpectedBetweenActorHeaderAndMemberBlock + } + set { + unexpectedBetweenActorHeaderAndMemberBlock = newValue + } + } + + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenActorKeywordAndName") public var unexpectedBetweenActorKeywordAndIdentifier: UnexpectedNodesSyntax? { get { - return unexpectedBetweenActorKeywordAndName + return actorHeader.unexpectedBetweenActorKeywordAndName } set { - unexpectedBetweenActorKeywordAndName = newValue + actorHeader.unexpectedBetweenActorKeywordAndName = newValue } } - @available(*, deprecated, renamed: "name") + @available(*, deprecated, renamed: "actorHeader.name") public var identifier: TokenSyntax { get { - return name + return actorHeader.name } set { - name = newValue + actorHeader.name = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause") + @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenNameAndGenericParameterClause") public var unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? { get { - return unexpectedBetweenNameAndGenericParameterClause + return actorHeader.unexpectedBetweenNameAndGenericParameterClause } set { - unexpectedBetweenNameAndGenericParameterClause = newValue + actorHeader.unexpectedBetweenNameAndGenericParameterClause = newValue } } - @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:actorKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)") + @available(*, deprecated, renamed: "init(leadingTrivia:_:actorHeader:_:memberBlock:_:trailingTrivia:)") + @_disfavoredOverload + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + _ unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil, + actorKeyword: TokenSyntax = .keyword(.actor), + _ unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + actorHeader: ActorDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndActorKeyword, + actorKeyword: actorKeyword, + unexpectedBetweenActorKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: memberBlock, + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } + + @available(*, deprecated, renamed: "init(leadingTrivia:_:actorHeader:_:memberBlock:_:trailingTrivia:)") @_disfavoredOverload public init( leadingTrivia: Trivia? = nil, @@ -159,19 +357,21 @@ extension ActorDeclSyntax { self.init( leadingTrivia: leadingTrivia, unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndActorKeyword, - actorKeyword: actorKeyword, - unexpectedBetweenActorKeywordAndIdentifier, - name: identifier, - unexpectedBetweenIdentifierAndGenericParameterClause, - genericParameterClause: genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, + actorHeader: ActorDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndActorKeyword, + actorKeyword: actorKeyword, + unexpectedBetweenActorKeywordAndIdentifier, + name: identifier, + unexpectedBetweenIdentifierAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock: memberBlock, unexpectedAfterMemberBlock, @@ -1074,37 +1274,235 @@ extension _CanImportVersionInfoSyntax { } extension ClassDeclSyntax { - @available(*, deprecated, renamed: "unexpectedBetweenClassKeywordAndName") + @available(*, deprecated, renamed: "unexpectedBeforeClassHeader") + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return unexpectedBeforeClassHeader + } + set { + unexpectedBeforeClassHeader = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.attributes") + public var attributes: AttributeListSyntax { + get { + return classHeader.attributes + } + set { + classHeader.attributes = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenAttributesAndModifiers") + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return classHeader.unexpectedBetweenAttributesAndModifiers + } + set { + classHeader.unexpectedBetweenAttributesAndModifiers = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.modifiers") + public var modifiers: DeclModifierListSyntax { + get { + return classHeader.modifiers + } + set { + classHeader.modifiers = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenModifiersAndClassKeyword") + public var unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? { + get { + return classHeader.unexpectedBetweenModifiersAndClassKeyword + } + set { + classHeader.unexpectedBetweenModifiersAndClassKeyword = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.classKeyword") + public var classKeyword: TokenSyntax { + get { + return classHeader.classKeyword + } + set { + classHeader.classKeyword = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenClassKeywordAndName") + public var unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? { + get { + return classHeader.unexpectedBetweenClassKeywordAndName + } + set { + classHeader.unexpectedBetweenClassKeywordAndName = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.name") + public var name: TokenSyntax { + get { + return classHeader.name + } + set { + classHeader.name = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenNameAndGenericParameterClause") + public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? { + get { + return classHeader.unexpectedBetweenNameAndGenericParameterClause + } + set { + classHeader.unexpectedBetweenNameAndGenericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.genericParameterClause") + public var genericParameterClause: GenericParameterClauseSyntax? { + get { + return classHeader.genericParameterClause + } + set { + classHeader.genericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause") + public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? { + get { + return classHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause + } + set { + classHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.inheritanceClause") + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return classHeader.inheritanceClause + } + set { + classHeader.inheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause") + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? { + get { + return classHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause + } + set { + classHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.genericWhereClause") + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return classHeader.genericWhereClause + } + set { + classHeader.genericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedBetweenClassHeaderAndMemberBlock") + public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + get { + return unexpectedBetweenClassHeaderAndMemberBlock + } + set { + unexpectedBetweenClassHeaderAndMemberBlock = newValue + } + } + + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenClassKeywordAndName") public var unexpectedBetweenClassKeywordAndIdentifier: UnexpectedNodesSyntax? { get { - return unexpectedBetweenClassKeywordAndName + return classHeader.unexpectedBetweenClassKeywordAndName } set { - unexpectedBetweenClassKeywordAndName = newValue + classHeader.unexpectedBetweenClassKeywordAndName = newValue } } - @available(*, deprecated, renamed: "name") + @available(*, deprecated, renamed: "classHeader.name") public var identifier: TokenSyntax { get { - return name + return classHeader.name } set { - name = newValue + classHeader.name = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause") + @available(*, deprecated, renamed: "classHeader.unexpectedBetweenNameAndGenericParameterClause") public var unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? { get { - return unexpectedBetweenNameAndGenericParameterClause + return classHeader.unexpectedBetweenNameAndGenericParameterClause } set { - unexpectedBetweenNameAndGenericParameterClause = newValue + classHeader.unexpectedBetweenNameAndGenericParameterClause = newValue } } - @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:classKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)") + @available(*, deprecated, renamed: "init(leadingTrivia:_:classHeader:_:memberBlock:_:trailingTrivia:)") + @_disfavoredOverload + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + _ unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil, + classKeyword: TokenSyntax = .keyword(.class), + _ unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + classHeader: ClassDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndClassKeyword, + classKeyword: classKeyword, + unexpectedBetweenClassKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: memberBlock, + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } + + @available(*, deprecated, renamed: "init(leadingTrivia:_:classHeader:_:memberBlock:_:trailingTrivia:)") @_disfavoredOverload public init( leadingTrivia: Trivia? = nil, @@ -1130,19 +1528,21 @@ extension ClassDeclSyntax { self.init( leadingTrivia: leadingTrivia, unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndClassKeyword, - classKeyword: classKeyword, - unexpectedBetweenClassKeywordAndIdentifier, - name: identifier, - unexpectedBetweenIdentifierAndGenericParameterClause, - genericParameterClause: genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, + classHeader: ClassDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndClassKeyword, + classKeyword: classKeyword, + unexpectedBetweenClassKeywordAndIdentifier, + name: identifier, + unexpectedBetweenIdentifierAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock: memberBlock, unexpectedAfterMemberBlock, @@ -2574,57 +2974,255 @@ extension EnumCaseParameterSyntax { } extension EnumDeclSyntax { - @available(*, deprecated, renamed: "unexpectedBetweenEnumKeywordAndName") + @available(*, deprecated, renamed: "unexpectedBeforeEnumHeader") + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return unexpectedBeforeEnumHeader + } + set { + unexpectedBeforeEnumHeader = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.attributes") + public var attributes: AttributeListSyntax { + get { + return enumHeader.attributes + } + set { + enumHeader.attributes = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenAttributesAndModifiers") + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return enumHeader.unexpectedBetweenAttributesAndModifiers + } + set { + enumHeader.unexpectedBetweenAttributesAndModifiers = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.modifiers") + public var modifiers: DeclModifierListSyntax { + get { + return enumHeader.modifiers + } + set { + enumHeader.modifiers = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenModifiersAndEnumKeyword") + public var unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? { + get { + return enumHeader.unexpectedBetweenModifiersAndEnumKeyword + } + set { + enumHeader.unexpectedBetweenModifiersAndEnumKeyword = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.enumKeyword") + public var enumKeyword: TokenSyntax { + get { + return enumHeader.enumKeyword + } + set { + enumHeader.enumKeyword = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenEnumKeywordAndName") + public var unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? { + get { + return enumHeader.unexpectedBetweenEnumKeywordAndName + } + set { + enumHeader.unexpectedBetweenEnumKeywordAndName = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.name") + public var name: TokenSyntax { + get { + return enumHeader.name + } + set { + enumHeader.name = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenNameAndGenericParameterClause") + public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? { + get { + return enumHeader.unexpectedBetweenNameAndGenericParameterClause + } + set { + enumHeader.unexpectedBetweenNameAndGenericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.genericParameterClause") + public var genericParameterClause: GenericParameterClauseSyntax? { + get { + return enumHeader.genericParameterClause + } + set { + enumHeader.genericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause") + public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? { + get { + return enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause + } + set { + enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.inheritanceClause") + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return enumHeader.inheritanceClause + } + set { + enumHeader.inheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause") + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? { + get { + return enumHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause + } + set { + enumHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.genericWhereClause") + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return enumHeader.genericWhereClause + } + set { + enumHeader.genericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedBetweenEnumHeaderAndMemberBlock") + public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + get { + return unexpectedBetweenEnumHeaderAndMemberBlock + } + set { + unexpectedBetweenEnumHeaderAndMemberBlock = newValue + } + } + + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenEnumKeywordAndName") public var unexpectedBetweenEnumKeywordAndIdentifier: UnexpectedNodesSyntax? { get { - return unexpectedBetweenEnumKeywordAndName + return enumHeader.unexpectedBetweenEnumKeywordAndName } set { - unexpectedBetweenEnumKeywordAndName = newValue + enumHeader.unexpectedBetweenEnumKeywordAndName = newValue } } - @available(*, deprecated, renamed: "name") + @available(*, deprecated, renamed: "enumHeader.name") public var identifier: TokenSyntax { get { - return name + return enumHeader.name } set { - name = newValue + enumHeader.name = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause") + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenNameAndGenericParameterClause") public var unexpectedBetweenIdentifierAndGenericParameters: UnexpectedNodesSyntax? { get { - return unexpectedBetweenNameAndGenericParameterClause + return enumHeader.unexpectedBetweenNameAndGenericParameterClause } set { - unexpectedBetweenNameAndGenericParameterClause = newValue + enumHeader.unexpectedBetweenNameAndGenericParameterClause = newValue } } - @available(*, deprecated, renamed: "genericParameterClause") + @available(*, deprecated, renamed: "enumHeader.genericParameterClause") public var genericParameters: GenericParameterClauseSyntax? { get { - return genericParameterClause + return enumHeader.genericParameterClause } set { - genericParameterClause = newValue + enumHeader.genericParameterClause = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenGenericParameterClauseAndInheritanceClause") + @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause") public var unexpectedBetweenGenericParametersAndInheritanceClause: UnexpectedNodesSyntax? { get { - return unexpectedBetweenGenericParameterClauseAndInheritanceClause + return enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause } set { - unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue + enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue } } - @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:enumKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)") + @available(*, deprecated, renamed: "init(leadingTrivia:_:enumHeader:_:memberBlock:_:trailingTrivia:)") + @_disfavoredOverload + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + _ unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil, + enumKeyword: TokenSyntax = .keyword(.enum), + _ unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + enumHeader: EnumDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndEnumKeyword, + enumKeyword: enumKeyword, + unexpectedBetweenEnumKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: memberBlock, + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } + + @available(*, deprecated, renamed: "init(leadingTrivia:_:enumHeader:_:memberBlock:_:trailingTrivia:)") @_disfavoredOverload public init( leadingTrivia: Trivia? = nil, @@ -2650,19 +3248,21 @@ extension EnumDeclSyntax { self.init( leadingTrivia: leadingTrivia, unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndEnumKeyword, - enumKeyword: enumKeyword, - unexpectedBetweenEnumKeywordAndIdentifier, - name: identifier, - unexpectedBetweenIdentifierAndGenericParameters, - genericParameterClause: genericParameters, - unexpectedBetweenGenericParametersAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, + enumHeader: EnumDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndEnumKeyword, + enumKeyword: enumKeyword, + unexpectedBetweenEnumKeywordAndIdentifier, + name: identifier, + unexpectedBetweenIdentifierAndGenericParameters, + genericParameterClause: genericParameters, + unexpectedBetweenGenericParametersAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock: memberBlock, unexpectedAfterMemberBlock, @@ -2737,6 +3337,182 @@ extension ExpressionSegmentSyntax { } } +extension ExtensionDeclSyntax { + @available(*, deprecated, renamed: "unexpectedBeforeExtensionHeader") + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return unexpectedBeforeExtensionHeader + } + set { + unexpectedBeforeExtensionHeader = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.attributes") + public var attributes: AttributeListSyntax { + get { + return extensionHeader.attributes + } + set { + extensionHeader.attributes = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenAttributesAndModifiers") + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return extensionHeader.unexpectedBetweenAttributesAndModifiers + } + set { + extensionHeader.unexpectedBetweenAttributesAndModifiers = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.modifiers") + public var modifiers: DeclModifierListSyntax { + get { + return extensionHeader.modifiers + } + set { + extensionHeader.modifiers = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenModifiersAndExtensionKeyword") + public var unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? { + get { + return extensionHeader.unexpectedBetweenModifiersAndExtensionKeyword + } + set { + extensionHeader.unexpectedBetweenModifiersAndExtensionKeyword = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.extensionKeyword") + public var extensionKeyword: TokenSyntax { + get { + return extensionHeader.extensionKeyword + } + set { + extensionHeader.extensionKeyword = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenExtensionKeywordAndExtendedType") + public var unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? { + get { + return extensionHeader.unexpectedBetweenExtensionKeywordAndExtendedType + } + set { + extensionHeader.unexpectedBetweenExtensionKeywordAndExtendedType = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.extendedType") + public var extendedType: TypeSyntax { + get { + return extensionHeader.extendedType + } + set { + extensionHeader.extendedType = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenExtendedTypeAndInheritanceClause") + public var unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? { + get { + return extensionHeader.unexpectedBetweenExtendedTypeAndInheritanceClause + } + set { + extensionHeader.unexpectedBetweenExtendedTypeAndInheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.inheritanceClause") + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return extensionHeader.inheritanceClause + } + set { + extensionHeader.inheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause") + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? { + get { + return extensionHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause + } + set { + extensionHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "extensionHeader.genericWhereClause") + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return extensionHeader.genericWhereClause + } + set { + extensionHeader.genericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedBetweenExtensionHeaderAndMemberBlock") + public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + get { + return unexpectedBetweenExtensionHeaderAndMemberBlock + } + set { + unexpectedBetweenExtensionHeaderAndMemberBlock = newValue + } + } + + @available(*, deprecated, renamed: "init(leadingTrivia:_:extensionHeader:_:memberBlock:_:trailingTrivia:)") + @_disfavoredOverload + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + _ unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil, + extensionKeyword: TokenSyntax = .keyword(.extension), + _ unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil, + extendedType: some TypeSyntaxProtocol, + _ unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + extensionHeader: ExtensionDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndExtensionKeyword, + extensionKeyword: extensionKeyword, + unexpectedBetweenExtensionKeywordAndExtendedType, + extendedType: extendedType, + unexpectedBetweenExtendedTypeAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: memberBlock, + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } +} + extension FloatLiteralExprSyntax { @available(*, deprecated, renamed: "unexpectedBeforeLiteral") public var unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? { @@ -6278,125 +7054,323 @@ extension PrimaryAssociatedTypeClauseSyntax { } } - @available(*, deprecated, renamed: "leftAngle") - public var leftAngleBracket: TokenSyntax { + @available(*, deprecated, renamed: "leftAngle") + public var leftAngleBracket: TokenSyntax { + get { + return leftAngle + } + set { + leftAngle = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes") + public var unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? { + get { + return unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes + } + set { + unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes = newValue + } + } + + @available(*, deprecated, renamed: "primaryAssociatedTypes") + public var primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax { + get { + return primaryAssociatedTypes + } + set { + primaryAssociatedTypes = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedBetweenPrimaryAssociatedTypesAndRightAngle") + public var unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? { + get { + return unexpectedBetweenPrimaryAssociatedTypesAndRightAngle + } + set { + unexpectedBetweenPrimaryAssociatedTypesAndRightAngle = newValue + } + } + + @available(*, deprecated, renamed: "rightAngle") + public var rightAngleBracket: TokenSyntax { + get { + return rightAngle + } + set { + rightAngle = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedAfterRightAngle") + public var unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? { + get { + return unexpectedAfterRightAngle + } + set { + unexpectedAfterRightAngle = newValue + } + } + + @available(*, deprecated, renamed: "init(leadingTrivia:_:leftAngle:_:primaryAssociatedTypes:_:rightAngle:_:trailingTrivia:)") + @_disfavoredOverload + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, + leftAngleBracket: TokenSyntax = .leftAngleToken(), + _ unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? = nil, + primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax, + _ unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? = nil, + rightAngleBracket: TokenSyntax = .rightAngleToken(), + _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeLeftAngleBracket, + leftAngle: leftAngleBracket, + unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList, + primaryAssociatedTypes: primaryAssociatedTypeList, + unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket, + rightAngle: rightAngleBracket, + unexpectedAfterRightAngleBracket, + trailingTrivia: trailingTrivia + ) + } +} + +extension ProtocolDeclSyntax { + @available(*, deprecated, renamed: "unexpectedBeforeProtocolHeader") + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return unexpectedBeforeProtocolHeader + } + set { + unexpectedBeforeProtocolHeader = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.attributes") + public var attributes: AttributeListSyntax { + get { + return protocolHeader.attributes + } + set { + protocolHeader.attributes = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenAttributesAndModifiers") + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return protocolHeader.unexpectedBetweenAttributesAndModifiers + } + set { + protocolHeader.unexpectedBetweenAttributesAndModifiers = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.modifiers") + public var modifiers: DeclModifierListSyntax { + get { + return protocolHeader.modifiers + } + set { + protocolHeader.modifiers = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenModifiersAndProtocolKeyword") + public var unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? { + get { + return protocolHeader.unexpectedBetweenModifiersAndProtocolKeyword + } + set { + protocolHeader.unexpectedBetweenModifiersAndProtocolKeyword = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.protocolKeyword") + public var protocolKeyword: TokenSyntax { + get { + return protocolHeader.protocolKeyword + } + set { + protocolHeader.protocolKeyword = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenProtocolKeywordAndName") + public var unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? { + get { + return protocolHeader.unexpectedBetweenProtocolKeywordAndName + } + set { + protocolHeader.unexpectedBetweenProtocolKeywordAndName = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.name") + public var name: TokenSyntax { + get { + return protocolHeader.name + } + set { + protocolHeader.name = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause") + public var unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? { + get { + return protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause + } + set { + protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause = newValue + } + } + + @available(*, deprecated, renamed: "protocolHeader.primaryAssociatedTypeClause") + public var primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? { get { - return leftAngle + return protocolHeader.primaryAssociatedTypeClause } set { - leftAngle = newValue + protocolHeader.primaryAssociatedTypeClause = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes") - public var unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? { + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause") + public var unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? { get { - return unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes + return protocolHeader.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause } set { - unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes = newValue + protocolHeader.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause = newValue } } - @available(*, deprecated, renamed: "primaryAssociatedTypes") - public var primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax { + @available(*, deprecated, renamed: "protocolHeader.inheritanceClause") + public var inheritanceClause: InheritanceClauseSyntax? { get { - return primaryAssociatedTypes + return protocolHeader.inheritanceClause } set { - primaryAssociatedTypes = newValue + protocolHeader.inheritanceClause = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenPrimaryAssociatedTypesAndRightAngle") - public var unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? { + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause") + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? { get { - return unexpectedBetweenPrimaryAssociatedTypesAndRightAngle + return protocolHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause } set { - unexpectedBetweenPrimaryAssociatedTypesAndRightAngle = newValue + protocolHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue } } - @available(*, deprecated, renamed: "rightAngle") - public var rightAngleBracket: TokenSyntax { + @available(*, deprecated, renamed: "protocolHeader.genericWhereClause") + public var genericWhereClause: GenericWhereClauseSyntax? { get { - return rightAngle + return protocolHeader.genericWhereClause } set { - rightAngle = newValue + protocolHeader.genericWhereClause = newValue } } - @available(*, deprecated, renamed: "unexpectedAfterRightAngle") - public var unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? { + @available(*, deprecated, renamed: "unexpectedBetweenProtocolHeaderAndMemberBlock") + public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { get { - return unexpectedAfterRightAngle + return unexpectedBetweenProtocolHeaderAndMemberBlock } set { - unexpectedAfterRightAngle = newValue + unexpectedBetweenProtocolHeaderAndMemberBlock = newValue } } - @available(*, deprecated, renamed: "init(leadingTrivia:_:leftAngle:_:primaryAssociatedTypes:_:rightAngle:_:trailingTrivia:)") - @_disfavoredOverload - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, - leftAngleBracket: TokenSyntax = .leftAngleToken(), - _ unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? = nil, - primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax, - _ unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? = nil, - rightAngleBracket: TokenSyntax = .rightAngleToken(), - _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeLeftAngleBracket, - leftAngle: leftAngleBracket, - unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList, - primaryAssociatedTypes: primaryAssociatedTypeList, - unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket, - rightAngle: rightAngleBracket, - unexpectedAfterRightAngleBracket, - trailingTrivia: trailingTrivia - ) - } -} - -extension ProtocolDeclSyntax { - @available(*, deprecated, renamed: "unexpectedBetweenProtocolKeywordAndName") + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenProtocolKeywordAndName") public var unexpectedBetweenProtocolKeywordAndIdentifier: UnexpectedNodesSyntax? { get { - return unexpectedBetweenProtocolKeywordAndName + return protocolHeader.unexpectedBetweenProtocolKeywordAndName } set { - unexpectedBetweenProtocolKeywordAndName = newValue + protocolHeader.unexpectedBetweenProtocolKeywordAndName = newValue } } - @available(*, deprecated, renamed: "name") + @available(*, deprecated, renamed: "protocolHeader.name") public var identifier: TokenSyntax { get { - return name + return protocolHeader.name } set { - name = newValue + protocolHeader.name = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenNameAndPrimaryAssociatedTypeClause") + @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause") public var unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? { get { - return unexpectedBetweenNameAndPrimaryAssociatedTypeClause + return protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause } set { - unexpectedBetweenNameAndPrimaryAssociatedTypeClause = newValue + protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause = newValue } } - @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:protocolKeyword:_:name:_:primaryAssociatedTypeClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)") + @available(*, deprecated, renamed: "init(leadingTrivia:_:protocolHeader:_:memberBlock:_:trailingTrivia:)") + @_disfavoredOverload + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + _ unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil, + protocolKeyword: TokenSyntax = .keyword(.protocol), + _ unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil, + primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil, + _ unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + protocolHeader: ProtocolDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndProtocolKeyword, + protocolKeyword: protocolKeyword, + unexpectedBetweenProtocolKeywordAndName, + name: name, + unexpectedBetweenNameAndPrimaryAssociatedTypeClause, + primaryAssociatedTypeClause: primaryAssociatedTypeClause, + unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: memberBlock, + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } + + @available(*, deprecated, renamed: "init(leadingTrivia:_:protocolHeader:_:memberBlock:_:trailingTrivia:)") @_disfavoredOverload public init( leadingTrivia: Trivia? = nil, @@ -6422,19 +7396,21 @@ extension ProtocolDeclSyntax { self.init( leadingTrivia: leadingTrivia, unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndProtocolKeyword, - protocolKeyword: protocolKeyword, - unexpectedBetweenProtocolKeywordAndIdentifier, - name: identifier, - unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause, - primaryAssociatedTypeClause: primaryAssociatedTypeClause, - unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, + protocolHeader: ProtocolDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndProtocolKeyword, + protocolKeyword: protocolKeyword, + unexpectedBetweenProtocolKeywordAndIdentifier, + name: identifier, + unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause, + primaryAssociatedTypeClause: primaryAssociatedTypeClause, + unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock: memberBlock, unexpectedAfterMemberBlock, @@ -7139,37 +8115,235 @@ extension StringLiteralExprSyntax { } extension StructDeclSyntax { - @available(*, deprecated, renamed: "unexpectedBetweenStructKeywordAndName") + @available(*, deprecated, renamed: "unexpectedBeforeStructHeader") + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return unexpectedBeforeStructHeader + } + set { + unexpectedBeforeStructHeader = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.attributes") + public var attributes: AttributeListSyntax { + get { + return structHeader.attributes + } + set { + structHeader.attributes = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenAttributesAndModifiers") + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return structHeader.unexpectedBetweenAttributesAndModifiers + } + set { + structHeader.unexpectedBetweenAttributesAndModifiers = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.modifiers") + public var modifiers: DeclModifierListSyntax { + get { + return structHeader.modifiers + } + set { + structHeader.modifiers = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenModifiersAndStructKeyword") + public var unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? { + get { + return structHeader.unexpectedBetweenModifiersAndStructKeyword + } + set { + structHeader.unexpectedBetweenModifiersAndStructKeyword = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.structKeyword") + public var structKeyword: TokenSyntax { + get { + return structHeader.structKeyword + } + set { + structHeader.structKeyword = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenStructKeywordAndName") + public var unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? { + get { + return structHeader.unexpectedBetweenStructKeywordAndName + } + set { + structHeader.unexpectedBetweenStructKeywordAndName = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.name") + public var name: TokenSyntax { + get { + return structHeader.name + } + set { + structHeader.name = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenNameAndGenericParameterClause") + public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? { + get { + return structHeader.unexpectedBetweenNameAndGenericParameterClause + } + set { + structHeader.unexpectedBetweenNameAndGenericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.genericParameterClause") + public var genericParameterClause: GenericParameterClauseSyntax? { + get { + return structHeader.genericParameterClause + } + set { + structHeader.genericParameterClause = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause") + public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? { + get { + return structHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause + } + set { + structHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.inheritanceClause") + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return structHeader.inheritanceClause + } + set { + structHeader.inheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause") + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? { + get { + return structHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause + } + set { + structHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.genericWhereClause") + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return structHeader.genericWhereClause + } + set { + structHeader.genericWhereClause = newValue + } + } + + @available(*, deprecated, renamed: "unexpectedBetweenStructHeaderAndMemberBlock") + public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + get { + return unexpectedBetweenStructHeaderAndMemberBlock + } + set { + unexpectedBetweenStructHeaderAndMemberBlock = newValue + } + } + + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenStructKeywordAndName") public var unexpectedBetweenStructKeywordAndIdentifier: UnexpectedNodesSyntax? { get { - return unexpectedBetweenStructKeywordAndName + return structHeader.unexpectedBetweenStructKeywordAndName } set { - unexpectedBetweenStructKeywordAndName = newValue + structHeader.unexpectedBetweenStructKeywordAndName = newValue } } - @available(*, deprecated, renamed: "name") + @available(*, deprecated, renamed: "structHeader.name") public var identifier: TokenSyntax { get { - return name + return structHeader.name } set { - name = newValue + structHeader.name = newValue } } - @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause") + @available(*, deprecated, renamed: "structHeader.unexpectedBetweenNameAndGenericParameterClause") public var unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? { get { - return unexpectedBetweenNameAndGenericParameterClause + return structHeader.unexpectedBetweenNameAndGenericParameterClause } set { - unexpectedBetweenNameAndGenericParameterClause = newValue + structHeader.unexpectedBetweenNameAndGenericParameterClause = newValue } } - @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:structKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)") + @available(*, deprecated, renamed: "init(leadingTrivia:_:structHeader:_:memberBlock:_:trailingTrivia:)") + @_disfavoredOverload + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + _ unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil, + structKeyword: TokenSyntax = .keyword(.struct), + _ unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + structHeader: StructDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndStructKeyword, + structKeyword: structKeyword, + unexpectedBetweenStructKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: memberBlock, + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } + + @available(*, deprecated, renamed: "init(leadingTrivia:_:structHeader:_:memberBlock:_:trailingTrivia:)") @_disfavoredOverload public init( leadingTrivia: Trivia? = nil, @@ -7195,19 +8369,21 @@ extension StructDeclSyntax { self.init( leadingTrivia: leadingTrivia, unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndStructKeyword, - structKeyword: structKeyword, - unexpectedBetweenStructKeywordAndIdentifier, - name: identifier, - unexpectedBetweenIdentifierAndGenericParameterClause, - genericParameterClause: genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, + structHeader: StructDeclHeaderSyntax( + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndStructKeyword, + structKeyword: structKeyword, + unexpectedBetweenStructKeywordAndIdentifier, + name: identifier, + unexpectedBetweenIdentifierAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause + ), unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock: memberBlock, unexpectedAfterMemberBlock, @@ -8560,6 +9736,58 @@ extension YieldedExpressionsClauseSyntax { } } +extension DeclGroupSyntax { + @available(*, deprecated, renamed: "header.attributes") + public var attributes: AttributeListSyntax { + get { + return header.attributes + } + set { + header.attributes = newValue + } + } + + @available(*, deprecated, renamed: "header.modifiers") + public var modifiers: DeclModifierListSyntax { + get { + return header.modifiers + } + set { + header.modifiers = newValue + } + } + + @available(*, deprecated, renamed: "header.introducer") + public var introducer: TokenSyntax { + get { + return header.introducer + } + set { + header.introducer = newValue + } + } + + @available(*, deprecated, renamed: "header.inheritanceClause") + public var inheritanceClause: InheritanceClauseSyntax? { + get { + return header.inheritanceClause + } + set { + header.inheritanceClause = newValue + } + } + + @available(*, deprecated, renamed: "header.genericWhereClause") + public var genericWhereClause: GenericWhereClauseSyntax? { + get { + return header.genericWhereClause + } + set { + header.genericWhereClause = newValue + } + } +} + extension FreestandingMacroExpansionSyntax { @available(*, deprecated, renamed: "pound") public var poundToken: TokenSyntax { diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 46d64fb2696..65e48997966 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -96,6 +96,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ActorDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ActorDeclHeaderSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: ActorDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -320,6 +328,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ClassDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ClassDeclHeaderSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -846,6 +862,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: EnumDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: EnumDeclHeaderSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -894,6 +918,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ExtensionDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ExtensionDeclHeaderSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -1824,6 +1856,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ProtocolDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ProtocolDeclHeaderSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -1968,6 +2008,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: StructDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: StructDeclHeaderSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index bf1b9a45d7d..069187a1e51 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -193,7 +193,13 @@ extension Syntax { /// ### Subtypes /// +/// - ``ActorDeclHeaderSyntax`` +/// - ``ClassDeclHeaderSyntax`` +/// - ``EnumDeclHeaderSyntax`` +/// - ``ExtensionDeclHeaderSyntax`` /// - ``MissingDeclHeaderSyntax`` +/// - ``ProtocolDeclHeaderSyntax`` +/// - ``StructDeclHeaderSyntax`` public struct DeclGroupHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax @@ -230,7 +236,7 @@ public struct DeclGroupHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashab public init?(_ node: __shared some SyntaxProtocol) { switch node.raw.kind { - case .missingDeclHeader: + case .actorDeclHeader, .classDeclHeader, .enumDeclHeader, .extensionDeclHeader, .missingDeclHeader, .protocolDeclHeader, .structDeclHeader: self._syntaxNode = node._syntaxNode default: return nil @@ -255,7 +261,14 @@ public struct DeclGroupHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashab public static var structure: SyntaxNodeStructure { return .choices([ - .node(MissingDeclHeaderSyntax.self)]) + .node(ActorDeclHeaderSyntax.self), + .node(ClassDeclHeaderSyntax.self), + .node(EnumDeclHeaderSyntax.self), + .node(ExtensionDeclHeaderSyntax.self), + .node(MissingDeclHeaderSyntax.self), + .node(ProtocolDeclHeaderSyntax.self), + .node(StructDeclHeaderSyntax.self) + ]) } public var attributes: AttributeListSyntax { @@ -1882,6 +1895,7 @@ extension Syntax { .node(AccessorDeclSyntax.self), .node(AccessorEffectSpecifiersSyntax.self), .node(AccessorParametersSyntax.self), + .node(ActorDeclHeaderSyntax.self), .node(ActorDeclSyntax.self), .node(ArrayElementListSyntax.self), .node(ArrayElementSyntax.self), @@ -1910,6 +1924,7 @@ extension Syntax { .node(CatchClauseSyntax.self), .node(CatchItemListSyntax.self), .node(CatchItemSyntax.self), + .node(ClassDeclHeaderSyntax.self), .node(ClassDeclSyntax.self), .node(ClassRestrictionTypeSyntax.self), .node(ClosureCaptureClauseSyntax.self), @@ -1975,12 +1990,14 @@ extension Syntax { .node(EnumCaseParameterClauseSyntax.self), .node(EnumCaseParameterListSyntax.self), .node(EnumCaseParameterSyntax.self), + .node(EnumDeclHeaderSyntax.self), .node(EnumDeclSyntax.self), .node(ExposeAttributeArgumentsSyntax.self), .node(ExprListSyntax.self), .node(ExpressionPatternSyntax.self), .node(ExpressionSegmentSyntax.self), .node(ExpressionStmtSyntax.self), + .node(ExtensionDeclHeaderSyntax.self), .node(ExtensionDeclSyntax.self), .node(FallThroughStmtSyntax.self), .node(FloatLiteralExprSyntax.self), @@ -2095,6 +2112,7 @@ extension Syntax { .node(PrimaryAssociatedTypeClauseSyntax.self), .node(PrimaryAssociatedTypeListSyntax.self), .node(PrimaryAssociatedTypeSyntax.self), + .node(ProtocolDeclHeaderSyntax.self), .node(ProtocolDeclSyntax.self), .node(RegexLiteralExprSyntax.self), .node(RepeatStmtSyntax.self), @@ -2113,6 +2131,7 @@ extension Syntax { .node(StringLiteralExprSyntax.self), .node(StringLiteralSegmentListSyntax.self), .node(StringSegmentSyntax.self), + .node(StructDeclHeaderSyntax.self), .node(StructDeclSyntax.self), .node(SubscriptCallExprSyntax.self), .node(SubscriptDeclSyntax.self), diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift index 6240a612ab1..4723f9facae 100644 --- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift +++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift @@ -76,18 +76,18 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { /// ### Contained in /// /// - ``AccessorDeclSyntax``.``AccessorDeclSyntax/attributes`` -/// - ``ActorDeclSyntax``.``ActorDeclSyntax/attributes`` +/// - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/attributes`` /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/attributes`` /// - ``AttributedTypeSyntax``.``AttributedTypeSyntax/attributes`` -/// - ``ClassDeclSyntax``.``ClassDeclSyntax/attributes`` +/// - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/attributes`` /// - ``ClosureParameterSyntax``.``ClosureParameterSyntax/attributes`` /// - ``ClosureSignatureSyntax``.``ClosureSignatureSyntax/attributes`` /// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/attributes`` /// - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/attributes`` /// - ``EditorPlaceholderDeclSyntax``.``EditorPlaceholderDeclSyntax/attributes`` /// - ``EnumCaseDeclSyntax``.``EnumCaseDeclSyntax/attributes`` -/// - ``EnumDeclSyntax``.``EnumDeclSyntax/attributes`` -/// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/attributes`` +/// - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/attributes`` +/// - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/attributes`` /// - ``FunctionDeclSyntax``.``FunctionDeclSyntax/attributes`` /// - ``FunctionParameterSyntax``.``FunctionParameterSyntax/attributes`` /// - ``GenericParameterSyntax``.``GenericParameterSyntax/attributes`` @@ -99,8 +99,8 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { /// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/attributes`` /// - ``MissingDeclSyntax``.``MissingDeclSyntax/attributes`` /// - ``PrecedenceGroupDeclSyntax``.``PrecedenceGroupDeclSyntax/attributes`` -/// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/attributes`` -/// - ``StructDeclSyntax``.``StructDeclSyntax/attributes`` +/// - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/attributes`` +/// - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/attributes`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/attributes`` /// - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/attributes`` /// - ``VariableDeclSyntax``.``VariableDeclSyntax/attributes`` @@ -424,17 +424,17 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { /// /// ### Contained in /// -/// - ``ActorDeclSyntax``.``ActorDeclSyntax/modifiers`` +/// - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/modifiers`` /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/modifiers`` -/// - ``ClassDeclSyntax``.``ClassDeclSyntax/modifiers`` +/// - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/modifiers`` /// - ``ClosureParameterSyntax``.``ClosureParameterSyntax/modifiers`` /// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/modifiers`` /// - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/modifiers`` /// - ``EditorPlaceholderDeclSyntax``.``EditorPlaceholderDeclSyntax/modifiers`` /// - ``EnumCaseDeclSyntax``.``EnumCaseDeclSyntax/modifiers`` /// - ``EnumCaseParameterSyntax``.``EnumCaseParameterSyntax/modifiers`` -/// - ``EnumDeclSyntax``.``EnumDeclSyntax/modifiers`` -/// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/modifiers`` +/// - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/modifiers`` +/// - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/modifiers`` /// - ``FunctionDeclSyntax``.``FunctionDeclSyntax/modifiers`` /// - ``FunctionParameterSyntax``.``FunctionParameterSyntax/modifiers`` /// - ``ImportDeclSyntax``.``ImportDeclSyntax/modifiers`` @@ -444,8 +444,8 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { /// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/modifiers`` /// - ``MissingDeclSyntax``.``MissingDeclSyntax/modifiers`` /// - ``PrecedenceGroupDeclSyntax``.``PrecedenceGroupDeclSyntax/modifiers`` -/// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/modifiers`` -/// - ``StructDeclSyntax``.``StructDeclSyntax/modifiers`` +/// - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/modifiers`` +/// - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/modifiers`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/modifiers`` /// - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/modifiers`` /// - ``VariableDeclSyntax``.``VariableDeclSyntax/modifiers`` diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index fbd2638a217..c8365b1d95e 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -20,6 +20,7 @@ public enum SyntaxEnum: Sendable { case accessorDecl(AccessorDeclSyntax) case accessorEffectSpecifiers(AccessorEffectSpecifiersSyntax) case accessorParameters(AccessorParametersSyntax) + case actorDeclHeader(ActorDeclHeaderSyntax) case actorDecl(ActorDeclSyntax) case arrayElementList(ArrayElementListSyntax) case arrayElement(ArrayElementSyntax) @@ -48,6 +49,7 @@ public enum SyntaxEnum: Sendable { case catchClause(CatchClauseSyntax) case catchItemList(CatchItemListSyntax) case catchItem(CatchItemSyntax) + case classDeclHeader(ClassDeclHeaderSyntax) case classDecl(ClassDeclSyntax) case classRestrictionType(ClassRestrictionTypeSyntax) case closureCaptureClause(ClosureCaptureClauseSyntax) @@ -116,12 +118,14 @@ public enum SyntaxEnum: Sendable { case enumCaseParameterClause(EnumCaseParameterClauseSyntax) case enumCaseParameterList(EnumCaseParameterListSyntax) case enumCaseParameter(EnumCaseParameterSyntax) + case enumDeclHeader(EnumDeclHeaderSyntax) case enumDecl(EnumDeclSyntax) case exposeAttributeArguments(ExposeAttributeArgumentsSyntax) case exprList(ExprListSyntax) case expressionPattern(ExpressionPatternSyntax) case expressionSegment(ExpressionSegmentSyntax) case expressionStmt(ExpressionStmtSyntax) + case extensionDeclHeader(ExtensionDeclHeaderSyntax) case extensionDecl(ExtensionDeclSyntax) case fallThroughStmt(FallThroughStmtSyntax) case floatLiteralExpr(FloatLiteralExprSyntax) @@ -245,6 +249,7 @@ public enum SyntaxEnum: Sendable { case primaryAssociatedTypeClause(PrimaryAssociatedTypeClauseSyntax) case primaryAssociatedTypeList(PrimaryAssociatedTypeListSyntax) case primaryAssociatedType(PrimaryAssociatedTypeSyntax) + case protocolDeclHeader(ProtocolDeclHeaderSyntax) case protocolDecl(ProtocolDeclSyntax) case regexLiteralExpr(RegexLiteralExprSyntax) case repeatStmt(RepeatStmtSyntax) @@ -263,6 +268,7 @@ public enum SyntaxEnum: Sendable { case stringLiteralExpr(StringLiteralExprSyntax) case stringLiteralSegmentList(StringLiteralSegmentListSyntax) case stringSegment(StringSegmentSyntax) + case structDeclHeader(StructDeclHeaderSyntax) case structDecl(StructDeclSyntax) case subscriptCallExpr(SubscriptCallExprSyntax) case subscriptDecl(SubscriptDeclSyntax) @@ -332,6 +338,8 @@ extension Syntax { return .accessorEffectSpecifiers(AccessorEffectSpecifiersSyntax(self)!) case .accessorParameters: return .accessorParameters(AccessorParametersSyntax(self)!) + case .actorDeclHeader: + return .actorDeclHeader(ActorDeclHeaderSyntax(self)!) case .actorDecl: return .actorDecl(ActorDeclSyntax(self)!) case .arrayElementList: @@ -388,6 +396,8 @@ extension Syntax { return .catchItemList(CatchItemListSyntax(self)!) case .catchItem: return .catchItem(CatchItemSyntax(self)!) + case .classDeclHeader: + return .classDeclHeader(ClassDeclHeaderSyntax(self)!) case .classDecl: return .classDecl(ClassDeclSyntax(self)!) case .classRestrictionType: @@ -518,6 +528,8 @@ extension Syntax { return .enumCaseParameterList(EnumCaseParameterListSyntax(self)!) case .enumCaseParameter: return .enumCaseParameter(EnumCaseParameterSyntax(self)!) + case .enumDeclHeader: + return .enumDeclHeader(EnumDeclHeaderSyntax(self)!) case .enumDecl: return .enumDecl(EnumDeclSyntax(self)!) case .exposeAttributeArguments: @@ -530,6 +542,8 @@ extension Syntax { return .expressionSegment(ExpressionSegmentSyntax(self)!) case .expressionStmt: return .expressionStmt(ExpressionStmtSyntax(self)!) + case .extensionDeclHeader: + return .extensionDeclHeader(ExtensionDeclHeaderSyntax(self)!) case .extensionDecl: return .extensionDecl(ExtensionDeclSyntax(self)!) case .fallThroughStmt: @@ -758,6 +772,8 @@ extension Syntax { return .primaryAssociatedTypeList(PrimaryAssociatedTypeListSyntax(self)!) case .primaryAssociatedType: return .primaryAssociatedType(PrimaryAssociatedTypeSyntax(self)!) + case .protocolDeclHeader: + return .protocolDeclHeader(ProtocolDeclHeaderSyntax(self)!) case .protocolDecl: return .protocolDecl(ProtocolDeclSyntax(self)!) case .regexLiteralExpr: @@ -794,6 +810,8 @@ extension Syntax { return .stringLiteralSegmentList(StringLiteralSegmentListSyntax(self)!) case .stringSegment: return .stringSegment(StringSegmentSyntax(self)!) + case .structDeclHeader: + return .structDeclHeader(StructDeclHeaderSyntax(self)!) case .structDecl: return .structDecl(StructDeclSyntax(self)!) case .subscriptCallExpr: @@ -896,15 +914,33 @@ extension Syntax { /// Enum to exhaustively switch over all different DeclGroupHeader syntax nodes. public enum DeclGroupHeaderSyntaxEnum { + case actorDeclHeader(ActorDeclHeaderSyntax) + case classDeclHeader(ClassDeclHeaderSyntax) + case enumDeclHeader(EnumDeclHeaderSyntax) + case extensionDeclHeader(ExtensionDeclHeaderSyntax) case missingDeclHeader(MissingDeclHeaderSyntax) + case protocolDeclHeader(ProtocolDeclHeaderSyntax) + case structDeclHeader(StructDeclHeaderSyntax) } extension DeclGroupHeaderSyntax { /// Get an enum that can be used to exhaustively switch over all DeclGroupHeader syntax nodes. public func `as`(_: DeclGroupHeaderSyntaxEnum.Type) -> DeclGroupHeaderSyntaxEnum { switch raw.kind { + case .actorDeclHeader: + return .actorDeclHeader(ActorDeclHeaderSyntax(self)!) + case .classDeclHeader: + return .classDeclHeader(ClassDeclHeaderSyntax(self)!) + case .enumDeclHeader: + return .enumDeclHeader(EnumDeclHeaderSyntax(self)!) + case .extensionDeclHeader: + return .extensionDeclHeader(ExtensionDeclHeaderSyntax(self)!) case .missingDeclHeader: return .missingDeclHeader(MissingDeclHeaderSyntax(self)!) + case .protocolDeclHeader: + return .protocolDeclHeader(ProtocolDeclHeaderSyntax(self)!) + case .structDeclHeader: + return .structDeclHeader(StructDeclHeaderSyntax(self)!) default: preconditionFailure("unknown DeclGroupHeader syntax kind") } diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index a5e7c0a3a52..65f0272dc18 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -20,6 +20,7 @@ public enum SyntaxKind: Sendable { case accessorDecl case accessorEffectSpecifiers case accessorParameters + case actorDeclHeader case actorDecl case arrayElementList case arrayElement @@ -48,6 +49,7 @@ public enum SyntaxKind: Sendable { case catchClause case catchItemList case catchItem + case classDeclHeader case classDecl case classRestrictionType case closureCaptureClause @@ -116,12 +118,14 @@ public enum SyntaxKind: Sendable { case enumCaseParameterClause case enumCaseParameterList case enumCaseParameter + case enumDeclHeader case enumDecl case exposeAttributeArguments case exprList case expressionPattern case expressionSegment case expressionStmt + case extensionDeclHeader case extensionDecl case fallThroughStmt case floatLiteralExpr @@ -245,6 +249,7 @@ public enum SyntaxKind: Sendable { case primaryAssociatedTypeClause case primaryAssociatedTypeList case primaryAssociatedType + case protocolDeclHeader case protocolDecl case regexLiteralExpr case repeatStmt @@ -263,6 +268,7 @@ public enum SyntaxKind: Sendable { case stringLiteralExpr case stringLiteralSegmentList case stringSegment + case structDeclHeader case structDecl case subscriptCallExpr case subscriptDecl @@ -459,6 +465,8 @@ public enum SyntaxKind: Sendable { return AccessorEffectSpecifiersSyntax.self case .accessorParameters: return AccessorParametersSyntax.self + case .actorDeclHeader: + return ActorDeclHeaderSyntax.self case .actorDecl: return ActorDeclSyntax.self case .arrayElementList: @@ -515,6 +523,8 @@ public enum SyntaxKind: Sendable { return CatchItemListSyntax.self case .catchItem: return CatchItemSyntax.self + case .classDeclHeader: + return ClassDeclHeaderSyntax.self case .classDecl: return ClassDeclSyntax.self case .classRestrictionType: @@ -645,6 +655,8 @@ public enum SyntaxKind: Sendable { return EnumCaseParameterListSyntax.self case .enumCaseParameter: return EnumCaseParameterSyntax.self + case .enumDeclHeader: + return EnumDeclHeaderSyntax.self case .enumDecl: return EnumDeclSyntax.self case .exposeAttributeArguments: @@ -657,6 +669,8 @@ public enum SyntaxKind: Sendable { return ExpressionSegmentSyntax.self case .expressionStmt: return ExpressionStmtSyntax.self + case .extensionDeclHeader: + return ExtensionDeclHeaderSyntax.self case .extensionDecl: return ExtensionDeclSyntax.self case .fallThroughStmt: @@ -885,6 +899,8 @@ public enum SyntaxKind: Sendable { return PrimaryAssociatedTypeListSyntax.self case .primaryAssociatedType: return PrimaryAssociatedTypeSyntax.self + case .protocolDeclHeader: + return ProtocolDeclHeaderSyntax.self case .protocolDecl: return ProtocolDeclSyntax.self case .regexLiteralExpr: @@ -921,6 +937,8 @@ public enum SyntaxKind: Sendable { return StringLiteralSegmentListSyntax.self case .stringSegment: return StringSegmentSyntax.self + case .structDeclHeader: + return StructDeclHeaderSyntax.self case .structDecl: return StructDeclSyntax.self case .subscriptCallExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index a484df0190a..6642d356fa1 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -141,6 +141,13 @@ open class SyntaxRewriter { return visitChildren(node._syntaxNode).cast(AccessorParametersSyntax.self) } + /// Visit a ``ActorDeclHeaderSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ActorDeclHeaderSyntax) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ActorDeclHeaderSyntax.self)) + } + /// Visit a ``ActorDeclSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -337,6 +344,13 @@ open class SyntaxRewriter { return visitChildren(node._syntaxNode).cast(CatchItemSyntax.self) } + /// Visit a ``ClassDeclHeaderSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClassDeclHeaderSyntax) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ClassDeclHeaderSyntax.self)) + } + /// Visit a ``ClassDeclSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -795,6 +809,13 @@ open class SyntaxRewriter { return visitChildren(node._syntaxNode).cast(EnumCaseParameterSyntax.self) } + /// Visit a ``EnumDeclHeaderSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumDeclHeaderSyntax) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(EnumDeclHeaderSyntax.self)) + } + /// Visit a ``EnumDeclSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -837,6 +858,13 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node._syntaxNode).cast(ExpressionStmtSyntax.self)) } + /// Visit a ``ExtensionDeclHeaderSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExtensionDeclHeaderSyntax) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ExtensionDeclHeaderSyntax.self)) + } + /// Visit a ``ExtensionDeclSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1644,6 +1672,13 @@ open class SyntaxRewriter { return visitChildren(node._syntaxNode).cast(PrimaryAssociatedTypeSyntax.self) } + /// Visit a ``ProtocolDeclHeaderSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ProtocolDeclHeaderSyntax) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ProtocolDeclHeaderSyntax.self)) + } + /// Visit a ``ProtocolDeclSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1770,6 +1805,13 @@ open class SyntaxRewriter { return visitChildren(node._syntaxNode).cast(StringSegmentSyntax.self) } + /// Visit a ``StructDeclHeaderSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: StructDeclHeaderSyntax) -> DeclGroupHeaderSyntax { + return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(StructDeclHeaderSyntax.self)) + } + /// Visit a ``StructDeclSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2227,6 +2269,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, AccessorParametersSyntax.self, self.visit) } + case .actorDeclHeader: + return { + self.visitImpl(&$0, ActorDeclHeaderSyntax.self, self.visit) + } case .actorDecl: return { self.visitImpl(&$0, ActorDeclSyntax.self, self.visit) @@ -2339,6 +2385,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, CatchItemSyntax.self, self.visit) } + case .classDeclHeader: + return { + self.visitImpl(&$0, ClassDeclHeaderSyntax.self, self.visit) + } case .classDecl: return { self.visitImpl(&$0, ClassDeclSyntax.self, self.visit) @@ -2599,6 +2649,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, EnumCaseParameterSyntax.self, self.visit) } + case .enumDeclHeader: + return { + self.visitImpl(&$0, EnumDeclHeaderSyntax.self, self.visit) + } case .enumDecl: return { self.visitImpl(&$0, EnumDeclSyntax.self, self.visit) @@ -2623,6 +2677,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, ExpressionStmtSyntax.self, self.visit) } + case .extensionDeclHeader: + return { + self.visitImpl(&$0, ExtensionDeclHeaderSyntax.self, self.visit) + } case .extensionDecl: return { self.visitImpl(&$0, ExtensionDeclSyntax.self, self.visit) @@ -3079,6 +3137,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, PrimaryAssociatedTypeSyntax.self, self.visit) } + case .protocolDeclHeader: + return { + self.visitImpl(&$0, ProtocolDeclHeaderSyntax.self, self.visit) + } case .protocolDecl: return { self.visitImpl(&$0, ProtocolDeclSyntax.self, self.visit) @@ -3151,6 +3213,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, StringSegmentSyntax.self, self.visit) } + case .structDeclHeader: + return { + self.visitImpl(&$0, StructDeclHeaderSyntax.self, self.visit) + } case .structDecl: return { self.visitImpl(&$0, StructDeclSyntax.self, self.visit) @@ -3363,6 +3429,8 @@ open class SyntaxRewriter { return visitImpl(&node, AccessorEffectSpecifiersSyntax.self, visit) case .accessorParameters: return visitImpl(&node, AccessorParametersSyntax.self, visit) + case .actorDeclHeader: + return visitImpl(&node, ActorDeclHeaderSyntax.self, visit) case .actorDecl: return visitImpl(&node, ActorDeclSyntax.self, visit) case .arrayElementList: @@ -3419,6 +3487,8 @@ open class SyntaxRewriter { return visitImpl(&node, CatchItemListSyntax.self, visit) case .catchItem: return visitImpl(&node, CatchItemSyntax.self, visit) + case .classDeclHeader: + return visitImpl(&node, ClassDeclHeaderSyntax.self, visit) case .classDecl: return visitImpl(&node, ClassDeclSyntax.self, visit) case .classRestrictionType: @@ -3549,6 +3619,8 @@ open class SyntaxRewriter { return visitImpl(&node, EnumCaseParameterListSyntax.self, visit) case .enumCaseParameter: return visitImpl(&node, EnumCaseParameterSyntax.self, visit) + case .enumDeclHeader: + return visitImpl(&node, EnumDeclHeaderSyntax.self, visit) case .enumDecl: return visitImpl(&node, EnumDeclSyntax.self, visit) case .exposeAttributeArguments: @@ -3561,6 +3633,8 @@ open class SyntaxRewriter { return visitImpl(&node, ExpressionSegmentSyntax.self, visit) case .expressionStmt: return visitImpl(&node, ExpressionStmtSyntax.self, visit) + case .extensionDeclHeader: + return visitImpl(&node, ExtensionDeclHeaderSyntax.self, visit) case .extensionDecl: return visitImpl(&node, ExtensionDeclSyntax.self, visit) case .fallThroughStmt: @@ -3789,6 +3863,8 @@ open class SyntaxRewriter { return visitImpl(&node, PrimaryAssociatedTypeListSyntax.self, visit) case .primaryAssociatedType: return visitImpl(&node, PrimaryAssociatedTypeSyntax.self, visit) + case .protocolDeclHeader: + return visitImpl(&node, ProtocolDeclHeaderSyntax.self, visit) case .protocolDecl: return visitImpl(&node, ProtocolDeclSyntax.self, visit) case .regexLiteralExpr: @@ -3825,6 +3901,8 @@ open class SyntaxRewriter { return visitImpl(&node, StringLiteralSegmentListSyntax.self, visit) case .stringSegment: return visitImpl(&node, StringSegmentSyntax.self, visit) + case .structDeclHeader: + return visitImpl(&node, StructDeclHeaderSyntax.self, visit) case .structDecl: return visitImpl(&node, StructDeclSyntax.self, visit) case .subscriptCallExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index d91d41b47e5..c86d6d7ee3a 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -62,39 +62,8 @@ extension SyntaxProtocol { // MARK: - DeclGroupSyntax public protocol DeclGroupSyntax: SyntaxProtocol, DeclSyntaxProtocol { - var attributes: AttributeListSyntax { - get - set - } - - var modifiers: DeclModifierListSyntax { - get - set - } - - /// The token that introduces this declaration, eg. `class` for a class declaration. - /// - /// ### Tokens - /// - /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds: - /// - `actor` - /// - `class` - /// - `enum` - /// - `extension` - /// - `protocol` - /// - `struct` - var introducer: TokenSyntax { - get - set - } - - var inheritanceClause: InheritanceClauseSyntax? { - get - set - } - - /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`. - var genericWhereClause: GenericWhereClauseSyntax? { + /// The header of the declaration. + var header: DeclGroupHeaderSyntax { get set } @@ -315,6 +284,45 @@ extension SyntaxProtocol { } } +// MARK: - NamedDeclHeaderSyntax + +public protocol NamedDeclHeaderSyntax: SyntaxProtocol, DeclGroupHeaderSyntaxProtocol { + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be ``. + var name: TokenSyntax { + get + set + } +} + +extension NamedDeclHeaderSyntax { + /// Without this function, the `with` function defined on `SyntaxProtocol` + /// does not work on existentials of this protocol type. + @_disfavoredOverload + public func with(_ keyPath: WritableKeyPath, _ newChild: T) -> NamedDeclHeaderSyntax { + var copy: NamedDeclHeaderSyntax = self + copy[keyPath: keyPath] = newChild + return copy + } +} + +extension SyntaxProtocol { + /// Check whether the non-type erased version of this syntax node conforms to + /// `NamedDeclHeaderSyntax`. + /// Note that this will incur an existential conversion. + public func isProtocol(_: NamedDeclHeaderSyntax.Protocol) -> Bool { + return self.asProtocol(NamedDeclHeaderSyntax.self) != nil + } + + /// Return the non-type erased version of this syntax node if it conforms to + /// `NamedDeclHeaderSyntax`. Otherwise return `nil`. + /// Note that this will incur an existential conversion. + public func asProtocol(_: NamedDeclHeaderSyntax.Protocol) -> NamedDeclHeaderSyntax? { + return Syntax(self).asProtocol(SyntaxProtocol.self) as? NamedDeclHeaderSyntax + } +} + // MARK: - MissingNodeSyntax /// Represents a layout node that is missing in the source file. @@ -679,6 +687,8 @@ extension AccessorEffectSpecifiersSyntax: EffectSpecifiersSyntax {} extension AccessorParametersSyntax: ParenthesizedSyntax {} +extension ActorDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} + extension ActorDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} extension ArrayElementSyntax: WithTrailingCommaSyntax {} @@ -693,6 +703,8 @@ extension CatchClauseSyntax: WithCodeBlockSyntax {} extension CatchItemSyntax: WithTrailingCommaSyntax {} +extension ClassDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} + extension ClassDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} extension ClosureCaptureSyntax: WithTrailingCommaSyntax {} @@ -741,10 +753,14 @@ extension EnumCaseParameterClauseSyntax: ParenthesizedSyntax {} extension EnumCaseParameterSyntax: WithTrailingCommaSyntax, WithModifiersSyntax {} +extension EnumDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} + extension EnumDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} extension ExpressionSegmentSyntax: ParenthesizedSyntax {} +extension ExtensionDeclHeaderSyntax: WithAttributesSyntax, WithModifiersSyntax {} + extension ExtensionDeclSyntax: DeclGroupSyntax, WithAttributesSyntax, WithModifiersSyntax {} extension ForStmtSyntax: WithCodeBlockSyntax {} @@ -817,6 +833,8 @@ extension PrecedenceGroupNameSyntax: WithTrailingCommaSyntax {} extension PrimaryAssociatedTypeSyntax: WithTrailingCommaSyntax {} +extension ProtocolDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithModifiersSyntax {} + extension ProtocolDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithModifiersSyntax {} extension RepeatStmtSyntax: WithCodeBlockSyntax {} @@ -825,6 +843,8 @@ extension SourceFileSyntax: WithStatementsSyntax {} extension SpecializeTargetFunctionArgumentSyntax: WithTrailingCommaSyntax {} +extension StructDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} + extension StructDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} extension SubscriptDeclSyntax: WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index 6bd63289b51..ef487d6b92b 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -98,6 +98,18 @@ open class SyntaxVisitor { open func visitPost(_ node: AccessorParametersSyntax) { } + /// Visiting ``ActorDeclHeaderSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ActorDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``ActorDeclHeaderSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ActorDeclHeaderSyntax) { + } + /// Visiting ``ActorDeclSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -434,6 +446,18 @@ open class SyntaxVisitor { open func visitPost(_ node: CatchItemSyntax) { } + /// Visiting ``ClassDeclHeaderSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ClassDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``ClassDeclHeaderSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ClassDeclHeaderSyntax) { + } + /// Visiting ``ClassDeclSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1220,6 +1244,18 @@ open class SyntaxVisitor { open func visitPost(_ node: EnumCaseParameterSyntax) { } + /// Visiting ``EnumDeclHeaderSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: EnumDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``EnumDeclHeaderSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: EnumDeclHeaderSyntax) { + } + /// Visiting ``EnumDeclSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1292,6 +1328,18 @@ open class SyntaxVisitor { open func visitPost(_ node: ExpressionStmtSyntax) { } + /// Visiting ``ExtensionDeclHeaderSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ExtensionDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``ExtensionDeclHeaderSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ExtensionDeclHeaderSyntax) { + } + /// Visiting ``ExtensionDeclSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -2678,6 +2726,18 @@ open class SyntaxVisitor { open func visitPost(_ node: PrimaryAssociatedTypeSyntax) { } + /// Visiting ``ProtocolDeclHeaderSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ProtocolDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``ProtocolDeclHeaderSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ProtocolDeclHeaderSyntax) { + } + /// Visiting ``ProtocolDeclSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -2894,6 +2954,18 @@ open class SyntaxVisitor { open func visitPost(_ node: StringSegmentSyntax) { } + /// Visiting ``StructDeclHeaderSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: StructDeclHeaderSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``StructDeclHeaderSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: StructDeclHeaderSyntax) { + } + /// Visiting ``StructDeclSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -3567,6 +3639,10 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, AccessorParametersSyntax.self, self.visit, self.visitPost) } + case .actorDeclHeader: + return { + self.visitImpl(&$0, ActorDeclHeaderSyntax.self, self.visit, self.visitPost) + } case .actorDecl: return { self.visitImpl(&$0, ActorDeclSyntax.self, self.visit, self.visitPost) @@ -3679,6 +3755,10 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, CatchItemSyntax.self, self.visit, self.visitPost) } + case .classDeclHeader: + return { + self.visitImpl(&$0, ClassDeclHeaderSyntax.self, self.visit, self.visitPost) + } case .classDecl: return { self.visitImpl(&$0, ClassDeclSyntax.self, self.visit, self.visitPost) @@ -3939,6 +4019,10 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, EnumCaseParameterSyntax.self, self.visit, self.visitPost) } + case .enumDeclHeader: + return { + self.visitImpl(&$0, EnumDeclHeaderSyntax.self, self.visit, self.visitPost) + } case .enumDecl: return { self.visitImpl(&$0, EnumDeclSyntax.self, self.visit, self.visitPost) @@ -3963,6 +4047,10 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, ExpressionStmtSyntax.self, self.visit, self.visitPost) } + case .extensionDeclHeader: + return { + self.visitImpl(&$0, ExtensionDeclHeaderSyntax.self, self.visit, self.visitPost) + } case .extensionDecl: return { self.visitImpl(&$0, ExtensionDeclSyntax.self, self.visit, self.visitPost) @@ -4419,6 +4507,10 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, PrimaryAssociatedTypeSyntax.self, self.visit, self.visitPost) } + case .protocolDeclHeader: + return { + self.visitImpl(&$0, ProtocolDeclHeaderSyntax.self, self.visit, self.visitPost) + } case .protocolDecl: return { self.visitImpl(&$0, ProtocolDeclSyntax.self, self.visit, self.visitPost) @@ -4491,6 +4583,10 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, StringSegmentSyntax.self, self.visit, self.visitPost) } + case .structDeclHeader: + return { + self.visitImpl(&$0, StructDeclHeaderSyntax.self, self.visit, self.visitPost) + } case .structDecl: return { self.visitImpl(&$0, StructDeclSyntax.self, self.visit, self.visitPost) @@ -4707,6 +4803,8 @@ open class SyntaxVisitor { visitImpl(&node, AccessorEffectSpecifiersSyntax.self, visit, visitPost) case .accessorParameters: visitImpl(&node, AccessorParametersSyntax.self, visit, visitPost) + case .actorDeclHeader: + visitImpl(&node, ActorDeclHeaderSyntax.self, visit, visitPost) case .actorDecl: visitImpl(&node, ActorDeclSyntax.self, visit, visitPost) case .arrayElementList: @@ -4763,6 +4861,8 @@ open class SyntaxVisitor { visitImpl(&node, CatchItemListSyntax.self, visit, visitPost) case .catchItem: visitImpl(&node, CatchItemSyntax.self, visit, visitPost) + case .classDeclHeader: + visitImpl(&node, ClassDeclHeaderSyntax.self, visit, visitPost) case .classDecl: visitImpl(&node, ClassDeclSyntax.self, visit, visitPost) case .classRestrictionType: @@ -4893,6 +4993,8 @@ open class SyntaxVisitor { visitImpl(&node, EnumCaseParameterListSyntax.self, visit, visitPost) case .enumCaseParameter: visitImpl(&node, EnumCaseParameterSyntax.self, visit, visitPost) + case .enumDeclHeader: + visitImpl(&node, EnumDeclHeaderSyntax.self, visit, visitPost) case .enumDecl: visitImpl(&node, EnumDeclSyntax.self, visit, visitPost) case .exposeAttributeArguments: @@ -4905,6 +5007,8 @@ open class SyntaxVisitor { visitImpl(&node, ExpressionSegmentSyntax.self, visit, visitPost) case .expressionStmt: visitImpl(&node, ExpressionStmtSyntax.self, visit, visitPost) + case .extensionDeclHeader: + visitImpl(&node, ExtensionDeclHeaderSyntax.self, visit, visitPost) case .extensionDecl: visitImpl(&node, ExtensionDeclSyntax.self, visit, visitPost) case .fallThroughStmt: @@ -5133,6 +5237,8 @@ open class SyntaxVisitor { visitImpl(&node, PrimaryAssociatedTypeListSyntax.self, visit, visitPost) case .primaryAssociatedType: visitImpl(&node, PrimaryAssociatedTypeSyntax.self, visit, visitPost) + case .protocolDeclHeader: + visitImpl(&node, ProtocolDeclHeaderSyntax.self, visit, visitPost) case .protocolDecl: visitImpl(&node, ProtocolDeclSyntax.self, visit, visitPost) case .regexLiteralExpr: @@ -5169,6 +5275,8 @@ open class SyntaxVisitor { visitImpl(&node, StringLiteralSegmentListSyntax.self, visit, visitPost) case .stringSegment: visitImpl(&node, StringSegmentSyntax.self, visit, visitPost) + case .structDeclHeader: + visitImpl(&node, StructDeclHeaderSyntax.self, visit, visitPost) case .structDecl: visitImpl(&node, StructDeclSyntax.self, visit, visitPost) case .subscriptCallExpr: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift index 33b11426d6c..c92f20165c6 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift @@ -443,14 +443,14 @@ public struct RawAccessorParametersSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawActorDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .actorDecl + return raw.kind == .actorDeclHeader } public var raw: RawSyntax @@ -486,13 +486,11 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { inheritanceClause: RawInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil, - memberBlock: RawMemberBlockSyntax, - _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .actorDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .actorDeclHeader, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes.raw @@ -508,9 +506,7 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { layout[11] = inheritanceClause?.raw layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw - layout[15] = memberBlock.raw - layout[16] = unexpectedAfterMemberBlock?.raw + layout[14] = unexpectedAfterGenericWhereClause?.raw } self.init(unchecked: raw) } @@ -571,16 +567,78 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } +} + +@_spi(RawSyntax) +public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .actorDecl + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeActorHeader: RawUnexpectedNodesSyntax? = nil, + actorHeader: RawActorDeclHeaderSyntax, + _ unexpectedBetweenActorHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil, + memberBlock: RawMemberBlockSyntax, + _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .actorDecl, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeActorHeader?.raw + layout[1] = actorHeader.raw + layout[2] = unexpectedBetweenActorHeaderAndMemberBlock?.raw + layout[3] = memberBlock.raw + layout[4] = unexpectedAfterMemberBlock?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeActorHeader: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var actorHeader: RawActorDeclHeaderSyntax { + layoutView.children[1].map(RawActorDeclHeaderSyntax.init(raw:))! + } + + public var unexpectedBetweenActorHeaderAndMemberBlock: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } public var memberBlock: RawMemberBlockSyntax { - layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))! + layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))! } public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift index 8e4a50643d6..80e85d82b31 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift @@ -477,14 +477,14 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawClassDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .classDecl + return raw.kind == .classDeclHeader } public var raw: RawSyntax @@ -520,13 +520,11 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { inheritanceClause: RawInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil, - memberBlock: RawMemberBlockSyntax, - _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .classDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .classDeclHeader, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes.raw @@ -542,9 +540,7 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { layout[11] = inheritanceClause?.raw layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw - layout[15] = memberBlock.raw - layout[16] = unexpectedAfterMemberBlock?.raw + layout[14] = unexpectedAfterGenericWhereClause?.raw } self.init(unchecked: raw) } @@ -605,16 +601,78 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } +} + +@_spi(RawSyntax) +public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .classDecl + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeClassHeader: RawUnexpectedNodesSyntax? = nil, + classHeader: RawClassDeclHeaderSyntax, + _ unexpectedBetweenClassHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil, + memberBlock: RawMemberBlockSyntax, + _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .classDecl, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeClassHeader?.raw + layout[1] = classHeader.raw + layout[2] = unexpectedBetweenClassHeaderAndMemberBlock?.raw + layout[3] = memberBlock.raw + layout[4] = unexpectedAfterMemberBlock?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeClassHeader: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var classHeader: RawClassDeclHeaderSyntax { + layoutView.children[1].map(RawClassDeclHeaderSyntax.init(raw:))! + } + + public var unexpectedBetweenClassHeaderAndMemberBlock: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } public var memberBlock: RawMemberBlockSyntax { - layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))! + layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))! } public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift index 8929ca7569d..b342367479d 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift @@ -27,7 +27,7 @@ public struct RawDeclGroupHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .missingDeclHeader: + case .actorDeclHeader, .classDeclHeader, .enumDeclHeader, .extensionDeclHeader, .missingDeclHeader, .protocolDeclHeader, .structDeclHeader: return true default: return false diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift index 376db16d670..f6381bb740f 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift @@ -706,14 +706,14 @@ public struct RawEnumCaseParameterSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawEnumDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .enumDecl + return raw.kind == .enumDeclHeader } public var raw: RawSyntax @@ -749,13 +749,11 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { inheritanceClause: RawInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil, - memberBlock: RawMemberBlockSyntax, - _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .enumDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .enumDeclHeader, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes.raw @@ -771,9 +769,7 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { layout[11] = inheritanceClause?.raw layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw - layout[15] = memberBlock.raw - layout[16] = unexpectedAfterMemberBlock?.raw + layout[14] = unexpectedAfterGenericWhereClause?.raw } self.init(unchecked: raw) } @@ -834,16 +830,78 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } +} + +@_spi(RawSyntax) +public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .enumDecl + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeEnumHeader: RawUnexpectedNodesSyntax? = nil, + enumHeader: RawEnumDeclHeaderSyntax, + _ unexpectedBetweenEnumHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil, + memberBlock: RawMemberBlockSyntax, + _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .enumDecl, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeEnumHeader?.raw + layout[1] = enumHeader.raw + layout[2] = unexpectedBetweenEnumHeaderAndMemberBlock?.raw + layout[3] = memberBlock.raw + layout[4] = unexpectedAfterMemberBlock?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeEnumHeader: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var enumHeader: RawEnumDeclHeaderSyntax { + layoutView.children[1].map(RawEnumDeclHeaderSyntax.init(raw:))! + } + + public var unexpectedBetweenEnumHeaderAndMemberBlock: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } public var memberBlock: RawMemberBlockSyntax { - layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))! + layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))! } public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @@ -1241,14 +1299,14 @@ public struct RawExpressionStmtSyntax: RawStmtSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawExtensionDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .extensionDecl + return raw.kind == .extensionDeclHeader } public var raw: RawSyntax @@ -1282,13 +1340,11 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { inheritanceClause: RawInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil, - memberBlock: RawMemberBlockSyntax, - _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .extensionDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .extensionDeclHeader, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes.raw @@ -1302,9 +1358,7 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { layout[9] = inheritanceClause?.raw layout[10] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw layout[11] = genericWhereClause?.raw - layout[12] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw - layout[13] = memberBlock.raw - layout[14] = unexpectedAfterMemberBlock?.raw + layout[12] = unexpectedAfterGenericWhereClause?.raw } self.init(unchecked: raw) } @@ -1357,16 +1411,78 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[11].map(RawGenericWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) } +} + +@_spi(RawSyntax) +public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .extensionDecl + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeExtensionHeader: RawUnexpectedNodesSyntax? = nil, + extensionHeader: RawExtensionDeclHeaderSyntax, + _ unexpectedBetweenExtensionHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil, + memberBlock: RawMemberBlockSyntax, + _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .extensionDecl, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeExtensionHeader?.raw + layout[1] = extensionHeader.raw + layout[2] = unexpectedBetweenExtensionHeaderAndMemberBlock?.raw + layout[3] = memberBlock.raw + layout[4] = unexpectedAfterMemberBlock?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeExtensionHeader: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var extensionHeader: RawExtensionDeclHeaderSyntax { + layoutView.children[1].map(RawExtensionDeclHeaderSyntax.init(raw:))! + } + + public var unexpectedBetweenExtensionHeaderAndMemberBlock: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } public var memberBlock: RawMemberBlockSyntax { - layoutView.children[13].map(RawMemberBlockSyntax.init(raw:))! + layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))! } public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift index e36fb1f30ce..dab4bc4cf20 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift @@ -2675,14 +2675,14 @@ public struct RawPrimaryAssociatedTypeSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawProtocolDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .protocolDecl + return raw.kind == .protocolDeclHeader } public var raw: RawSyntax @@ -2718,13 +2718,11 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { inheritanceClause: RawInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil, - memberBlock: RawMemberBlockSyntax, - _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .protocolDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .protocolDeclHeader, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes.raw @@ -2740,9 +2738,7 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { layout[11] = inheritanceClause?.raw layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw - layout[15] = memberBlock.raw - layout[16] = unexpectedAfterMemberBlock?.raw + layout[14] = unexpectedAfterGenericWhereClause?.raw } self.init(unchecked: raw) } @@ -2803,15 +2799,77 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } +} + +@_spi(RawSyntax) +public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .protocolDecl + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeProtocolHeader: RawUnexpectedNodesSyntax? = nil, + protocolHeader: RawProtocolDeclHeaderSyntax, + _ unexpectedBetweenProtocolHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil, + memberBlock: RawMemberBlockSyntax, + _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .protocolDecl, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeProtocolHeader?.raw + layout[1] = protocolHeader.raw + layout[2] = unexpectedBetweenProtocolHeaderAndMemberBlock?.raw + layout[3] = memberBlock.raw + layout[4] = unexpectedAfterMemberBlock?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeProtocolHeader: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var protocolHeader: RawProtocolDeclHeaderSyntax { + layoutView.children[1].map(RawProtocolDeclHeaderSyntax.init(raw:))! + } + + public var unexpectedBetweenProtocolHeaderAndMemberBlock: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } public var memberBlock: RawMemberBlockSyntax { - layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))! + layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))! } public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift index a2574cdd83e..91d0057f52c 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift @@ -1405,14 +1405,14 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawStructDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .structDecl + return raw.kind == .structDeclHeader } public var raw: RawSyntax @@ -1448,13 +1448,11 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { inheritanceClause: RawInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil, - memberBlock: RawMemberBlockSyntax, - _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .structDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .structDeclHeader, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes.raw @@ -1470,9 +1468,7 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { layout[11] = inheritanceClause?.raw layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw - layout[15] = memberBlock.raw - layout[16] = unexpectedAfterMemberBlock?.raw + layout[14] = unexpectedAfterGenericWhereClause?.raw } self.init(unchecked: raw) } @@ -1533,16 +1529,78 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } +} + +@_spi(RawSyntax) +public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .structDecl + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeStructHeader: RawUnexpectedNodesSyntax? = nil, + structHeader: RawStructDeclHeaderSyntax, + _ unexpectedBetweenStructHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil, + memberBlock: RawMemberBlockSyntax, + _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .structDecl, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeStructHeader?.raw + layout[1] = structHeader.raw + layout[2] = unexpectedBetweenStructHeaderAndMemberBlock?.raw + layout[3] = memberBlock.raw + layout[4] = unexpectedAfterMemberBlock?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeStructHeader: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var structHeader: RawStructDeclHeaderSyntax { + layoutView.children[1].map(RawStructDeclHeaderSyntax.init(raw:))! + } + + public var unexpectedBetweenStructHeaderAndMemberBlock: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } public var memberBlock: RawMemberBlockSyntax { - layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))! + layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))! } public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 166a32ae78f..075e1953d2d 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -270,8 +270,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - case .actorDecl: - assert(layout.count == 17) + case .actorDeclHeader: + assert(layout.count == 15) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) @@ -287,8 +287,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self)) assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self)) - assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) + case .actorDecl: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawActorDeclHeaderSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .arrayElementList: for (index, element) in layout.enumerated() { assertNoError(kind, index, verify(element, as: RawArrayElementSyntax.self)) @@ -516,8 +521,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - case .classDecl: - assert(layout.count == 17) + case .classDeclHeader: + assert(layout.count == 15) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) @@ -533,8 +538,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self)) assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self)) - assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) + case .classDecl: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawClassDeclHeaderSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .classRestrictionType: assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1105,8 +1115,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 13, verify(layout[13], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) - case .enumDecl: - assert(layout.count == 17) + case .enumDeclHeader: + assert(layout.count == 15) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) @@ -1122,8 +1132,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self)) assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self)) - assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) + case .enumDecl: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawEnumDeclHeaderSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .exposeAttributeArguments: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1160,8 +1175,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawExprSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - case .extensionDecl: - assert(layout.count == 15) + case .extensionDeclHeader: + assert(layout.count == 13) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) @@ -1175,8 +1190,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 11, verify(layout[11], as: RawGenericWhereClauseSyntax?.self)) assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 13, verify(layout[13], as: RawMemberBlockSyntax.self)) - assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) + case .extensionDecl: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawExtensionDeclHeaderSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .fallThroughStmt: assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -2214,8 +2234,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - case .protocolDecl: - assert(layout.count == 17) + case .protocolDeclHeader: + assert(layout.count == 15) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) @@ -2231,8 +2251,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self)) assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self)) - assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) + case .protocolDecl: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawProtocolDeclHeaderSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .regexLiteralExpr: assert(layout.count == 11) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -2383,8 +2408,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.stringSegment)])) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - case .structDecl: - assert(layout.count == 17) + case .structDeclHeader: + assert(layout.count == 15) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) @@ -2400,8 +2425,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self)) assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self)) - assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) + case .structDecl: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawStructDeclHeaderSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .subscriptCallExpr: assert(layout.count == 13) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift index f6519df7524..d326035f854 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -781,7 +781,7 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn ]) } -// MARK: - ActorDeclSyntax +// MARK: - ActorDeclHeaderSyntax /// ### Children /// @@ -792,12 +792,15 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn /// - `genericParameterClause`: ``GenericParameterClauseSyntax``? /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -/// - `memberBlock`: ``MemberBlockSyntax`` -public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +/// +/// ### Contained in +/// +/// - ``ActorDeclSyntax``.``ActorDeclSyntax/actorHeader`` +public struct ActorDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { - guard node.raw.kind == .actorDecl else { + guard node.raw.kind == .actorDeclHeader else { return nil } self._syntaxNode = node._syntaxNode @@ -827,9 +830,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt inheritanceClause: InheritanceClauseSyntax? = nil, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed @@ -849,9 +850,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt inheritanceClause, unexpectedBetweenInheritanceClauseAndGenericWhereClause, genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock + unexpectedAfterGenericWhereClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, @@ -868,12 +867,10 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt inheritanceClause?.raw, unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw + unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.actorDecl, + kind: SyntaxKind.actorDeclHeader, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -888,7 +885,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -897,7 +894,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -909,7 +906,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// - returns: A copy of the receiver with the provided `Attribute` /// appended to its `attributes` collection. @available(*, deprecated, message: "Use node.attributes.append(newElement) instead") - public func addAttribute(_ element: Syntax) -> ActorDeclSyntax { + public func addAttribute(_ element: Syntax) -> ActorDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[1] { @@ -925,7 +922,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt rawNodeArena: arena, allocationArena: arena ) - .cast(ActorDeclSyntax.self) + .cast(ActorDeclHeaderSyntax.self) } public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { @@ -933,7 +930,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -943,7 +940,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -955,7 +952,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// - returns: A copy of the receiver with the provided `Modifier` /// appended to its `modifiers` collection. @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead") - public func addModifier(_ element: DeclModifierSyntax) -> ActorDeclSyntax { + public func addModifier(_ element: DeclModifierSyntax) -> ActorDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[3] { @@ -971,7 +968,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt rawNodeArena: arena, allocationArena: arena ) - .cast(ActorDeclSyntax.self) + .cast(ActorDeclHeaderSyntax.self) } public var unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? { @@ -979,7 +976,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -993,7 +990,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1002,7 +999,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1016,7 +1013,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 7)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1025,7 +1022,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1035,7 +1032,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1044,7 +1041,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1053,7 +1050,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1062,7 +1059,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1072,34 +1069,16 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) - } - } - - public var memberBlock: MemberBlockSyntax { - get { - return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) - } - } - - public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { - get { - return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self) } } @@ -1118,7 +1097,116 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt \Self.inheritanceClause, \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, \Self.genericWhereClause, - \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock, + \Self.unexpectedAfterGenericWhereClause + ]) +} + +// MARK: - ActorDeclSyntax + +/// ### Children +/// +/// - `actorHeader`: ``ActorDeclHeaderSyntax`` +/// - `memberBlock`: ``MemberBlockSyntax`` +public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .actorDecl else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - actorHeader: The header of the actor declaration. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeActorHeader: UnexpectedNodesSyntax? = nil, + actorHeader: ActorDeclHeaderSyntax, + _ unexpectedBetweenActorHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeActorHeader, + actorHeader, + unexpectedBetweenActorHeaderAndMemberBlock, + memberBlock, + unexpectedAfterMemberBlock + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeActorHeader?.raw, + actorHeader.raw, + unexpectedBetweenActorHeaderAndMemberBlock?.raw, + memberBlock.raw, + unexpectedAfterMemberBlock?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.actorDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeActorHeader: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + } + } + + /// The header of the actor declaration. + public var actorHeader: ActorDeclHeaderSyntax { + get { + return Syntax(self).child(at: 1)!.cast(ActorDeclHeaderSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + } + } + + public var unexpectedBetweenActorHeaderAndMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + } + } + + public var memberBlock: MemberBlockSyntax { + get { + return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + } + } + + public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeActorHeader, + \Self.actorHeader, + \Self.unexpectedBetweenActorHeaderAndMemberBlock, \Self.memberBlock, \Self.unexpectedAfterMemberBlock ]) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift index a80eedea2ac..e1cd175003f 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift @@ -705,31 +705,15 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr ]) } -// MARK: - ClassDeclSyntax +// MARK: - ClassDeclHeaderSyntax -/// A `class` declaration +/// A `class` declaration header /// -/// An example of a class declaration is +/// An example of a class declaration header is /// /// ```swift -/// class SomeClass { -/// let someMember: String -/// -/// init(someMember: String) { -/// self.someMember = someMember -/// } -/// -/// func foo() { -/// print(someMember) -/// } -/// -/// static func bar() -> Int { -/// return 1 -/// } -/// } +/// class SomeClass /// ``` -/// -/// A class declaration may be declared without any members. /// /// ### Children /// @@ -740,12 +724,15 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr /// - `genericParameterClause`: ``GenericParameterClauseSyntax``? /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -/// - `memberBlock`: ``MemberBlockSyntax`` -public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +/// +/// ### Contained in +/// +/// - ``ClassDeclSyntax``.``ClassDeclSyntax/classHeader`` +public struct ClassDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { - guard node.raw.kind == .classDecl else { + guard node.raw.kind == .classDeclHeader else { return nil } self._syntaxNode = node._syntaxNode @@ -760,7 +747,6 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// - genericParameterClause: The generic parameters, if any, of the class declaration. /// - inheritanceClause: The inheritance clause describing one or more conformances for this class declaration. /// - genericWhereClause: The `where` clause that applies to the generic parameters of this class declaration. - /// - memberBlock: The members of the class declaration. As class extension declarations may declare additional members, the contents of this member block isn't guaranteed to be a complete list of members for this type. /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, @@ -778,9 +764,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt inheritanceClause: InheritanceClauseSyntax? = nil, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed @@ -800,9 +784,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt inheritanceClause, unexpectedBetweenInheritanceClauseAndGenericWhereClause, genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock + unexpectedAfterGenericWhereClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, @@ -819,12 +801,10 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt inheritanceClause?.raw, unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw + unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.classDecl, + kind: SyntaxKind.classDeclHeader, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -839,7 +819,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -849,7 +829,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -861,7 +841,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// - returns: A copy of the receiver with the provided `Attribute` /// appended to its `attributes` collection. @available(*, deprecated, message: "Use node.attributes.append(newElement) instead") - public func addAttribute(_ element: Syntax) -> ClassDeclSyntax { + public func addAttribute(_ element: Syntax) -> ClassDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[1] { @@ -877,7 +857,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt rawNodeArena: arena, allocationArena: arena ) - .cast(ClassDeclSyntax.self) + .cast(ClassDeclHeaderSyntax.self) } public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { @@ -885,7 +865,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -895,7 +875,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -907,7 +887,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt /// - returns: A copy of the receiver with the provided `Modifier` /// appended to its `modifiers` collection. @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead") - public func addModifier(_ element: DeclModifierSyntax) -> ClassDeclSyntax { + public func addModifier(_ element: DeclModifierSyntax) -> ClassDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[3] { @@ -923,7 +903,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt rawNodeArena: arena, allocationArena: arena ) - .cast(ClassDeclSyntax.self) + .cast(ClassDeclHeaderSyntax.self) } public var unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? { @@ -931,7 +911,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -945,7 +925,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -954,7 +934,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -968,7 +948,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 7)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -977,7 +957,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -987,7 +967,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -996,7 +976,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -1006,7 +986,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -1015,7 +995,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } @@ -1025,54 +1005,170 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) } } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndModifiers, + \Self.modifiers, + \Self.unexpectedBetweenModifiersAndClassKeyword, + \Self.classKeyword, + \Self.unexpectedBetweenClassKeywordAndName, + \Self.name, + \Self.unexpectedBetweenNameAndGenericParameterClause, + \Self.genericParameterClause, + \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause, + \Self.inheritanceClause, + \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, + \Self.genericWhereClause, + \Self.unexpectedAfterGenericWhereClause + ]) +} + +// MARK: - ClassDeclSyntax + +/// A `class` declaration +/// +/// An example of a class declaration is +/// +/// ```swift +/// class SomeClass { +/// let someMember: String +/// +/// init(someMember: String) { +/// self.someMember = someMember +/// } +/// +/// func foo() { +/// print(someMember) +/// } +/// +/// static func bar() -> Int { +/// return 1 +/// } +/// } +/// ``` +/// +/// A class declaration may be declared without any members. +/// +/// ### Children +/// +/// - `classHeader`: ``ClassDeclHeaderSyntax`` +/// - `memberBlock`: ``MemberBlockSyntax`` +public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .classDecl else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - classHeader: The header of the class declaration. + /// - memberBlock: The members of the class declaration. As class extension declarations may declare additional members, the contents of this member block isn't guaranteed to be a complete list of members for this type. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeClassHeader: UnexpectedNodesSyntax? = nil, + classHeader: ClassDeclHeaderSyntax, + _ unexpectedBetweenClassHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeClassHeader, + classHeader, + unexpectedBetweenClassHeaderAndMemberBlock, + memberBlock, + unexpectedAfterMemberBlock + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeClassHeader?.raw, + classHeader.raw, + unexpectedBetweenClassHeaderAndMemberBlock?.raw, + memberBlock.raw, + unexpectedAfterMemberBlock?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.classDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeClassHeader: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + } + } + + /// The header of the class declaration. + public var classHeader: ClassDeclHeaderSyntax { + get { + return Syntax(self).child(at: 1)!.cast(ClassDeclHeaderSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + } + } + + public var unexpectedBetweenClassHeaderAndMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) } } /// The members of the class declaration. As class extension declarations may declare additional members, the contents of this member block isn't guaranteed to be a complete list of members for this type. public var memberBlock: MemberBlockSyntax { get { - return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self) + return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) } } public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { get { - return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self) + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self) } } public static let structure: SyntaxNodeStructure = .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndModifiers, - \Self.modifiers, - \Self.unexpectedBetweenModifiersAndClassKeyword, - \Self.classKeyword, - \Self.unexpectedBetweenClassKeywordAndName, - \Self.name, - \Self.unexpectedBetweenNameAndGenericParameterClause, - \Self.genericParameterClause, - \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause, - \Self.inheritanceClause, - \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, - \Self.genericWhereClause, - \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock, + \Self.unexpectedBeforeClassHeader, + \Self.classHeader, + \Self.unexpectedBetweenClassHeaderAndMemberBlock, \Self.memberBlock, \Self.unexpectedAfterMemberBlock ]) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift index 9be2ca37f77..62b86397ef2 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift @@ -1216,9 +1216,9 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ]) } -// MARK: - EnumDeclSyntax +// MARK: - EnumDeclHeaderSyntax -/// A Swift `enum` declaration. +/// A Swift `enum` declaration header. /// /// ### Children /// @@ -1229,12 +1229,15 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt /// - `genericParameterClause`: ``GenericParameterClauseSyntax``? /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -/// - `memberBlock`: ``MemberBlockSyntax`` -public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +/// +/// ### Contained in +/// +/// - ``EnumDeclSyntax``.``EnumDeclSyntax/enumHeader`` +public struct EnumDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { - guard node.raw.kind == .enumDecl else { + guard node.raw.kind == .enumDeclHeader else { return nil } self._syntaxNode = node._syntaxNode @@ -1249,7 +1252,6 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta /// - genericParameterClause: The generic parameters, if any, for this enum declaration. /// - inheritanceClause: The inheritance clause describing conformances or raw values for this enum declaration. /// - genericWhereClause: The `where` clause that applies to the generic parameters of this enum declaration. - /// - memberBlock: The cases and other members associated with this enum declaration. Because enum extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type. /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, @@ -1267,9 +1269,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta inheritanceClause: InheritanceClauseSyntax? = nil, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed @@ -1289,9 +1289,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta inheritanceClause, unexpectedBetweenInheritanceClauseAndGenericWhereClause, genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock + unexpectedAfterGenericWhereClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, @@ -1308,12 +1306,10 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta inheritanceClause?.raw, unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw + unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumDecl, + kind: SyntaxKind.enumDeclHeader, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -1328,7 +1324,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1338,7 +1334,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1350,7 +1346,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta /// - returns: A copy of the receiver with the provided `Attribute` /// appended to its `attributes` collection. @available(*, deprecated, message: "Use node.attributes.append(newElement) instead") - public func addAttribute(_ element: Syntax) -> EnumDeclSyntax { + public func addAttribute(_ element: Syntax) -> EnumDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[1] { @@ -1366,7 +1362,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta rawNodeArena: arena, allocationArena: arena ) - .cast(EnumDeclSyntax.self) + .cast(EnumDeclHeaderSyntax.self) } public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { @@ -1374,7 +1370,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1384,7 +1380,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1396,7 +1392,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta /// - returns: A copy of the receiver with the provided `Modifier` /// appended to its `modifiers` collection. @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead") - public func addModifier(_ element: DeclModifierSyntax) -> EnumDeclSyntax { + public func addModifier(_ element: DeclModifierSyntax) -> EnumDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[3] { @@ -1412,7 +1408,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta rawNodeArena: arena, allocationArena: arena ) - .cast(EnumDeclSyntax.self) + .cast(EnumDeclHeaderSyntax.self) } public var unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? { @@ -1420,7 +1416,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1434,7 +1430,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1443,7 +1439,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1457,7 +1453,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 7)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1466,7 +1462,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1476,7 +1472,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1485,7 +1481,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1495,7 +1491,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1504,7 +1500,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } @@ -1514,54 +1510,148 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) } } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndModifiers, + \Self.modifiers, + \Self.unexpectedBetweenModifiersAndEnumKeyword, + \Self.enumKeyword, + \Self.unexpectedBetweenEnumKeywordAndName, + \Self.name, + \Self.unexpectedBetweenNameAndGenericParameterClause, + \Self.genericParameterClause, + \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause, + \Self.inheritanceClause, + \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, + \Self.genericWhereClause, + \Self.unexpectedAfterGenericWhereClause + ]) +} + +// MARK: - EnumDeclSyntax + +/// A Swift `enum` declaration. +/// +/// ### Children +/// +/// - `enumHeader`: ``EnumDeclHeaderSyntax`` +/// - `memberBlock`: ``MemberBlockSyntax`` +public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .enumDecl else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - enumHeader: The header of the enum declaration. + /// - memberBlock: The cases and other members associated with this enum declaration. Because enum extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeEnumHeader: UnexpectedNodesSyntax? = nil, + enumHeader: EnumDeclHeaderSyntax, + _ unexpectedBetweenEnumHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeEnumHeader, + enumHeader, + unexpectedBetweenEnumHeaderAndMemberBlock, + memberBlock, + unexpectedAfterMemberBlock + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeEnumHeader?.raw, + enumHeader.raw, + unexpectedBetweenEnumHeaderAndMemberBlock?.raw, + memberBlock.raw, + unexpectedAfterMemberBlock?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.enumDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeEnumHeader: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + } + } + + /// The header of the enum declaration. + public var enumHeader: EnumDeclHeaderSyntax { + get { + return Syntax(self).child(at: 1)!.cast(EnumDeclHeaderSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + } + } + + public var unexpectedBetweenEnumHeaderAndMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) } } /// The cases and other members associated with this enum declaration. Because enum extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type. public var memberBlock: MemberBlockSyntax { get { - return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self) + return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) } } public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { get { - return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self) + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self) } } public static let structure: SyntaxNodeStructure = .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndModifiers, - \Self.modifiers, - \Self.unexpectedBetweenModifiersAndEnumKeyword, - \Self.enumKeyword, - \Self.unexpectedBetweenEnumKeywordAndName, - \Self.name, - \Self.unexpectedBetweenNameAndGenericParameterClause, - \Self.genericParameterClause, - \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause, - \Self.inheritanceClause, - \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, - \Self.genericWhereClause, - \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock, + \Self.unexpectedBeforeEnumHeader, + \Self.enumHeader, + \Self.unexpectedBetweenEnumHeaderAndMemberBlock, \Self.memberBlock, \Self.unexpectedAfterMemberBlock ]) @@ -2103,18 +2193,14 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeExpression, \Self.expression, \Self.unexpectedAfterExpression]) } -// MARK: - ExtensionDeclSyntax +// MARK: - ExtensionDeclHeaderSyntax -/// An `extension` declaration. +/// An `extension` declaration header. /// /// ### Example /// /// ```swift -/// extension String { -/// var url: URL? { -/// URL(string: self) -/// } -/// } +/// extension String /// ``` /// /// ### Children @@ -2125,12 +2211,15 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm /// - `extendedType`: ``TypeSyntax`` /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -/// - `memberBlock`: ``MemberBlockSyntax`` -public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +/// +/// ### Contained in +/// +/// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/extensionHeader`` +public struct ExtensionDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { - guard node.raw.kind == .extensionDecl else { + guard node.raw.kind == .extensionDeclHeader else { return nil } self._syntaxNode = node._syntaxNode @@ -2144,7 +2233,6 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl /// - extendedType: The extended `type` for which the extension is added. /// - inheritanceClause: The inheritance clause describing one or more conformances for this extension declaration. /// - genericWhereClause: A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`. - /// - memberBlock: The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type. /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, @@ -2160,9 +2248,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl inheritanceClause: InheritanceClauseSyntax? = nil, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed @@ -2180,9 +2266,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl inheritanceClause, unexpectedBetweenInheritanceClauseAndGenericWhereClause, genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock + unexpectedAfterGenericWhereClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, @@ -2197,12 +2281,10 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl inheritanceClause?.raw, unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw + unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.extensionDecl, + kind: SyntaxKind.extensionDeclHeader, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -2217,7 +2299,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2235,7 +2317,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2247,7 +2329,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl /// - returns: A copy of the receiver with the provided `Attribute` /// appended to its `attributes` collection. @available(*, deprecated, message: "Use node.attributes.append(newElement) instead") - public func addAttribute(_ element: Syntax) -> ExtensionDeclSyntax { + public func addAttribute(_ element: Syntax) -> ExtensionDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[1] { @@ -2263,7 +2345,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl rawNodeArena: arena, allocationArena: arena ) - .cast(ExtensionDeclSyntax.self) + .cast(ExtensionDeclHeaderSyntax.self) } public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { @@ -2271,7 +2353,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2281,7 +2363,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2293,7 +2375,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl /// - returns: A copy of the receiver with the provided `Modifier` /// appended to its `modifiers` collection. @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead") - public func addModifier(_ element: DeclModifierSyntax) -> ExtensionDeclSyntax { + public func addModifier(_ element: DeclModifierSyntax) -> ExtensionDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[3] { @@ -2309,7 +2391,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl rawNodeArena: arena, allocationArena: arena ) - .cast(ExtensionDeclSyntax.self) + .cast(ExtensionDeclHeaderSyntax.self) } public var unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? { @@ -2317,7 +2399,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2331,7 +2413,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2340,7 +2422,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2350,7 +2432,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 7)!.cast(TypeSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2359,7 +2441,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2369,7 +2451,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 9)?.cast(InheritanceClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2378,7 +2460,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } @@ -2388,52 +2470,156 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl return Syntax(self).child(at: 11)?.cast(GenericWhereClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) } } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndModifiers, + \Self.modifiers, + \Self.unexpectedBetweenModifiersAndExtensionKeyword, + \Self.extensionKeyword, + \Self.unexpectedBetweenExtensionKeywordAndExtendedType, + \Self.extendedType, + \Self.unexpectedBetweenExtendedTypeAndInheritanceClause, + \Self.inheritanceClause, + \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, + \Self.genericWhereClause, + \Self.unexpectedAfterGenericWhereClause + ]) +} + +// MARK: - ExtensionDeclSyntax + +/// An `extension` declaration. +/// +/// ### Example +/// +/// ```swift +/// extension String { +/// var url: URL? { +/// URL(string: self) +/// } +/// } +/// ``` +/// +/// ### Children +/// +/// - `extensionHeader`: ``ExtensionDeclHeaderSyntax`` +/// - `memberBlock`: ``MemberBlockSyntax`` +public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .extensionDecl else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - extensionHeader: The header of the extension declaration. + /// - memberBlock: The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExtensionHeader: UnexpectedNodesSyntax? = nil, + extensionHeader: ExtensionDeclHeaderSyntax, + _ unexpectedBetweenExtensionHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeExtensionHeader, + extensionHeader, + unexpectedBetweenExtensionHeaderAndMemberBlock, + memberBlock, + unexpectedAfterMemberBlock + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeExtensionHeader?.raw, + extensionHeader.raw, + unexpectedBetweenExtensionHeaderAndMemberBlock?.raw, + memberBlock.raw, + unexpectedAfterMemberBlock?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.extensionDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeExtensionHeader: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + } + } + + /// The header of the extension declaration. + public var extensionHeader: ExtensionDeclHeaderSyntax { + get { + return Syntax(self).child(at: 1)!.cast(ExtensionDeclHeaderSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + } + } + + public var unexpectedBetweenExtensionHeaderAndMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) } } /// The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type. public var memberBlock: MemberBlockSyntax { get { - return Syntax(self).child(at: 13)!.cast(MemberBlockSyntax.self) + return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) } } public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { get { - return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self) + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self) } } public static let structure: SyntaxNodeStructure = .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndModifiers, - \Self.modifiers, - \Self.unexpectedBetweenModifiersAndExtensionKeyword, - \Self.extensionKeyword, - \Self.unexpectedBetweenExtensionKeywordAndExtendedType, - \Self.extendedType, - \Self.unexpectedBetweenExtendedTypeAndInheritanceClause, - \Self.inheritanceClause, - \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, - \Self.genericWhereClause, - \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock, + \Self.unexpectedBeforeExtensionHeader, + \Self.extensionHeader, + \Self.unexpectedBetweenExtensionHeaderAndMemberBlock, \Self.memberBlock, \Self.unexpectedAfterMemberBlock ]) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift index a1ca4fa7d77..e2d3ecab57f 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift @@ -319,14 +319,14 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax /// /// ### Contained in /// -/// - ``ActorDeclSyntax``.``ActorDeclSyntax/genericParameterClause`` -/// - ``ClassDeclSyntax``.``ClassDeclSyntax/genericParameterClause`` -/// - ``EnumDeclSyntax``.``EnumDeclSyntax/genericParameterClause`` +/// - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/genericParameterClause`` +/// - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/genericParameterClause`` +/// - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/genericParameterClause`` /// - ``FunctionDeclSyntax``.``FunctionDeclSyntax/genericParameterClause`` /// - ``InitializerDeclSyntax``.``InitializerDeclSyntax/genericParameterClause`` /// - ``MacroDeclSyntax``.``MacroDeclSyntax/genericParameterClause`` /// - ``NamedOpaqueReturnTypeSyntax``.``NamedOpaqueReturnTypeSyntax/genericParameterClause`` -/// - ``StructDeclSyntax``.``StructDeclSyntax/genericParameterClause`` +/// - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/genericParameterClause`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/genericParameterClause`` /// - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/genericParameterClause`` public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { @@ -1136,21 +1136,21 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl /// /// ### Contained in /// -/// - ``ActorDeclSyntax``.``ActorDeclSyntax/genericWhereClause`` +/// - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/genericWhereClause`` /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/genericWhereClause`` -/// - ``ClassDeclSyntax``.``ClassDeclSyntax/genericWhereClause`` +/// - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/genericWhereClause`` /// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/genericWhereClause`` /// - ``DifferentiableAttributeArgumentsSyntax``.``DifferentiableAttributeArgumentsSyntax/genericWhereClause`` -/// - ``EnumDeclSyntax``.``EnumDeclSyntax/genericWhereClause`` -/// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/genericWhereClause`` +/// - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/genericWhereClause`` +/// - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/genericWhereClause`` /// - ``FunctionDeclSyntax``.``FunctionDeclSyntax/genericWhereClause`` /// - ``GenericParameterClauseSyntax``.``GenericParameterClauseSyntax/genericWhereClause`` /// - ``InitializerDeclSyntax``.``InitializerDeclSyntax/genericWhereClause`` /// - ``MacroDeclSyntax``.``MacroDeclSyntax/genericWhereClause`` /// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/genericWhereClause`` -/// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/genericWhereClause`` +/// - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/genericWhereClause`` /// - ``SpecializeAttributeArgumentListSyntax`` -/// - ``StructDeclSyntax``.``StructDeclSyntax/genericWhereClause`` +/// - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/genericWhereClause`` /// - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/genericWhereClause`` /// - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/genericWhereClause`` public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { @@ -3429,15 +3429,15 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf /// /// ### Contained in /// -/// - ``ActorDeclSyntax``.``ActorDeclSyntax/inheritanceClause`` +/// - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/inheritanceClause`` /// - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/inheritanceClause`` -/// - ``ClassDeclSyntax``.``ClassDeclSyntax/inheritanceClause`` +/// - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/inheritanceClause`` /// - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/inheritanceClause`` -/// - ``EnumDeclSyntax``.``EnumDeclSyntax/inheritanceClause`` -/// - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/inheritanceClause`` +/// - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/inheritanceClause`` +/// - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/inheritanceClause`` /// - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/inheritanceClause`` -/// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/inheritanceClause`` -/// - ``StructDeclSyntax``.``StructDeclSyntax/inheritanceClause`` +/// - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/inheritanceClause`` +/// - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/inheritanceClause`` public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { public let _syntaxNode: Syntax diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift index f137e4e5989..3baf488d246 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift @@ -4032,7 +4032,7 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea /// /// ### Contained in /// -/// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/primaryAssociatedTypeClause`` +/// - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/primaryAssociatedTypeClause`` public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { public let _syntaxNode: Syntax @@ -4314,16 +4314,14 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf ]) } -// MARK: - ProtocolDeclSyntax +// MARK: - ProtocolDeclHeaderSyntax -/// A `protocol` declaration +/// A `protocol` declaration header /// -/// An example of a protocol declaration is +/// An example of a protocol declaration header is /// /// ```swift -/// protocol Example { -/// var isValid: Bool { get } -/// } +/// protocol Example /// ``` /// /// ### Children @@ -4335,12 +4333,15 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// - `primaryAssociatedTypeClause`: ``PrimaryAssociatedTypeClauseSyntax``? /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -/// - `memberBlock`: ``MemberBlockSyntax`` -public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +/// +/// ### Contained in +/// +/// - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/protocolHeader`` +public struct ProtocolDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { - guard node.raw.kind == .protocolDecl else { + guard node.raw.kind == .protocolDeclHeader else { return nil } self._syntaxNode = node._syntaxNode @@ -4355,7 +4356,6 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// - primaryAssociatedTypeClause: The primary associated type for the protocol. /// - inheritanceClause: The inheritance clause describing one or more conformances for this protocol declaration. /// - genericWhereClause: The `where` clause that applies to the generic parameters of this protocol declaration. - /// - memberBlock: The members of the protocol declaration. /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, @@ -4373,9 +4373,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS inheritanceClause: InheritanceClauseSyntax? = nil, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed @@ -4395,9 +4393,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS inheritanceClause, unexpectedBetweenInheritanceClauseAndGenericWhereClause, genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock + unexpectedAfterGenericWhereClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, @@ -4414,12 +4410,10 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS inheritanceClause?.raw, unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw + unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.protocolDecl, + kind: SyntaxKind.protocolDeclHeader, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -4434,7 +4428,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4444,7 +4438,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4456,7 +4450,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// - returns: A copy of the receiver with the provided `Attribute` /// appended to its `attributes` collection. @available(*, deprecated, message: "Use node.attributes.append(newElement) instead") - public func addAttribute(_ element: Syntax) -> ProtocolDeclSyntax { + public func addAttribute(_ element: Syntax) -> ProtocolDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[1] { @@ -4472,7 +4466,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS rawNodeArena: arena, allocationArena: arena ) - .cast(ProtocolDeclSyntax.self) + .cast(ProtocolDeclHeaderSyntax.self) } public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { @@ -4480,7 +4474,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4490,7 +4484,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4502,7 +4496,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// - returns: A copy of the receiver with the provided `Modifier` /// appended to its `modifiers` collection. @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead") - public func addModifier(_ element: DeclModifierSyntax) -> ProtocolDeclSyntax { + public func addModifier(_ element: DeclModifierSyntax) -> ProtocolDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[3] { @@ -4518,7 +4512,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS rawNodeArena: arena, allocationArena: arena ) - .cast(ProtocolDeclSyntax.self) + .cast(ProtocolDeclHeaderSyntax.self) } public var unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? { @@ -4526,7 +4520,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4540,7 +4534,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4549,7 +4543,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4563,7 +4557,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 7)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4572,7 +4566,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4582,7 +4576,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 9)?.cast(PrimaryAssociatedTypeClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4591,7 +4585,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4601,7 +4595,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4610,7 +4604,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } @@ -4620,54 +4614,156 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) } } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndModifiers, + \Self.modifiers, + \Self.unexpectedBetweenModifiersAndProtocolKeyword, + \Self.protocolKeyword, + \Self.unexpectedBetweenProtocolKeywordAndName, + \Self.name, + \Self.unexpectedBetweenNameAndPrimaryAssociatedTypeClause, + \Self.primaryAssociatedTypeClause, + \Self.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, + \Self.inheritanceClause, + \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, + \Self.genericWhereClause, + \Self.unexpectedAfterGenericWhereClause + ]) +} + +// MARK: - ProtocolDeclSyntax + +/// A `protocol` declaration +/// +/// An example of a protocol declaration is +/// +/// ```swift +/// protocol Example { +/// var isValid: Bool { get } +/// } +/// ``` +/// +/// ### Children +/// +/// - `protocolHeader`: ``ProtocolDeclHeaderSyntax`` +/// - `memberBlock`: ``MemberBlockSyntax`` +public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .protocolDecl else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - protocolHeader: The header of the protocol. + /// - memberBlock: The members of the protocol declaration. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeProtocolHeader: UnexpectedNodesSyntax? = nil, + protocolHeader: ProtocolDeclHeaderSyntax, + _ unexpectedBetweenProtocolHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeProtocolHeader, + protocolHeader, + unexpectedBetweenProtocolHeaderAndMemberBlock, + memberBlock, + unexpectedAfterMemberBlock + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeProtocolHeader?.raw, + protocolHeader.raw, + unexpectedBetweenProtocolHeaderAndMemberBlock?.raw, + memberBlock.raw, + unexpectedAfterMemberBlock?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.protocolDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeProtocolHeader: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + } + } + + /// The header of the protocol. + public var protocolHeader: ProtocolDeclHeaderSyntax { + get { + return Syntax(self).child(at: 1)!.cast(ProtocolDeclHeaderSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + } + } + + public var unexpectedBetweenProtocolHeaderAndMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) } } /// The members of the protocol declaration. public var memberBlock: MemberBlockSyntax { get { - return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self) + return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) } } public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { get { - return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self) + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self) } } public static let structure: SyntaxNodeStructure = .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndModifiers, - \Self.modifiers, - \Self.unexpectedBetweenModifiersAndProtocolKeyword, - \Self.protocolKeyword, - \Self.unexpectedBetweenProtocolKeywordAndName, - \Self.name, - \Self.unexpectedBetweenNameAndPrimaryAssociatedTypeClause, - \Self.primaryAssociatedTypeClause, - \Self.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, - \Self.inheritanceClause, - \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, - \Self.genericWhereClause, - \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock, + \Self.unexpectedBeforeProtocolHeader, + \Self.protocolHeader, + \Self.unexpectedBetweenProtocolHeaderAndMemberBlock, \Self.memberBlock, \Self.unexpectedAfterMemberBlock ]) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift index 87750e981a9..74932b91ccb 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift @@ -2173,64 +2173,29 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeContent, \Self.content, \Self.unexpectedAfterContent]) } -// MARK: - StructDeclSyntax +// MARK: - StructDeclHeaderSyntax -/// A `struct` declaration -/// -/// An example of a struct declaration is -/// -/// ```swift -/// struct SomeStruct { -/// let someMember: String -/// var anotherMember: Int -/// -/// func foo() { -/// print(someMember) -/// } -/// -/// mutating func bar() { -/// anotherMember = 42 -/// } -/// } -/// ``` +/// A `struct` declaration header /// -/// A struct declaration may be declared without any members. +/// An example of a struct declaration header is /// /// ```swift -/// struct EmptyStruct { -/// -/// } +/// struct SomeStruct /// ``` /// /// A struct declaration may include a type inheritance clause listing -/// one or more protocols the struct conforms to. -/// -/// The example below uses Hashable and Equatable protocols whose members -/// are automatically synthesized by the compiler if the struct contains -/// stored members that are themselves `Hashable` and `Equatable`. +/// one or more protocols the struct conforms to. The example below uses +/// Hashable and Equatable protocols. /// /// ```swift -/// struct AdvancedStruct: Hashable, Equatable { -/// let someMember: String -/// var anotherMember: Int -/// } +/// struct AdvancedStruct: Hashable, Equatable /// ``` /// /// A struct declaration may include a generic parameter clause as well /// as a generic where clause. /// /// ```swift -/// struct Stack { -/// var items: [Element] = [] -/// -/// mutating func push(_ item: Element) { -/// items.append(item) -/// } -/// -/// mutating func pop() -> Element { -/// return items.removeLast() -/// } -/// } +/// struct Stack /// ``` /// /// ### Children @@ -2242,12 +2207,15 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo /// - `genericParameterClause`: ``GenericParameterClauseSyntax``? /// - `inheritanceClause`: ``InheritanceClauseSyntax``? /// - `genericWhereClause`: ``GenericWhereClauseSyntax``? -/// - `memberBlock`: ``MemberBlockSyntax`` -public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { +/// +/// ### Contained in +/// +/// - ``StructDeclSyntax``.``StructDeclSyntax/structHeader`` +public struct StructDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: __shared some SyntaxProtocol) { - guard node.raw.kind == .structDecl else { + guard node.raw.kind == .structDeclHeader else { return nil } self._syntaxNode = node._syntaxNode @@ -2262,7 +2230,6 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn /// - genericParameterClause: The generic parameters, if any, of the struct declaration. /// - inheritanceClause: The struct declaration inheritance clause describing one or more conformances for this struct declaration. /// - genericWhereClause: The `where` clause that applies to the generic parameters of this struct declaration. - /// - memberBlock: The members of the struct declaration. Because struct extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type. /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, @@ -2280,9 +2247,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn inheritanceClause: InheritanceClauseSyntax? = nil, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed @@ -2302,9 +2267,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn inheritanceClause, unexpectedBetweenInheritanceClauseAndGenericWhereClause, genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock + unexpectedAfterGenericWhereClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, @@ -2321,12 +2284,10 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn inheritanceClause?.raw, unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw + unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.structDecl, + kind: SyntaxKind.structDeclHeader, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -2341,7 +2302,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2351,7 +2312,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2363,7 +2324,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn /// - returns: A copy of the receiver with the provided `Attribute` /// appended to its `attributes` collection. @available(*, deprecated, message: "Use node.attributes.append(newElement) instead") - public func addAttribute(_ element: Syntax) -> StructDeclSyntax { + public func addAttribute(_ element: Syntax) -> StructDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[1] { @@ -2379,7 +2340,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn rawNodeArena: arena, allocationArena: arena ) - .cast(StructDeclSyntax.self) + .cast(StructDeclHeaderSyntax.self) } public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { @@ -2387,7 +2348,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2397,7 +2358,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2409,7 +2370,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn /// - returns: A copy of the receiver with the provided `Modifier` /// appended to its `modifiers` collection. @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead") - public func addModifier(_ element: DeclModifierSyntax) -> StructDeclSyntax { + public func addModifier(_ element: DeclModifierSyntax) -> StructDeclHeaderSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[3] { @@ -2425,7 +2386,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn rawNodeArena: arena, allocationArena: arena ) - .cast(StructDeclSyntax.self) + .cast(StructDeclHeaderSyntax.self) } public var unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? { @@ -2433,7 +2394,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2447,7 +2408,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2456,7 +2417,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2470,7 +2431,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 7)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2479,7 +2440,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2489,7 +2450,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2498,7 +2459,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2508,7 +2469,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2517,7 +2478,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2527,35 +2488,16 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } - public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) - } - } - - /// The members of the struct declaration. Because struct extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type. - public var memberBlock: MemberBlockSyntax { - get { - return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) - } - } - - public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { - get { - return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self) } } @@ -2574,7 +2516,176 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn \Self.inheritanceClause, \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause, \Self.genericWhereClause, - \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock, + \Self.unexpectedAfterGenericWhereClause + ]) +} + +// MARK: - StructDeclSyntax + +/// A `struct` declaration +/// +/// An example of a struct declaration is +/// +/// ```swift +/// struct SomeStruct { +/// let someMember: String +/// var anotherMember: Int +/// +/// func foo() { +/// print(someMember) +/// } +/// +/// mutating func bar() { +/// anotherMember = 42 +/// } +/// } +/// ``` +/// +/// A struct declaration may be declared without any members. +/// +/// ```swift +/// struct EmptyStruct { +/// +/// } +/// ``` +/// +/// A struct declaration may include a type inheritance clause listing +/// one or more protocols the struct conforms to. +/// +/// The example below uses Hashable and Equatable protocols whose members +/// are automatically synthesized by the compiler if the struct contains +/// stored members that are themselves `Hashable` and `Equatable`. +/// +/// ```swift +/// struct AdvancedStruct: Hashable, Equatable { +/// let someMember: String +/// var anotherMember: Int +/// } +/// ``` +/// +/// A struct declaration may include a generic parameter clause as well +/// as a generic where clause. +/// +/// ```swift +/// struct Stack { +/// var items: [Element] = [] +/// +/// mutating func push(_ item: Element) { +/// items.append(item) +/// } +/// +/// mutating func pop() -> Element { +/// return items.removeLast() +/// } +/// } +/// ``` +/// +/// ### Children +/// +/// - `structHeader`: ``StructDeclHeaderSyntax`` +/// - `memberBlock`: ``MemberBlockSyntax`` +public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .structDecl else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - structHeader: Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it. + /// - memberBlock: The header of the struct declaration. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeStructHeader: UnexpectedNodesSyntax? = nil, + structHeader: StructDeclHeaderSyntax, + _ unexpectedBetweenStructHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeStructHeader, + structHeader, + unexpectedBetweenStructHeaderAndMemberBlock, + memberBlock, + unexpectedAfterMemberBlock + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeStructHeader?.raw, + structHeader.raw, + unexpectedBetweenStructHeaderAndMemberBlock?.raw, + memberBlock.raw, + unexpectedAfterMemberBlock?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.structDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeStructHeader: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + } + } + + /// Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it. + public var structHeader: StructDeclHeaderSyntax { + get { + return Syntax(self).child(at: 1)!.cast(StructDeclHeaderSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + } + } + + public var unexpectedBetweenStructHeaderAndMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + } + } + + /// The header of the struct declaration. + public var memberBlock: MemberBlockSyntax { + get { + return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + } + } + + public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeStructHeader, + \Self.structHeader, + \Self.unexpectedBetweenStructHeaderAndMemberBlock, \Self.memberBlock, \Self.unexpectedAfterMemberBlock ]) diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index 964df2e93cc..0ce6e1b3ed4 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -63,42 +63,18 @@ extension ActorDeclSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( leadingTrivia: Trivia? = nil, - unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax = [], - unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: DeclModifierListSyntax = [], - unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil, - actorKeyword: TokenSyntax = .keyword(.actor), - unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: InheritanceClauseSyntax? = nil, - unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedBeforeActorHeader: UnexpectedNodesSyntax? = nil, + actorHeader: ActorDeclHeaderSyntax, + unexpectedBetweenActorHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, trailingTrivia: Trivia? = nil ) rethrows { try self.init( leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndActorKeyword, - actorKeyword: actorKeyword, - unexpectedBetweenActorKeywordAndName, - name: name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause: genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, + unexpectedBeforeActorHeader, + actorHeader: actorHeader, + unexpectedBetweenActorHeaderAndMemberBlock, memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), unexpectedAfterMemberBlock, trailingTrivia: trailingTrivia @@ -164,42 +140,18 @@ extension ClassDeclSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( leadingTrivia: Trivia? = nil, - unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax = [], - unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: DeclModifierListSyntax = [], - unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil, - classKeyword: TokenSyntax = .keyword(.class), - unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: InheritanceClauseSyntax? = nil, - unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedBeforeClassHeader: UnexpectedNodesSyntax? = nil, + classHeader: ClassDeclHeaderSyntax, + unexpectedBetweenClassHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, trailingTrivia: Trivia? = nil ) rethrows { try self.init( leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndClassKeyword, - classKeyword: classKeyword, - unexpectedBetweenClassKeywordAndName, - name: name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause: genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, + unexpectedBeforeClassHeader, + classHeader: classHeader, + unexpectedBetweenClassHeaderAndMemberBlock, memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), unexpectedAfterMemberBlock, trailingTrivia: trailingTrivia @@ -445,42 +397,18 @@ extension EnumDeclSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( leadingTrivia: Trivia? = nil, - unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax = [], - unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: DeclModifierListSyntax = [], - unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil, - enumKeyword: TokenSyntax = .keyword(.enum), - unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: InheritanceClauseSyntax? = nil, - unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedBeforeEnumHeader: UnexpectedNodesSyntax? = nil, + enumHeader: EnumDeclHeaderSyntax, + unexpectedBetweenEnumHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, trailingTrivia: Trivia? = nil ) rethrows { try self.init( leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndEnumKeyword, - enumKeyword: enumKeyword, - unexpectedBetweenEnumKeywordAndName, - name: name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause: genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, + unexpectedBeforeEnumHeader, + enumHeader: enumHeader, + unexpectedBetweenEnumHeaderAndMemberBlock, memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), unexpectedAfterMemberBlock, trailingTrivia: trailingTrivia @@ -527,38 +455,18 @@ extension ExtensionDeclSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( leadingTrivia: Trivia? = nil, - unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax = [], - unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: DeclModifierListSyntax = [], - unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil, - extensionKeyword: TokenSyntax = .keyword(.extension), - unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil, - extendedType: TypeSyntaxProtocol, - unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: InheritanceClauseSyntax? = nil, - unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedBeforeExtensionHeader: UnexpectedNodesSyntax? = nil, + extensionHeader: ExtensionDeclHeaderSyntax, + unexpectedBetweenExtensionHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, trailingTrivia: Trivia? = nil ) rethrows { try self.init( leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndExtensionKeyword, - extensionKeyword: extensionKeyword, - unexpectedBetweenExtensionKeywordAndExtendedType, - extendedType: TypeSyntax(fromProtocol: extendedType), - unexpectedBetweenExtendedTypeAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, + unexpectedBeforeExtensionHeader, + extensionHeader: extensionHeader, + unexpectedBetweenExtensionHeaderAndMemberBlock, memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), unexpectedAfterMemberBlock, trailingTrivia: trailingTrivia @@ -1115,42 +1023,18 @@ extension ProtocolDeclSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( leadingTrivia: Trivia? = nil, - unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax = [], - unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: DeclModifierListSyntax = [], - unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil, - protocolKeyword: TokenSyntax = .keyword(.protocol), - unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil, - primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil, - unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: InheritanceClauseSyntax? = nil, - unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedBeforeProtocolHeader: UnexpectedNodesSyntax? = nil, + protocolHeader: ProtocolDeclHeaderSyntax, + unexpectedBetweenProtocolHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, trailingTrivia: Trivia? = nil ) rethrows { try self.init( leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndProtocolKeyword, - protocolKeyword: protocolKeyword, - unexpectedBetweenProtocolKeywordAndName, - name: name, - unexpectedBetweenNameAndPrimaryAssociatedTypeClause, - primaryAssociatedTypeClause: primaryAssociatedTypeClause, - unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, + unexpectedBeforeProtocolHeader, + protocolHeader: protocolHeader, + unexpectedBetweenProtocolHeaderAndMemberBlock, memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), unexpectedAfterMemberBlock, trailingTrivia: trailingTrivia @@ -1239,42 +1123,18 @@ extension StructDeclSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( leadingTrivia: Trivia? = nil, - unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax = [], - unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: DeclModifierListSyntax = [], - unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil, - structKeyword: TokenSyntax = .keyword(.struct), - unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: InheritanceClauseSyntax? = nil, - unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedBeforeStructHeader: UnexpectedNodesSyntax? = nil, + structHeader: StructDeclHeaderSyntax, + unexpectedBetweenStructHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil, unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, trailingTrivia: Trivia? = nil ) rethrows { try self.init( leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndStructKeyword, - structKeyword: structKeyword, - unexpectedBetweenStructKeywordAndName, - name: name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause: genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause: inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause: genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, + unexpectedBeforeStructHeader, + structHeader: structHeader, + unexpectedBetweenStructHeaderAndMemberBlock, memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), unexpectedAfterMemberBlock, trailingTrivia: trailingTrivia diff --git a/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift b/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift index 7cfa6227fb2..15b3ca14519 100644 --- a/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift +++ b/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift @@ -62,7 +62,56 @@ extension AccessorDeclSyntax { } extension ActorDeclSyntax { - @available(*, deprecated, message: "Use an initializer with name argument(s).") + @available(*, deprecated, message: "Use an initializer with actorHeader argument(s).") + @_disfavoredOverload + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil, + actorKeyword: TokenSyntax = .keyword(.actor), + unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndActorKeyword, + actorKeyword: actorKeyword, + unexpectedBetweenActorKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause, + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } +} + +extension ActorDeclSyntax { + @available(*, deprecated, message: "Use an initializer with actorHeader argument(s).") @_disfavoredOverload /// A convenience initializer that allows initializing syntax collections using result builders public init( @@ -140,7 +189,56 @@ extension ArrayExprSyntax { } extension ClassDeclSyntax { - @available(*, deprecated, message: "Use an initializer with name argument(s).") + @available(*, deprecated, message: "Use an initializer with classHeader argument(s).") + @_disfavoredOverload + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil, + classKeyword: TokenSyntax = .keyword(.class), + unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndClassKeyword, + classKeyword: classKeyword, + unexpectedBetweenClassKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause, + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } +} + +extension ClassDeclSyntax { + @available(*, deprecated, message: "Use an initializer with classHeader argument(s).") @_disfavoredOverload /// A convenience initializer that allows initializing syntax collections using result builders public init( @@ -189,7 +287,56 @@ extension ClassDeclSyntax { } extension EnumDeclSyntax { - @available(*, deprecated, message: "Use an initializer with name, genericParameterClause argument(s).") + @available(*, deprecated, message: "Use an initializer with enumHeader argument(s).") + @_disfavoredOverload + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil, + enumKeyword: TokenSyntax = .keyword(.enum), + unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndEnumKeyword, + enumKeyword: enumKeyword, + unexpectedBetweenEnumKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause, + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } +} + +extension EnumDeclSyntax { + @available(*, deprecated, message: "Use an initializer with enumHeader argument(s).") @_disfavoredOverload /// A convenience initializer that allows initializing syntax collections using result builders public init( @@ -274,6 +421,51 @@ extension ExpressionSegmentSyntax { } } +extension ExtensionDeclSyntax { + @available(*, deprecated, message: "Use an initializer with extensionHeader argument(s).") + @_disfavoredOverload + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil, + extensionKeyword: TokenSyntax = .keyword(.extension), + unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil, + extendedType: TypeSyntaxProtocol, + unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndExtensionKeyword, + extensionKeyword: extensionKeyword, + unexpectedBetweenExtensionKeywordAndExtendedType, + extendedType: TypeSyntax(fromProtocol: extendedType), + unexpectedBetweenExtendedTypeAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause, + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } +} + extension ForStmtSyntax { @available(*, deprecated, message: "Use an initializer with sequence argument(s).") @_disfavoredOverload @@ -700,7 +892,56 @@ extension MacroExpansionExprSyntax { } extension ProtocolDeclSyntax { - @available(*, deprecated, message: "Use an initializer with name argument(s).") + @available(*, deprecated, message: "Use an initializer with protocolHeader argument(s).") + @_disfavoredOverload + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil, + protocolKeyword: TokenSyntax = .keyword(.protocol), + unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil, + primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil, + unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndProtocolKeyword, + protocolKeyword: protocolKeyword, + unexpectedBetweenProtocolKeywordAndName, + name: name, + unexpectedBetweenNameAndPrimaryAssociatedTypeClause, + primaryAssociatedTypeClause: primaryAssociatedTypeClause, + unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause, + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } +} + +extension ProtocolDeclSyntax { + @available(*, deprecated, message: "Use an initializer with protocolHeader argument(s).") @_disfavoredOverload /// A convenience initializer that allows initializing syntax collections using result builders public init( @@ -778,7 +1019,56 @@ extension SourceFileSyntax { } extension StructDeclSyntax { - @available(*, deprecated, message: "Use an initializer with name argument(s).") + @available(*, deprecated, message: "Use an initializer with structHeader argument(s).") + @_disfavoredOverload + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax = [], + unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: DeclModifierListSyntax = [], + unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil, + structKeyword: TokenSyntax = .keyword(.struct), + unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: InheritanceClauseSyntax? = nil, + unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndStructKeyword, + structKeyword: structKeyword, + unexpectedBetweenStructKeywordAndName, + name: name, + unexpectedBetweenNameAndGenericParameterClause, + genericParameterClause: genericParameterClause, + unexpectedBetweenGenericParameterClauseAndInheritanceClause, + inheritanceClause: inheritanceClause, + unexpectedBetweenInheritanceClauseAndGenericWhereClause, + genericWhereClause: genericWhereClause, + unexpectedBetweenGenericWhereClauseAndMemberBlock, + memberBlock: MemberBlockSyntax(members: memberBlockBuilder()), + unexpectedAfterMemberBlock, + trailingTrivia: trailingTrivia + ) + } +} + +extension StructDeclSyntax { + @available(*, deprecated, message: "Use an initializer with structHeader argument(s).") @_disfavoredOverload /// A convenience initializer that allows initializing syntax collections using result builders public init( diff --git a/Tests/SwiftSyntaxTest/RawSyntaxTests.swift b/Tests/SwiftSyntaxTest/RawSyntaxTests.swift index 67a6074dc1a..502fbaa94f8 100644 --- a/Tests/SwiftSyntaxTest/RawSyntaxTests.swift +++ b/Tests/SwiftSyntaxTest/RawSyntaxTests.swift @@ -52,7 +52,7 @@ fileprivate func cannedStructDecl(arena: ParsingSyntaxArena) -> RawStructDeclSyn rightBrace: rBrace, arena: arena ) - return RawStructDeclSyntax( + let header = RawStructDeclHeaderSyntax( attributes: RawAttributeListSyntax(elements: [], arena: arena), modifiers: RawDeclModifierListSyntax(elements: [], arena: arena), structKeyword: structKW, @@ -60,6 +60,10 @@ fileprivate func cannedStructDecl(arena: ParsingSyntaxArena) -> RawStructDeclSyn genericParameterClause: nil, inheritanceClause: nil, genericWhereClause: nil, + arena: arena + ) + return RawStructDeclSyntax( + structHeader: header, memberBlock: memberBlock, arena: arena ) @@ -83,8 +87,8 @@ final class RawSyntaxTests: XCTestCase { func testAccessor() { withExtendedLifetime(ParsingSyntaxArena(parseTriviaFunction: dummyParseToken)) { arena in let structDecl = cannedStructDecl(arena: arena) - XCTAssertEqual(structDecl.name.tokenKind, .identifier) - XCTAssertEqual(structDecl.structKeyword.tokenText, "struct") + XCTAssertEqual(structDecl.structHeader.name.tokenKind, .identifier) + XCTAssertEqual(structDecl.structHeader.structKeyword.tokenText, "struct") XCTAssertEqual(structDecl.memberBlock.leftBrace.tokenText, "{") XCTAssertEqual(structDecl.memberBlock.members.elements.count, 0) From f77bb2554f275b1f78a073150c4e31a76d78d467 Mon Sep 17 00:00:00 2001 From: Becca Royal-Gordon Date: Wed, 30 Oct 2024 19:31:34 -0700 Subject: [PATCH 5/7] [NFC] Update uses of DeclGroups to use headers Clears up a bunch of warnings. --- .../Macros.swift | 2 +- Sources/SwiftLexicalLookup/LookupName.swift | 2 +- .../Scopes/ScopeImplementations.swift | 13 +++++++------ .../SwiftSyntaxMacroExpansion/MacroSystem.swift | 2 +- Tests/SwiftParserTest/DeclarationTests.swift | 12 ++++++++---- .../translated/HashbangLibraryTests.swift | 16 +++++++++------- .../ClassDeclSyntaxTests.swift | 4 ++-- .../EnumCaseElementTests.swift | 14 ++++++++------ .../ExtensionDeclTests.swift | 2 +- .../SwiftSyntaxBuilderTest/SourceFileTests.swift | 6 ++++-- .../StringInterpolationTests.swift | 2 +- Tests/SwiftSyntaxBuilderTest/StructTests.swift | 16 ++++++++++------ .../LexicalContextTests.swift | 2 +- .../MemberMacroTests.swift | 2 +- .../AssertionsTests.swift | 8 ++++---- Tests/SwiftSyntaxTest/SyntaxCreationTests.swift | 8 +++++--- Tests/SwiftSyntaxTest/SyntaxTests.swift | 6 ++++-- 17 files changed, 68 insertions(+), 49 deletions(-) diff --git a/Sources/SwiftCompilerPluginMessageHandling/Macros.swift b/Sources/SwiftCompilerPluginMessageHandling/Macros.swift index 0e51be77df0..7511aef7f69 100644 --- a/Sources/SwiftCompilerPluginMessageHandling/Macros.swift +++ b/Sources/SwiftCompilerPluginMessageHandling/Macros.swift @@ -132,7 +132,7 @@ extension PluginProviderMessageHandler { } let conformanceList = conformanceListSyntax.map { let placeholderStruct = sourceManager.add($0).cast(StructDeclSyntax.self) - return placeholderStruct.inheritanceClause!.inheritedTypes + return placeholderStruct.structHeader.inheritanceClause!.inheritedTypes } let context = PluginMacroExpansionContext( diff --git a/Sources/SwiftLexicalLookup/LookupName.swift b/Sources/SwiftLexicalLookup/LookupName.swift index 4530473d3bb..93d94467046 100644 --- a/Sources/SwiftLexicalLookup/LookupName.swift +++ b/Sources/SwiftLexicalLookup/LookupName.swift @@ -110,7 +110,7 @@ import SwiftSyntax case .Self(let declSyntax): switch Syntax(declSyntax).as(SyntaxEnum.self) { case .protocolDecl(let protocolDecl): - return protocolDecl.name.positionAfterSkippingLeadingTrivia + return protocolDecl.protocolHeader.name.positionAfterSkippingLeadingTrivia default: return declSyntax.positionAfterSkippingLeadingTrivia } diff --git a/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift b/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift index 81e8e649929..6d9520bfa0e 100644 --- a/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift +++ b/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift @@ -391,7 +391,7 @@ import SwiftSyntax } @_spi(Experimental) extension ExtensionDeclSyntax: LookInMembersScopeSyntax { @_spi(Experimental) public var lookupMembersPosition: AbsolutePosition { - extendedType.position + extensionHeader.extendedType.position } @_spi(Experimental) public var defaultIntroducedNames: [LookupName] { @@ -420,7 +420,8 @@ import SwiftSyntax + defaultLookupImplementation(identifier, at: lookUpPosition, with: config, propagateToParent: false) + [.lookInMembers(self)] + lookupInParent(identifier, at: lookUpPosition, with: config) - } else if !extendedType.range.contains(lookUpPosition) && genericWhereClause != nil { + } else if !extensionHeader.extendedType.range.contains(lookUpPosition) && extensionHeader.genericWhereClause != nil + { if inRightTypeOrSameTypeRequirement(lookUpPosition) { return [.lookInGenericParametersOfExtendedType(self)] + [.lookInMembers(self)] + defaultLookupImplementation(identifier, at: lookUpPosition, with: config) @@ -439,7 +440,7 @@ import SwiftSyntax private func inRightTypeOrSameTypeRequirement( _ checkedPosition: AbsolutePosition ) -> Bool { - genericWhereClause?.requirements.contains { elem in + extensionHeader.genericWhereClause?.requirements.contains { elem in switch Syntax(elem.requirement).as(SyntaxEnum.self) { case .conformanceRequirement(let conformanceRequirement): return conformanceRequirement.rightType.range.contains(checkedPosition) @@ -612,7 +613,7 @@ import SwiftSyntax } @_spi(Experimental) public var lookupMembersPosition: AbsolutePosition { - name.positionAfterSkippingLeadingTrivia + protocolHeader.name.positionAfterSkippingLeadingTrivia } @_spi(Experimental) public var scopeDebugName: String { @@ -644,7 +645,7 @@ import SwiftSyntax ) -> [LookupResult] { var results: [LookupResult] = [] - if let primaryAssociatedTypeClause, + if let primaryAssociatedTypeClause = protocolHeader.primaryAssociatedTypeClause, primaryAssociatedTypeClause.range.contains(lookUpPosition) { results = memberBlock.lookupAssociatedTypeDeclarations( @@ -656,7 +657,7 @@ import SwiftSyntax let lookInMembers: [LookupResult] - if !(inheritanceClause?.range.contains(lookUpPosition) ?? false) { + if !(protocolHeader.inheritanceClause?.range.contains(lookUpPosition) ?? false) { lookInMembers = [.lookInMembers(self)] } else { lookInMembers = [] diff --git a/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift b/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift index a0c54cab223..f4f813db79b 100644 --- a/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift +++ b/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift @@ -1490,7 +1490,7 @@ private extension SyntaxProtocol { var syntacticQualifiedTypeContext: TypeSyntax? { if let ext = self.as(ExtensionDeclSyntax.self) { // Don't handle nested 'extension' cases - they are invalid anyway. - return ext.extendedType.trimmed + return ext.extensionHeader.extendedType.trimmed } let base = self.parent?.syntacticQualifiedTypeContext diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index 345ca2739e9..c4c7113f702 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -2337,8 +2337,10 @@ final class DeclarationTests: ParserTestCase { CodeBlockItemSyntax( item: .init( ClassDeclSyntax( - classKeyword: .keyword(.class), - name: .identifier("A"), + classHeader: ClassDeclHeaderSyntax( + classKeyword: .keyword(.class), + name: .identifier("A") + ), memberBlock: MemberBlockSyntax( leftBrace: .leftBraceToken(), members: MemberBlockItemListSyntax(), @@ -2351,8 +2353,10 @@ final class DeclarationTests: ParserTestCase { CodeBlockItemSyntax( item: .init( ClassDeclSyntax( - classKeyword: .keyword(.class), - name: .identifier("B"), + classHeader: .init( + classKeyword: .keyword(.class), + name: .identifier("B") + ), memberBlock: MemberBlockSyntax( leftBrace: .leftBraceToken(), members: MemberBlockItemListSyntax(), diff --git a/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift b/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift index 69b56b06e9f..f3794787ebc 100644 --- a/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift +++ b/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift @@ -31,14 +31,16 @@ final class HashbangLibraryTests: ParserTestCase { item: .decl( DeclSyntax( ClassDeclSyntax( - classKeyword: .keyword( - .class, - leadingTrivia: [ - .newlines(1) - ], - trailingTrivia: .space + classHeader: ClassDeclHeaderSyntax( + classKeyword: .keyword( + .class, + leadingTrivia: [ + .newlines(1) + ], + trailingTrivia: .space + ), + name: .identifier("Foo", trailingTrivia: .space) ), - name: .identifier("Foo", trailingTrivia: .space), memberBlock: MemberBlockSyntax( members: MemberBlockItemListSyntax([]) ) diff --git a/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift b/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift index 1f217e35e31..14b947435ef 100644 --- a/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift @@ -35,7 +35,7 @@ final class ClassDeclSyntaxTests: XCTestCase { } func testThrowableClass() throws { - let buildable = try ClassDeclSyntax(name: .identifier("Foo")) { + let buildable = try ClassDeclSyntax(classHeader: .init(name: .identifier("Foo"))) { try FunctionDeclSyntax("func foo() -> String") { StmtSyntax(#"return "hello world""#) } @@ -54,7 +54,7 @@ final class ClassDeclSyntaxTests: XCTestCase { } func testNodeWithoutAnchorPointInResultBuilder() throws { - let buildable = ClassDeclSyntax(name: .identifier("Foo")) { + let buildable = ClassDeclSyntax(classHeader: .init(name: .identifier("Foo"))) { DeclSyntax( """ func foo() -> String { diff --git a/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift b/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift index 7ebd79605f1..1239d762d51 100644 --- a/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift @@ -19,12 +19,14 @@ final class EnumCaseElementTests: XCTestCase { let leadingTrivia = Trivia.unexpectedText("␣") let buildable = EnumDeclSyntax( leadingTrivia: leadingTrivia, - name: "Greeting", - inheritanceClause: InheritanceClauseSyntax { - InheritedTypeSyntax(type: TypeSyntax("String")) - InheritedTypeSyntax(type: TypeSyntax("Codable")) - InheritedTypeSyntax(type: TypeSyntax("Equatable")) - } + enumHeader: .init( + name: "Greeting", + inheritanceClause: InheritanceClauseSyntax { + InheritedTypeSyntax(type: TypeSyntax("String")) + InheritedTypeSyntax(type: TypeSyntax("Codable")) + InheritedTypeSyntax(type: TypeSyntax("Equatable")) + } + ) ) { MemberBlockItemSyntax( decl: EnumCaseDeclSyntax { diff --git a/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift b/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift index 8cb9ea1a7e4..ed3a418567c 100644 --- a/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift @@ -36,7 +36,7 @@ final class ExtensionDeclTests: XCTestCase { } let members = MemberBlockItemListSyntax(keywords.map { MemberBlockItemSyntax(decl: $0) }) let buildable = ExtensionDeclSyntax( - extendedType: TypeSyntax("TokenSyntax"), + extensionHeader: .init(extendedType: TypeSyntax("TokenSyntax")), memberBlock: MemberBlockSyntax(members: members) ) diff --git a/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift b/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift index 9e6b10c9835..436eb67fba4 100644 --- a/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift @@ -20,8 +20,10 @@ final class SourceFileTests: XCTestCase { DeclSyntax("import Foundation") DeclSyntax("import UIKit") ClassDeclSyntax( - classKeyword: .keyword(.class), - name: "SomeViewController", + classHeader: .init( + classKeyword: .keyword(.class), + name: "SomeViewController" + ), memberBlockBuilder: { DeclSyntax("let tableView: UITableView") } diff --git a/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift b/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift index 4194894c0e8..53a2eea23f4 100644 --- a/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift @@ -349,7 +349,7 @@ final class StringInterpolationTests: XCTestCase { } func testStringInterpolationInBuilder() { - let ext = ExtensionDeclSyntax(extendedType: TypeSyntax("MyType")) { + let ext = ExtensionDeclSyntax(extensionHeader: .init(extendedType: TypeSyntax("MyType"))) { DeclSyntax( """ /// diff --git a/Tests/SwiftSyntaxBuilderTest/StructTests.swift b/Tests/SwiftSyntaxBuilderTest/StructTests.swift index 94d2e09dc20..e2f1ad41cef 100644 --- a/Tests/SwiftSyntaxBuilderTest/StructTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/StructTests.swift @@ -17,7 +17,7 @@ import XCTest final class StructTests: XCTestCase { func testEmptyStruct() { let leadingTrivia = Trivia.unexpectedText("␣") - let buildable = StructDeclSyntax(leadingTrivia: leadingTrivia, name: "TestStruct") {} + let buildable = StructDeclSyntax(leadingTrivia: leadingTrivia, structHeader: .init(name: "TestStruct")) {} assertBuildResult( buildable, @@ -44,8 +44,10 @@ final class StructTests: XCTestCase { .docLineComment("/// with multi line comment where the newline is a CR"), .carriageReturns(1), ], - structKeyword: .keyword(.struct), - name: "CarriateReturnsStruct", + structHeader: .init( + structKeyword: .keyword(.struct), + name: "CarriateReturnsStruct" + ), memberBlock: MemberBlockSyntax(members: []) ) let carriageReturnFormFeedsStruct = StructDeclSyntax( @@ -55,8 +57,10 @@ final class StructTests: XCTestCase { .docLineComment("/// with multi line comment where the newline is a CRLF"), .carriageReturnLineFeeds(1), ], - structKeyword: .keyword(.struct), - name: "CarriageReturnFormFeedsStruct", + structHeader: .init( + structKeyword: .keyword(.struct), + name: "CarriageReturnFormFeedsStruct" + ), memberBlock: MemberBlockSyntax(members: []) ) let testStruct = try StructDeclSyntax("public struct TestStruct") { @@ -87,7 +91,7 @@ final class StructTests: XCTestCase { } func testControlWithLoopAndIf() { - let myStruct = StructDeclSyntax(name: "MyStruct") { + let myStruct = StructDeclSyntax(structHeader: .init(name: "MyStruct")) { for i in 0..<5 { if i.isMultiple(of: 2) { VariableDeclSyntax(bindingSpecifier: .keyword(.let)) { diff --git a/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift b/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift index 533a2a4d19f..8f77c925334 100644 --- a/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift +++ b/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift @@ -134,7 +134,7 @@ extension SyntaxProtocol { // Extensions if let extensionDecl = self.as(ExtensionDeclSyntax.self) { // FIXME: It would be nice to be able to switch on type syntax... - let extendedType = extensionDecl.extendedType + let extendedType = extensionDecl.extensionHeader.extendedType if let simple = extendedType.as(IdentifierTypeSyntax.self) { return simple.name.trimmedDescription } diff --git a/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift b/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift index 48f1fcc7aaf..4aa93d57a67 100644 --- a/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift +++ b/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift @@ -450,7 +450,7 @@ final class MemberMacroTests: XCTestCase { // This doesn't account for other attributes that *could* be present in the // attribute list, but for this test it will be fine. .replace( - oldNode: Syntax(declaration.attributes), + oldNode: Syntax(declaration.header.attributes), newNode: Syntax(AttributeListSyntax()) ) ] diff --git a/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift b/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift index 862f3e0f3f7..b5ad9d84b60 100644 --- a/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift +++ b/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift @@ -33,7 +33,7 @@ final class AssertionsTests: XCTestCase { if let structDecl = declaration.as(StructDeclSyntax.self) { context.diagnose( .init( - node: structDecl.structKeyword, + node: structDecl.structHeader.structKeyword, message: OnlyStruct() ) ) @@ -52,11 +52,11 @@ final class AssertionsTests: XCTestCase { if let structDecl = declaration.as(StructDeclSyntax.self) { context.diagnose( .init( - node: structDecl.structKeyword, + node: structDecl.structHeader.structKeyword, message: OnlyStruct(), highlights: [ - Syntax(structDecl.structKeyword), - Syntax(structDecl.name), + Syntax(structDecl.structHeader.structKeyword), + Syntax(structDecl.structHeader.name), ] ) ) diff --git a/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift b/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift index bde8943a31f..47a077aa204 100644 --- a/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift +++ b/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift @@ -23,8 +23,10 @@ fileprivate func cannedStructDecl() -> StructDeclSyntax { rightBrace: rBrace ) return StructDeclSyntax( - structKeyword: structKW, - name: fooID, + structHeader: .init( + structKeyword: structKW, + name: fooID + ), memberBlock: memberBlock ) } @@ -46,7 +48,7 @@ class SyntaxCreationTests: XCTestCase { let forType = TokenSyntax.identifier("`for`", trailingTrivia: .space) let newBrace = TokenSyntax.rightBraceToken(leadingTrivia: .newlines(2)) - let renamed = structDecl.with(\.name, forType) + let renamed = structDecl.with(\.structHeader.name, forType) .with( \.memberBlock, structDecl.memberBlock diff --git a/Tests/SwiftSyntaxTest/SyntaxTests.swift b/Tests/SwiftSyntaxTest/SyntaxTests.swift index 42e569153cb..c56bdf079b7 100644 --- a/Tests/SwiftSyntaxTest/SyntaxTests.swift +++ b/Tests/SwiftSyntaxTest/SyntaxTests.swift @@ -40,8 +40,10 @@ class SyntaxTests: XCTestCase { public func testDetached() { let s = StructDeclSyntax( - structKeyword: .keyword(.struct), - name: .identifier("someStruct"), + structHeader: .init( + structKeyword: .keyword(.struct), + name: .identifier("someStruct") + ), memberBlock: MemberBlockSyntax(leftBrace: .leftBraceToken(), members: [], rightBrace: .rightBraceToken()) ) From cb0f4b912bd17f550be13fc49348d490bdaf6098 Mon Sep 17 00:00:00 2001 From: Becca Royal-Gordon Date: Fri, 1 Nov 2024 17:46:30 -0700 Subject: [PATCH 6/7] Rework `HasTrailingMemberDeclBlock` `DeclGroup` now requires an initializer that can build a group from a header and member block. With that in place, we can reimplement `HasTrailingMemberDeclBlock` to avoid reparsing anything. Which is kind of neat. --- .../SyntaxSupport/CompatibilityLayer.swift | 2 + .../Sources/SyntaxSupport/Traits.swift | 4 + .../InitSignature+Extensions.swift | 22 ++-- .../swiftsyntax/SyntaxTraitsFile.swift | 10 ++ Sources/SwiftSyntax/CustomTraits.swift | 102 ++++++++++++++++++ .../SwiftSyntax/generated/SyntaxTraits.swift | 12 +++ .../Syntax+StringInterpolation.swift | 16 +++ .../SyntaxNodeWithBody.swift | 31 +++--- 8 files changed, 174 insertions(+), 25 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift b/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift index a3fe70dd372..a391f6ba2d3 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift @@ -180,6 +180,8 @@ public struct CompatibilityLayer { vars += children.filter { knownVars.insert($0).inserted } // We don't create compatibility layers for protocol requirement inits. + // In theory, we *could* create compatibility layers for traits with `requiresInit: true`, but the only one we'd + // create so far is unnecessary and tricky to implement. if !areRequirements { initSignatures.append(InitSignature(children: children)) } diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index baeb30f09bc..dc6d6b76b99 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -21,6 +21,7 @@ public class Trait { public let baseKind: SyntaxNodeKind? public let protocolName: TokenSyntax public let documentation: SwiftSyntax.Trivia + public let requiresInit: Bool public let children: [Child] public let childHistory: Child.History @@ -28,6 +29,7 @@ public class Trait { traitName: String, baseKind: SyntaxNodeKind? = nil, documentation: String? = nil, + requiresInit: Bool = false, children: [Child], childHistory: Child.History = [] ) { @@ -36,6 +38,7 @@ public class Trait { self.baseKind = baseKind self.protocolName = .identifier("\(traitName)Syntax") self.documentation = SwiftSyntax.Trivia.docCommentTrivia(from: documentation) + self.requiresInit = requiresInit self.children = children self.childHistory = childHistory } @@ -52,6 +55,7 @@ public let TRAITS: [Trait] = [ Trait( traitName: "DeclGroup", baseKind: .decl, + requiresInit: true, children: [ Child( name: "header", diff --git a/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift b/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift index 97a61847829..d02ee5cb858 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift @@ -28,9 +28,11 @@ extension InitSignature { return "init(leadingTrivia:\(renamedArguments)trailingTrivia:)" } - func generateInitializerDeclHeader() -> SyntaxNodeString { + func generateInitializerDeclHeader(isRequirement: Bool = false) -> SyntaxNodeString { + let stub = isRequirement ? "init?" : "public init" + if children.isEmpty { - return "public init()" + return "\(raw: stub)()" } func createFunctionParameterSyntax(for child: Child) -> FunctionParameterSyntax { @@ -63,19 +65,25 @@ extension InitSignature { ) } + func transformParam(_ param: FunctionParameterSyntax) -> FunctionParameterSyntax { + isRequirement ? param.with(\.defaultValue, nil) : param + } + let params = FunctionParameterListSyntax { - FunctionParameterSyntax("leadingTrivia: Trivia? = nil") + transformParam(FunctionParameterSyntax("leadingTrivia: Trivia? = nil")) for child in children { - createFunctionParameterSyntax(for: child) + transformParam(createFunctionParameterSyntax(for: child)) } - FunctionParameterSyntax("trailingTrivia: Trivia? = nil") - .with(\.leadingTrivia, .newline) + transformParam( + FunctionParameterSyntax("trailingTrivia: Trivia? = nil") + .with(\.leadingTrivia, .newline) + ) } return """ - public init( + \(raw: stub)( \(params) ) """ diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift index 32989b0fd2f..6008e581a72 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift @@ -37,6 +37,16 @@ let syntaxTraitsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { """ ) } + + if trait.requiresInit { + let signature = InitSignature(trait) + DeclSyntax( + """ + \(signature.generateInitializerDocComment()) + \(signature.generateInitializerDeclHeader(isRequirement: true)) + """ + ) + } } try! ExtensionDeclSyntax("extension \(trait.protocolName)") { diff --git a/Sources/SwiftSyntax/CustomTraits.swift b/Sources/SwiftSyntax/CustomTraits.swift index f47b3b43580..8cc12cb7583 100644 --- a/Sources/SwiftSyntax/CustomTraits.swift +++ b/Sources/SwiftSyntax/CustomTraits.swift @@ -30,6 +30,23 @@ extension ActorDeclSyntax { actorHeader = newValue.cast(ActorDeclHeaderSyntax.self) } } + + public init?( + leadingTrivia: Trivia? = nil, + header: some DeclGroupHeaderSyntaxProtocol, + memberBlock: MemberBlockSyntax, + trailingTrivia: Trivia? = nil + ) { + guard let actorHeader = header.as(ActorDeclHeaderSyntax.self) else { + return nil + } + self.init( + leadingTrivia: leadingTrivia, + actorHeader: actorHeader, + memberBlock: memberBlock, + trailingTrivia: trailingTrivia + ) + } } extension ClassDeclHeaderSyntax { @@ -52,6 +69,23 @@ extension ClassDeclSyntax { classHeader = newValue.cast(ClassDeclHeaderSyntax.self) } } + + public init?( + leadingTrivia: Trivia? = nil, + header: some DeclGroupHeaderSyntaxProtocol, + memberBlock: MemberBlockSyntax, + trailingTrivia: Trivia? = nil + ) { + guard let classHeader = header.as(ClassDeclHeaderSyntax.self) else { + return nil + } + self.init( + leadingTrivia: leadingTrivia, + classHeader: classHeader, + memberBlock: memberBlock, + trailingTrivia: trailingTrivia + ) + } } extension EnumDeclHeaderSyntax { @@ -74,6 +108,23 @@ extension EnumDeclSyntax { enumHeader = newValue.cast(EnumDeclHeaderSyntax.self) } } + + public init?( + leadingTrivia: Trivia? = nil, + header: some DeclGroupHeaderSyntaxProtocol, + memberBlock: MemberBlockSyntax, + trailingTrivia: Trivia? = nil + ) { + guard let enumHeader = header.as(EnumDeclHeaderSyntax.self) else { + return nil + } + self.init( + leadingTrivia: leadingTrivia, + enumHeader: enumHeader, + memberBlock: memberBlock, + trailingTrivia: trailingTrivia + ) + } } extension ExtensionDeclHeaderSyntax { @@ -96,6 +147,23 @@ extension ExtensionDeclSyntax { extensionHeader = newValue.cast(ExtensionDeclHeaderSyntax.self) } } + + public init?( + leadingTrivia: Trivia? = nil, + header: some DeclGroupHeaderSyntaxProtocol, + memberBlock: MemberBlockSyntax, + trailingTrivia: Trivia? = nil + ) { + guard let extensionHeader = header.as(ExtensionDeclHeaderSyntax.self) else { + return nil + } + self.init( + leadingTrivia: leadingTrivia, + extensionHeader: extensionHeader, + memberBlock: memberBlock, + trailingTrivia: trailingTrivia + ) + } } extension MissingDeclHeaderSyntax { @@ -129,6 +197,23 @@ extension ProtocolDeclSyntax { protocolHeader = newValue.cast(ProtocolDeclHeaderSyntax.self) } } + + public init?( + leadingTrivia: Trivia? = nil, + header: some DeclGroupHeaderSyntaxProtocol, + memberBlock: MemberBlockSyntax, + trailingTrivia: Trivia? = nil + ) { + guard let protocolHeader = header.as(ProtocolDeclHeaderSyntax.self) else { + return nil + } + self.init( + leadingTrivia: leadingTrivia, + protocolHeader: protocolHeader, + memberBlock: memberBlock, + trailingTrivia: trailingTrivia + ) + } } extension StructDeclHeaderSyntax { @@ -151,6 +236,23 @@ extension StructDeclSyntax { structHeader = newValue.cast(StructDeclHeaderSyntax.self) } } + + public init?( + leadingTrivia: Trivia? = nil, + header: some DeclGroupHeaderSyntaxProtocol, + memberBlock: MemberBlockSyntax, + trailingTrivia: Trivia? = nil + ) { + guard let structHeader = header.as(StructDeclHeaderSyntax.self) else { + return nil + } + self.init( + leadingTrivia: leadingTrivia, + structHeader: structHeader, + memberBlock: memberBlock, + trailingTrivia: trailingTrivia + ) + } } //==========================================================================// diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index c86d6d7ee3a..8dc1d2b5541 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -72,6 +72,18 @@ public protocol DeclGroupSyntax: SyntaxProtocol, DeclSyntaxProtocol { get set } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - header: The header of the declaration. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + + init?( + leadingTrivia: Trivia? , + header: some DeclGroupHeaderSyntaxProtocol, + memberBlock: MemberBlockSyntax, + trailingTrivia: Trivia? + ) } extension DeclGroupSyntax { diff --git a/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift b/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift index abf3d4a0f45..4889916c27b 100644 --- a/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift +++ b/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift @@ -184,6 +184,22 @@ public struct SyntaxStringInterpolationInvalidNodeTypeError: Error, CustomString } } +/// Describes an error when building a syntax node with string interpolation resulted in an unexpected node type. +public struct SyntaxStringInterpolationInvalidHeaderForNodeTypeError: Error, CustomStringConvertible { + let declType: SyntaxProtocol.Type + let headerType: SyntaxProtocol.Type + + /// Initialize the invalid node type error providing an expected type, and the actual node that resulted. + public init(declType: SyntaxProtocol.Type, headerNode: S) { + self.declType = declType + self.headerType = type(of: headerNode) + } + + public var description: String { + return "Attempted to construct an \(declType) declaration with a header of mismatched type \(headerType)" + } +} + /// A string interpolation error based on a ``SwiftDiagnostics/Diagnostic``. struct SyntaxStringInterpolationDiagnosticError: Error, CustomStringConvertible { let diagnostics: [Diagnostic] diff --git a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift index 6d0f2dae993..9f3796e1ec7 100644 --- a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift +++ b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift @@ -177,32 +177,27 @@ public protocol HasTrailingMemberDeclBlock { /// /// Throws an error if `header` defines a different node type than the type the initializer is called on. E.g. if calling `try StructDeclSyntax("class MyClass") {}` init( - _ header: SyntaxNodeString, + _ header: DeclGroupHeaderSyntax, @MemberBlockItemListBuilder membersBuilder: () throws -> MemberBlockItemListSyntax ) throws } -extension HasTrailingMemberDeclBlock where Self: DeclSyntaxProtocol { +extension HasTrailingMemberDeclBlock where Self: DeclGroupSyntax { public init( - _ header: SyntaxNodeString, + _ header: DeclGroupHeaderSyntax, @MemberBlockItemListBuilder membersBuilder: () throws -> MemberBlockItemListSyntax ) throws { - // If the type provides a custom `SyntaxParseable` implementation, use that. Otherwise construct it as a - // `DeclSyntax`. - let decl: DeclSyntax - var stringInterpolation = SyntaxStringInterpolation(literalCapacity: 1, interpolationCount: 1) - stringInterpolation.appendInterpolation(header) - stringInterpolation.appendLiteral(" {}") - if let parsableType = Self.self as? SyntaxParseable.Type { - decl = parsableType.init(stringInterpolation: stringInterpolation).cast(DeclSyntax.self) - } else { - decl = DeclSyntax(stringInterpolation: stringInterpolation) + guard + let newSelf = Self( + leadingTrivia: nil, + header: header, + memberBlock: try MemberBlockSyntax(members: membersBuilder()), + trailingTrivia: nil + ) + else { + throw SyntaxStringInterpolationInvalidHeaderForNodeTypeError(declType: Self.self, headerNode: header) } - guard let castedDecl = decl.as(Self.self) else { - throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: decl) - } - self = castedDecl - self.memberBlock = try MemberBlockSyntax(members: membersBuilder()) + self = newSelf } } From 54ce286679a8be06c7b0fc9eaff546313fed5bac Mon Sep 17 00:00:00 2001 From: Becca Royal-Gordon Date: Wed, 30 Oct 2024 19:44:16 -0700 Subject: [PATCH 7/7] Parse the `@abi` attribute in SwiftSyntax Matches work in swiftlang/swift#76878. --- .../SyntaxSupport/AttributeNodes.swift | 30 ++ .../SyntaxSupport/ExperimentalFeatures.swift | 3 + .../Sources/SyntaxSupport/KeywordSpec.swift | 3 + .../SyntaxSupport/SyntaxNodeKind.swift | 12 +- .../Sources/Utils/SyntaxBuildableType.swift | 2 +- .../swiftsyntax/SyntaxEnumFile.swift | 2 +- Sources/SwiftParser/Attributes.swift | 98 +++- Sources/SwiftParser/Declarations.swift | 102 +++- Sources/SwiftParser/Nominals.swift | 26 +- Sources/SwiftParser/TokenPrecedence.swift | 1 + .../generated/ExperimentalFeatures.swift | 3 + .../ParseDiagnosticsGenerator.swift | 16 + .../ParserDiagnosticMessages.swift | 21 +- .../SyntaxKindNameForDiagnostics.swift | 2 + .../generated/ChildNameForKeyPath.swift | 6 + Sources/SwiftSyntax/generated/Keyword.swift | 7 + .../generated/SyntaxAnyVisitor.swift | 14 + .../generated/SyntaxBaseNodes.swift | 1 + .../SwiftSyntax/generated/SyntaxEnum.swift | 6 + .../SwiftSyntax/generated/SyntaxKind.swift | 6 + .../generated/SyntaxRewriter.swift | 16 + .../SwiftSyntax/generated/SyntaxVisitor.swift | 24 + .../generated/raw/RawSyntaxNodesAB.swift | 146 +++++- .../generated/raw/RawSyntaxValidation.swift | 6 + .../generated/syntaxNodes/SyntaxNodesAB.swift | 466 +++++++++++++++++- Tests/SwiftParserTest/AttributeTests.swift | 270 +++++++++- 26 files changed, 1255 insertions(+), 34 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift index 28e4baf5045..b5a2a4e9f3c 100644 --- a/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift @@ -139,6 +139,11 @@ public let ATTRIBUTE_NODES: [Node] = [ name: "documentationArguments", kind: .node(kind: .documentationAttributeArgumentList) ), + Child( + name: "abiArguments", + kind: .node(kind: .abiAttributeArguments), + experimentalFeature: .abiAttribute + ), ]), documentation: """ The arguments of the attribute. @@ -267,6 +272,31 @@ public let ATTRIBUTE_NODES: [Node] = [ ] ), + Node( + kind: .abiAttributeArguments, + base: .syntax, + experimentalFeature: .abiAttribute, + nameForDiagnostics: "ABI-providing declaration", + documentation: "The arguments of the '@abi' attribute", + children: [ + Child( + name: "provider", + kind: ChildKind.nodeChoices(choices: [ + Child(name: "associatedType", kind: .node(kind: .associatedTypeDecl)), + Child(name: "declGroup", kind: .node(kind: .declGroupHeader)), + Child(name: "deinitializer", kind: .node(kind: .deinitializerDecl)), + Child(name: "enumCase", kind: .node(kind: .enumCaseDecl)), + Child(name: "function", kind: .node(kind: .functionDecl)), + Child(name: "initializer", kind: .node(kind: .initializerDecl)), + Child(name: "subscript", kind: .node(kind: .subscriptDecl)), + Child(name: "typeAlias", kind: .node(kind: .typeAliasDecl)), + Child(name: "variable", kind: .node(kind: .variableDecl)), + Child(name: "unsupported", kind: .node(kind: .decl)), + ]) + ) + ] + ), + Node( kind: .conventionAttributeArguments, base: .syntax, diff --git a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift index 35fadbc0f2f..43d4fd0691f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift +++ b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift @@ -19,6 +19,7 @@ public enum ExperimentalFeature: String, CaseIterable { case nonescapableTypes case trailingComma case coroutineAccessors + case abiAttribute /// The name of the feature, which is used in the doc comment. public var featureName: String { @@ -35,6 +36,8 @@ public enum ExperimentalFeature: String, CaseIterable { return "trailing comma" case .coroutineAccessors: return "CoroutineAccessors" + case .abiAttribute: + return "@abi attribute" } } diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift index b1f35ef6433..00085156307 100644 --- a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift +++ b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift @@ -131,6 +131,7 @@ public enum Keyword: CaseIterable { case _underlyingVersion case _UnknownLayout case _version + case abi case accesses case actor case addressWithNativeOwner @@ -404,6 +405,8 @@ public enum Keyword: CaseIterable { return KeywordSpec("_UnknownLayout") case ._version: return KeywordSpec("_version") + case .abi: + return KeywordSpec("abi", experimentalFeature: .abiAttribute) case .accesses: return KeywordSpec("accesses") case .actor: diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index b6e97d92050..f0a40af29a9 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -22,6 +22,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case _canImportExpr case _canImportVersionInfo + case abiAttributeArguments case accessorBlock case accessorDecl case accessorDeclList @@ -348,6 +349,15 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon return .identifier(rawValue) } + public var uppercasedFirstWordRawValue: String { + switch self { + case .abiAttributeArguments: + "ABIAttributeArguments" + default: + rawValue.withFirstCharacterUppercased + } + } + public var syntaxType: TypeSyntax { switch self { case .syntax: @@ -355,7 +365,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case .syntaxCollection: return "SyntaxCollection" default: - return "\(raw: rawValue.withFirstCharacterUppercased)Syntax" + return "\(raw: uppercasedFirstWordRawValue)Syntax" } } diff --git a/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift b/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift index 954114c87bc..a9b68bf05ce 100644 --- a/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift +++ b/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift @@ -151,7 +151,7 @@ public struct SyntaxBuildableType: Hashable { public var resultBuilderType: TypeSyntax { switch kind { case .node(kind: let kind): - return TypeSyntax("\(raw: kind.rawValue.withFirstCharacterUppercased)Builder") + return TypeSyntax("\(raw: kind.uppercasedFirstWordRawValue)Builder") case .token: preconditionFailure("Tokens cannot be constructed using result builders") } diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift index b1758f26295..5afd357d4dc 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift @@ -60,7 +60,7 @@ let syntaxEnumFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { for base in SYNTAX_NODES where base.kind.isBase { let baseKind = base.kind - let baseName = baseKind.rawValue.withFirstCharacterUppercased + let baseName = baseKind.uppercasedFirstWordRawValue let enumType: TypeSyntax = "\(raw: baseName)SyntaxEnum" try! EnumDeclSyntax( diff --git a/Sources/SwiftParser/Attributes.swift b/Sources/SwiftParser/Attributes.swift index ff3fd07596d..35fff842a31 100644 --- a/Sources/SwiftParser/Attributes.swift +++ b/Sources/SwiftParser/Attributes.swift @@ -11,9 +11,9 @@ //===----------------------------------------------------------------------===// #if swift(>=6) -@_spi(RawSyntax) internal import SwiftSyntax +@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) internal import SwiftSyntax #else -@_spi(RawSyntax) import SwiftSyntax +@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax #endif extension Parser { @@ -58,6 +58,7 @@ extension Parser { case _typeEraser case _unavailableFromAsync case `rethrows` + case abi case attached case available case backDeployed @@ -95,6 +96,7 @@ extension Parser { case TokenSpec(._typeEraser): self = ._typeEraser case TokenSpec(._unavailableFromAsync): self = ._unavailableFromAsync case TokenSpec(.`rethrows`): self = .rethrows + case TokenSpec(.abi) where experimentalFeatures.contains(.abiAttribute): self = .abi case TokenSpec(.attached): self = .attached case TokenSpec(.available): self = .available case TokenSpec(.backDeployed): self = .backDeployed @@ -136,6 +138,7 @@ extension Parser { case ._typeEraser: return .keyword(._typeEraser) case ._unavailableFromAsync: return .keyword(._unavailableFromAsync) case .`rethrows`: return .keyword(.rethrows) + case .abi: return .keyword(.abi) case .attached: return .keyword(.attached) case .available: return .keyword(.available) case .backDeployed: return .keyword(.backDeployed) @@ -176,9 +179,16 @@ extension Parser { case noArgument } + /// Parse the argument of an attribute, if it has one. + /// + /// - Parameters: + /// - argumentMode: Indicates whether the attribute must, may, or may not have an argument. + /// - parseArguments: Called to parse the argument list. If there is an opening parenthesis, it will have already been consumed. + /// - parseMissingArguments: If provided, called instead of `parseArgument` when an argument list was required but no opening parenthesis was present. mutating func parseAttribute( argumentMode: AttributeArgumentMode, - parseArguments: (inout Parser) -> RawAttributeSyntax.Arguments + parseArguments: (inout Parser) -> RawAttributeSyntax.Arguments, + parseMissingArguments: ((inout Parser) -> RawAttributeSyntax.Arguments)? = nil ) -> RawAttributeListSyntax.Element { var (unexpectedBeforeAtSign, atSign) = self.expect(.atSign) if atSign.trailingTriviaByteLength > 0 || self.currentToken.leadingTriviaByteLength > 0 { @@ -213,7 +223,12 @@ extension Parser { ) leftParen = leftParen.tokenView.withTokenDiagnostic(tokenDiagnostic: diagnostic, arena: self.arena) } - let argument = parseArguments(&self) + let argument = + if let parseMissingArguments, leftParen.presence == .missing { + parseMissingArguments(&self) + } else { + parseArguments(&self) + } let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) return .attribute( RawAttributeSyntax( @@ -255,6 +270,12 @@ extension Parser { } switch peek(isAtAnyIn: DeclarationAttributeWithSpecialSyntax.self) { + case .abi: + return parseAttribute(argumentMode: .required) { parser in + return .abiArguments(parser.parseABIAttributeArguments()) + } parseMissingArguments: { parser in + return .abiArguments(parser.parseABIAttributeArguments(missing: true)) + } case .available, ._spi_available: return parseAttribute(argumentMode: .required) { parser in return .availability(parser.parseAvailabilityArgumentSpecList()) @@ -918,6 +939,75 @@ extension Parser { } } +extension Parser { + mutating func parseABIAttributeArguments(missing: Bool = false) -> RawABIAttributeArgumentsSyntax { + let providerDecl: RawABIAttributeArgumentsSyntax.Provider + if missing || at(.rightParen) { + // There are two situations where the left paren might be missing: + // 1. The user just forgot the paren: `@abi var x_abi: Int) var x: Int` + // 2. The user forgot the whole argument list: `@abi var x: Int` + // Normally, we would distinguish these by seeing if whatever comes after + // the attribute parses as an argument. However, for @abi the argument is + // a decl, so in #2, we would consume the decl the attribute is attached + // to! This leads to a lousy diagnostic in that situation. + // Avoid this problem by simply returning a missing decl immediately. + // FIXME: Could we look ahead to find an unbalanced parenthesis? + providerDecl = .unsupported( + RawDeclSyntax( + RawMissingDeclSyntax( + attributes: self.emptyCollection(RawAttributeListSyntax.self), + modifiers: self.emptyCollection(RawDeclModifierListSyntax.self), + arena: arena + ) + ) + ) + } else { + switch nextDeclarationKeyword() { + case .group?: + providerDecl = RawABIAttributeArgumentsSyntax.Provider(parseDeclarationGroupHeader())! + + case .simple?, .binding?, nil: + providerDecl = RawABIAttributeArgumentsSyntax.Provider(parseDeclaration(in: .argumentList))! + } + } + + return RawABIAttributeArgumentsSyntax(provider: providerDecl, arena: arena) + } + + mutating func nextDeclarationKeyword() -> DeclarationKeyword? { + return self.withLookahead { subparser in + // Consume attributes. + var attributeProgress = LoopProgressCondition() + while subparser.hasProgressed(&attributeProgress) && subparser.at(.atSign) { + _ = subparser.consumeAttributeList() + } + + // Consume modifiers. + if subparser.currentToken.isLexerClassifiedKeyword || subparser.currentToken.rawTokenKind == .identifier { + var modifierProgress = LoopProgressCondition() + while let (modifierKind, handle) = subparser.at(anyIn: DeclarationModifier.self), + subparser.hasProgressed(&modifierProgress) + { + if modifierKind == .class { + // `class` is a modifier only if it's followed by an introducer or modifier. + if subparser.peek(isAtAnyIn: DeclarationStart.self) == nil { + break + } + } + subparser.eat(handle) + if subparser.at(.leftParen) && modifierKind.canHaveParenthesizedArgument { + subparser.consumeAnyToken() + subparser.consume(to: .rightParen) + } + } + } + + // Is the next thing a declaration introducer? + return subparser.at(anyIn: DeclarationKeyword.self)?.spec + } + } +} + extension Parser { mutating func parseBackDeployedAttributeArguments() -> RawBackDeployedAttributeArgumentsSyntax { let (unexpectedBeforeLabel, label) = self.expect(.keyword(.before)) diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index 9722bafd4af..6255305e19f 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -168,11 +168,37 @@ extension Parser { } } + enum DeclarationParseContext { + case topLevel + case memberDeclList + case argumentList + + var requiresDecl: Bool { + switch self { + case .topLevel: + return false + case .memberDeclList, .argumentList: + return true + } + } + + var recoveryPrecedence: TokenPrecedence? { + switch self { + case .topLevel: + return nil + case .memberDeclList: + return .closingBrace + case .argumentList: + return .weakBracketed(closingDelimiter: .rightParen) + } + } + } + /// Parse a declaration. /// /// If `inMemberDeclList` is `true`, we know that the next item must be a /// declaration and thus start with a keyword. This allows further recovery. - mutating func parseDeclaration(inMemberDeclList: Bool = false) -> RawDeclSyntax { + mutating func parseDeclaration(in context: DeclarationParseContext = .topLevel) -> RawDeclSyntax { // If we are at a `#if` of attributes, the `#if` directive should be // parsed when we're parsing the attributes. if self.at(.poundIf) && !self.withLookahead({ $0.consumeIfConfigOfAttributes() }) { @@ -221,8 +247,10 @@ extension Parser { // to parse. // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context) // while recovering to the declaration start. - let recoveryPrecedence = inMemberDeclList ? TokenPrecedence.closingBrace : nil - recoveryResult = self.canRecoverTo(anyIn: DeclarationKeyword.self, overrideRecoveryPrecedence: recoveryPrecedence) + recoveryResult = self.canRecoverTo( + anyIn: DeclarationKeyword.self, + overrideRecoveryPrecedence: context.recoveryPrecedence + ) } switch recoveryResult { @@ -230,7 +258,8 @@ extension Parser { let (header, shouldContinueParsing) = parseHeaderForDeclarationGroup( attrs: attrs, introducer: introducer, - introducerHandle: handle + introducerHandle: handle, + allowsMemberBlock: true ) return parseDeclarationGroup(for: header, shouldParseMemberBlock: shouldContinueParsing) case (.simple(.import), let handle)?: @@ -258,12 +287,12 @@ extension Parser { case (.simple(.pound), let handle)?: return RawDeclSyntax(self.parseMacroExpansionDeclaration(attrs, handle)) case (.binding, let handle)?: - return RawDeclSyntax(self.parseBindingDeclaration(attrs, handle, inMemberDeclList: inMemberDeclList)) + return RawDeclSyntax(self.parseBindingDeclaration(attrs, handle, in: context)) case nil: break } - if inMemberDeclList { + if context.requiresDecl { let isProbablyVarDecl = self.at(.identifier, .wildcard) && self.peek(isAt: .colon, .equal, .comma) let isProbablyTupleDecl = self.at(.leftParen) && self.peek(isAt: .identifier, .wildcard) @@ -366,7 +395,12 @@ extension Parser { } if let (match, handle) = recoveryResult { - return parseHeaderForDeclarationGroup(attrs: attrs, introducer: match, introducerHandle: handle).0 + return parseHeaderForDeclarationGroup( + attrs: attrs, + introducer: match, + introducerHandle: handle, + allowsMemberBlock: false + ).0 } if inMemberDeclList { @@ -397,11 +431,17 @@ extension Parser { ) } - /// Parse the header of a declaration group that will eventually have a member block attached. + /// Parse the header of a declaration group that will belong to some larger construct. + /// + /// - Parameters: + /// - allowsMemberBlock: If `false`, a member block is definitively *not* + /// expected after this header and if one is found, it should be + /// proactively consumed. mutating func parseHeaderForDeclarationGroup( attrs: DeclAttributes, introducer: DeclGroupHeaderSyntax.IntroducerOptions, - introducerHandle: RecoveryConsumptionHandle + introducerHandle: RecoveryConsumptionHandle, + allowsMemberBlock: Bool ) -> (RawDeclGroupHeaderSyntax, shouldContinueParsing: Bool) { func eraseToRawDeclGroupHeaderSyntax( _ result: (some RawDeclGroupHeaderSyntaxNodeProtocol, Bool) @@ -415,7 +455,8 @@ extension Parser { self.parseNominalTypeDeclarationHeader( for: RawClassDeclHeaderSyntax.self, attrs: attrs, - introducerHandle: introducerHandle + introducerHandle: introducerHandle, + allowsMemberBlock: allowsMemberBlock ) ) case .enum: @@ -423,7 +464,8 @@ extension Parser { self.parseNominalTypeDeclarationHeader( for: RawEnumDeclHeaderSyntax.self, attrs: attrs, - introducerHandle: introducerHandle + introducerHandle: introducerHandle, + allowsMemberBlock: allowsMemberBlock ) ) case .struct: @@ -431,7 +473,8 @@ extension Parser { self.parseNominalTypeDeclarationHeader( for: RawStructDeclHeaderSyntax.self, attrs: attrs, - introducerHandle: introducerHandle + introducerHandle: introducerHandle, + allowsMemberBlock: allowsMemberBlock ) ) case .protocol: @@ -439,17 +482,23 @@ extension Parser { self.parseNominalTypeDeclarationHeader( for: RawProtocolDeclHeaderSyntax.self, attrs: attrs, - introducerHandle: introducerHandle + introducerHandle: introducerHandle, + allowsMemberBlock: allowsMemberBlock ) ) case .extension: - return (RawDeclGroupHeaderSyntax(self.parseExtensionDeclarationHeader(attrs, introducerHandle)), true) + return ( + RawDeclGroupHeaderSyntax( + self.parseExtensionDeclarationHeader(attrs, introducerHandle, allowsMemberBlock: allowsMemberBlock) + ), true + ) case .actor: return eraseToRawDeclGroupHeaderSyntax( self.parseNominalTypeDeclarationHeader( for: RawActorDeclHeaderSyntax.self, attrs: attrs, - introducerHandle: introducerHandle + introducerHandle: introducerHandle, + allowsMemberBlock: allowsMemberBlock ) ) } @@ -623,14 +672,15 @@ extension Parser { _ attrs: DeclAttributes, _ handle: RecoveryConsumptionHandle ) -> RawExtensionDeclSyntax { - let header = parseExtensionDeclarationHeader(attrs, handle) + let header = parseExtensionDeclarationHeader(attrs, handle, allowsMemberBlock: true) return parseDeclarationGroup(for: header) } /// Parse the header of an extension declaration. mutating func parseExtensionDeclarationHeader( _ attrs: DeclAttributes, - _ handle: RecoveryConsumptionHandle + _ handle: RecoveryConsumptionHandle, + allowsMemberBlock: Bool ) -> RawExtensionDeclHeaderSyntax { let (unexpectedBeforeExtensionKeyword, extensionKeyword) = self.eat(handle) let type = self.parseType() @@ -648,6 +698,17 @@ extension Parser { } else { whereClause = nil } + + // If we know there shouldn't be a member block, but there is, gobble it up whole right now. + var trailingUnexpectedNodes: RawUnexpectedNodesSyntax? + if !allowsMemberBlock && self.at(.leftBrace) { + let forbiddenMemberBlock = parseMemberBlock(introducer: extensionKeyword) + trailingUnexpectedNodes = RawUnexpectedNodesSyntax( + [forbiddenMemberBlock], + arena: self.arena + ) + } + return RawExtensionDeclHeaderSyntax( attributes: attrs.attributes, modifiers: attrs.modifiers, @@ -656,6 +717,7 @@ extension Parser { extendedType: type, inheritanceClause: inheritance, genericWhereClause: whereClause, + trailingUnexpectedNodes, arena: self.arena ) } @@ -997,7 +1059,7 @@ extension Parser { if self.at(.poundSourceLocation) { decl = RawDeclSyntax(self.parsePoundSourceLocationDirective()) } else { - decl = self.parseDeclaration(inMemberDeclList: true) + decl = self.parseDeclaration(in: .memberDeclList) } let semi = self.consume(if: .semicolon) @@ -1519,7 +1581,7 @@ extension Parser { mutating func parseBindingDeclaration( _ attrs: DeclAttributes, _ handle: RecoveryConsumptionHandle, - inMemberDeclList: Bool = false + in context: DeclarationParseContext = .topLevel ) -> RawVariableDeclSyntax { let (unexpectedBeforeIntroducer, introducer) = self.eat(handle) let hasTryBeforeIntroducer = unexpectedBeforeIntroducer?.containsToken(where: { TokenSpec(.try) ~= $0 }) ?? false @@ -1609,7 +1671,7 @@ extension Parser { if (self.at(.leftBrace) && (initializer == nil || !self.currentToken.isAtStartOfLine || self.withLookahead({ $0.atStartOfGetSetAccessor() }))) - || (inMemberDeclList && self.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) != nil + || (context == .memberDeclList && self.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) != nil && !self.at(.keyword(.`init`))) { accessors = self.parseAccessorBlock() diff --git a/Sources/SwiftParser/Nominals.swift b/Sources/SwiftParser/Nominals.swift index 1ac9d1eeeaf..d7ec2e25133 100644 --- a/Sources/SwiftParser/Nominals.swift +++ b/Sources/SwiftParser/Nominals.swift @@ -29,6 +29,7 @@ protocol NominalTypeDeclarationHeaderTrait: DeclarationGroupHeaderTrait { primaryOrGenerics: PrimaryOrGenerics?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, + trailingUnexpectedNodes: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) @@ -46,6 +47,7 @@ extension RawProtocolDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { primaryOrGenerics: RawPrimaryAssociatedTypeClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, + trailingUnexpectedNodes: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -58,6 +60,7 @@ extension RawProtocolDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { primaryAssociatedTypeClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, + trailingUnexpectedNodes, arena: arena ) } @@ -86,6 +89,7 @@ extension RawClassDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, + trailingUnexpectedNodes: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -98,6 +102,7 @@ extension RawClassDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, + trailingUnexpectedNodes, arena: arena ) } @@ -126,6 +131,7 @@ extension RawActorDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, + trailingUnexpectedNodes: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -138,6 +144,7 @@ extension RawActorDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, + trailingUnexpectedNodes, arena: arena ) } @@ -166,6 +173,7 @@ extension RawStructDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, + trailingUnexpectedNodes: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -178,6 +186,7 @@ extension RawStructDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, + trailingUnexpectedNodes, arena: arena ) } @@ -206,6 +215,7 @@ extension RawEnumDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { primaryOrGenerics: RawGenericParameterClauseSyntax?, inheritanceClause: RawInheritanceClauseSyntax?, genericWhereClause: RawGenericWhereClauseSyntax?, + trailingUnexpectedNodes: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -218,6 +228,7 @@ extension RawEnumDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait { genericParameterClause: primaryOrGenerics, inheritanceClause: inheritanceClause, genericWhereClause: genericWhereClause, + trailingUnexpectedNodes, arena: arena ) } @@ -240,7 +251,8 @@ extension Parser { mutating func parseNominalTypeDeclarationHeader( for T: T.Type, attrs: DeclAttributes, - introducerHandle: RecoveryConsumptionHandle + introducerHandle: RecoveryConsumptionHandle, + allowsMemberBlock: Bool ) -> (T, shouldContinueParsing: Bool) where T: NominalTypeDeclarationHeaderTrait { let (unexpectedBeforeIntroducerKeyword, introducerKeyword) = self.eat(introducerHandle) let (unexpectedBeforeName, name) = self.expectIdentifier(keywordRecovery: true) @@ -256,6 +268,7 @@ extension Parser { primaryOrGenerics: nil, inheritanceClause: nil, genericWhereClause: nil, + trailingUnexpectedNodes: nil, arena: self.arena ), shouldContinueParsing: false @@ -284,6 +297,16 @@ extension Parser { whereClause = nil } + // If we know there shouldn't be a member block, but there is, gobble it up whole right now. + var trailingUnexpectedNodes: RawUnexpectedNodesSyntax? + if !allowsMemberBlock && self.at(.leftBrace) { + let forbiddenMemberBlock = parseMemberBlock(introducer: introducerKeyword) + trailingUnexpectedNodes = RawUnexpectedNodesSyntax( + [forbiddenMemberBlock], + arena: self.arena + ) + } + return ( T.init( attributes: attrs.attributes, @@ -295,6 +318,7 @@ extension Parser { primaryOrGenerics: primaryOrGenerics, inheritanceClause: inheritance, genericWhereClause: whereClause, + trailingUnexpectedNodes: trailingUnexpectedNodes, arena: self.arena ), shouldContinueParsing: true diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift index 1cc318aedfa..9e1a22cc01f 100644 --- a/Sources/SwiftParser/TokenPrecedence.swift +++ b/Sources/SwiftParser/TokenPrecedence.swift @@ -283,6 +283,7 @@ enum TokenPrecedence: Comparable { ._swift_native_objc_runtime_base, ._typeEraser, ._unavailableFromAsync, + .abi, .attached, .available, .backDeployed, diff --git a/Sources/SwiftParser/generated/ExperimentalFeatures.swift b/Sources/SwiftParser/generated/ExperimentalFeatures.swift index 63fe9639d8f..ae693126061 100644 --- a/Sources/SwiftParser/generated/ExperimentalFeatures.swift +++ b/Sources/SwiftParser/generated/ExperimentalFeatures.swift @@ -41,4 +41,7 @@ extension Parser.ExperimentalFeatures { /// Whether to enable the parsing of CoroutineAccessors. public static let coroutineAccessors = Self (rawValue: 1 << 5) + + /// Whether to enable the parsing of @abi attribute. + public static let abiAttribute = Self (rawValue: 1 << 6) } diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index 6ce8dd76032..ce9bd9eebda 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -477,6 +477,22 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { SpaceSeparatedIdentifiersError(firstToken: previousToken, additionalTokens: tokens), fixIts: fixIts ) + } else if node.count == 1, + let onlyChild = node.first!.as(MemberBlockSyntax.self), + let parentHeader = node.parent?.as(DeclGroupHeaderSyntax.self) + { + addDiagnostic( + node, + DeclarationMemberBlockNotAllowedOnHeader(header: parentHeader), + fixIts: [ + FixIt( + message: RemoveNodesFixIt([Syntax(onlyChild)]), + changes: [ + .makeMissing(node, transferTrivia: true) + ] + ) + ] + ) } else { addDiagnostic(node, UnexpectedNodesError(unexpectedNodes: node), highlights: [Syntax(node)]) } diff --git a/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift b/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift index f1a21255bb5..20b976f4fac 100644 --- a/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift +++ b/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift @@ -17,7 +17,7 @@ public import SwiftDiagnostics #else import SwiftDiagnostics @_spi(Diagnostics) import SwiftParser -@_spi(RawSyntax) import SwiftSyntax +@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax #endif fileprivate let diagnosticDomain: String = "SwiftParser" @@ -270,6 +270,25 @@ extension DiagnosticMessage where Self == StaticParserError { // MARK: - Diagnostics (please sort alphabetically) +public struct DeclarationMemberBlockNotAllowedOnHeader: ParserError { + public let header: DeclGroupHeaderSyntax + + private var headerDescription: String { + header.kind.nameForDiagnostics ?? "declaration" + } + + private var contextDescription: String { + if header.parent?.is(ABIAttributeArgumentsSyntax.self) ?? false { + return "in '@abi' attribute" + } + return "here" + } + + public var message: String { + "\(headerDescription) header \(contextDescription) cannot have a member block" + } +} + public struct AsyncMustPrecedeThrows: ParserError { public let asyncKeywords: [TokenSyntax] public let throwsKeyword: TokenSyntax diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index bdc38c52543..1ef0dfe502f 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -23,6 +23,8 @@ extension SyntaxKind { switch self { case .token: return "token" + case .abiAttributeArguments: + return "ABI-providing declaration" case .accessorDecl: return "accessor" case .accessorEffectSpecifiers: diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index 7fd90ae8297..9bf24844c3d 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -17,6 +17,12 @@ @_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: diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift index 2ce15cdf90c..eefd53fe6b0 100644 --- a/Sources/SwiftSyntax/generated/Keyword.swift +++ b/Sources/SwiftSyntax/generated/Keyword.swift @@ -71,6 +71,10 @@ public enum Keyword: UInt8, Hashable, Sendable { case _underlyingVersion case _UnknownLayout case _version + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + case abi case accesses case actor case addressWithNativeOwner @@ -271,6 +275,8 @@ public enum Keyword: UInt8, Hashable, Sendable { } case 3: switch text { + case "abi": + self = .abi case "any": self = .any case "Any": @@ -871,6 +877,7 @@ public enum Keyword: UInt8, Hashable, Sendable { "_underlyingVersion", "_UnknownLayout", "_version", + "abi", "accesses", "actor", "addressWithNativeOwner", diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 65e48997966..03b3d1fb137 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -56,6 +56,20 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + override open func visit(_ node: ABIAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + override open func visitPost(_ node: ABIAttributeArgumentsSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: AccessorBlockSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index 069187a1e51..c2a94ff35ae 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -1890,6 +1890,7 @@ extension Syntax { public static var structure: SyntaxNodeStructure { return .choices([ .node(TokenSyntax.self), + .node(ABIAttributeArgumentsSyntax.self), .node(AccessorBlockSyntax.self), .node(AccessorDeclListSyntax.self), .node(AccessorDeclSyntax.self), diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index c8365b1d95e..ed5f7498e78 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -15,6 +15,10 @@ /// Enum to exhaustively switch over all different syntax nodes. public enum SyntaxEnum: Sendable { case token(TokenSyntax) + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + case abiAttributeArguments(ABIAttributeArgumentsSyntax) case accessorBlock(AccessorBlockSyntax) case accessorDeclList(AccessorDeclListSyntax) case accessorDecl(AccessorDeclSyntax) @@ -328,6 +332,8 @@ extension Syntax { switch raw.kind { case .token: return .token(TokenSyntax(self)!) + case .abiAttributeArguments: + return .abiAttributeArguments(ABIAttributeArgumentsSyntax(self)!) case .accessorBlock: return .accessorBlock(AccessorBlockSyntax(self)!) case .accessorDeclList: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index 65f0272dc18..c054531153c 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -15,6 +15,10 @@ /// Enumerates the known kinds of Syntax represented in the Syntax tree. public enum SyntaxKind: Sendable { case token + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + case abiAttributeArguments case accessorBlock case accessorDeclList case accessorDecl @@ -455,6 +459,8 @@ public enum SyntaxKind: Sendable { switch self { case .token: return TokenSyntax.self + case .abiAttributeArguments: + return ABIAttributeArgumentsSyntax.self case .accessorBlock: return AccessorBlockSyntax.self case .accessorDeclList: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index 6642d356fa1..00a12488406 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -106,6 +106,16 @@ open class SyntaxRewriter { return rewritten.cast(T.self) } + /// Visit a `ABIAttributeArgumentsSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visit(_ node: ABIAttributeArgumentsSyntax) -> ABIAttributeArgumentsSyntax { + return visitChildren(node._syntaxNode).cast(ABIAttributeArgumentsSyntax.self) + } + /// Visit a ``AccessorBlockSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2249,6 +2259,10 @@ open class SyntaxRewriter { return { self.visitImpl(&$0, TokenSyntax.self, self.visit) } + case .abiAttributeArguments: + return { + self.visitImpl(&$0, ABIAttributeArgumentsSyntax.self, self.visit) + } case .accessorBlock: return { self.visitImpl(&$0, AccessorBlockSyntax.self, self.visit) @@ -3419,6 +3433,8 @@ open class SyntaxRewriter { switch node.raw.kind { case .token: return visitImpl(&node, TokenSyntax.self, visit) + case .abiAttributeArguments: + return visitImpl(&node, ABIAttributeArgumentsSyntax.self, visit) case .accessorBlock: return visitImpl(&node, AccessorBlockSyntax.self, visit) case .accessorDeclList: diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index ef487d6b92b..98d4898ab87 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -38,6 +38,24 @@ open class SyntaxVisitor { visit(&syntaxNode) } + /// Visiting `ABIAttributeArgumentsSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visit(_ node: ABIAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `ABIAttributeArgumentsSyntax` and its descendants. + /// - node: the node we just finished visiting. + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visitPost(_ node: ABIAttributeArgumentsSyntax) { + } + /// Visiting ``AccessorBlockSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -3619,6 +3637,10 @@ open class SyntaxVisitor { // No children to visit. self.visitPost(node) } + case .abiAttributeArguments: + return { + self.visitImpl(&$0, ABIAttributeArgumentsSyntax.self, self.visit, self.visitPost) + } case .accessorBlock: return { self.visitImpl(&$0, AccessorBlockSyntax.self, self.visit, self.visitPost) @@ -4793,6 +4815,8 @@ open class SyntaxVisitor { _ = visit(node) // No children to visit. visitPost(node) + case .abiAttributeArguments: + visitImpl(&node, ABIAttributeArgumentsSyntax.self, visit, visitPost) case .accessorBlock: visitImpl(&node, AccessorBlockSyntax.self, visit, visitPost) case .accessorDeclList: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift index c92f20165c6..cf1c03e5dce 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift @@ -12,6 +12,143 @@ // //===----------------------------------------------------------------------===// +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +@_spi(RawSyntax) +public struct RawABIAttributeArgumentsSyntax: RawSyntaxNodeProtocol { + public enum Provider: RawSyntaxNodeProtocol { + case associatedType(RawAssociatedTypeDeclSyntax) + case declGroup(RawDeclGroupHeaderSyntax) + case deinitializer(RawDeinitializerDeclSyntax) + case enumCase(RawEnumCaseDeclSyntax) + case function(RawFunctionDeclSyntax) + case initializer(RawInitializerDeclSyntax) + case `subscript`(RawSubscriptDeclSyntax) + case typeAlias(RawTypeAliasDeclSyntax) + case variable(RawVariableDeclSyntax) + case unsupported(RawDeclSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + RawAssociatedTypeDeclSyntax.isKindOf(raw) || RawDeclGroupHeaderSyntax.isKindOf(raw) || RawDeinitializerDeclSyntax.isKindOf(raw) || RawEnumCaseDeclSyntax.isKindOf(raw) || RawFunctionDeclSyntax.isKindOf(raw) || RawInitializerDeclSyntax.isKindOf(raw) || RawSubscriptDeclSyntax.isKindOf(raw) || RawTypeAliasDeclSyntax.isKindOf(raw) || RawVariableDeclSyntax.isKindOf(raw) || RawDeclSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .associatedType(let node): + return node.raw + case .declGroup(let node): + return node.raw + case .deinitializer(let node): + return node.raw + case .enumCase(let node): + return node.raw + case .function(let node): + return node.raw + case .initializer(let node): + return node.raw + case .subscript(let node): + return node.raw + case .typeAlias(let node): + return node.raw + case .variable(let node): + return node.raw + case .unsupported(let node): + return node.raw + } + } + + public init?(_ node: __shared some RawSyntaxNodeProtocol) { + if let node = node.as(RawAssociatedTypeDeclSyntax.self) { + self = .associatedType(node) + } else if let node = node.as(RawDeclGroupHeaderSyntax.self) { + self = .declGroup(node) + } else if let node = node.as(RawDeinitializerDeclSyntax.self) { + self = .deinitializer(node) + } else if let node = node.as(RawEnumCaseDeclSyntax.self) { + self = .enumCase(node) + } else if let node = node.as(RawFunctionDeclSyntax.self) { + self = .function(node) + } else if let node = node.as(RawInitializerDeclSyntax.self) { + self = .initializer(node) + } else if let node = node.as(RawSubscriptDeclSyntax.self) { + self = .subscript(node) + } else if let node = node.as(RawTypeAliasDeclSyntax.self) { + self = .typeAlias(node) + } else if let node = node.as(RawVariableDeclSyntax.self) { + self = .variable(node) + } else if let node = node.as(RawDeclSyntax.self) { + self = .unsupported(node) + } else { + return nil + } + } + + public init(declGroup: some RawDeclGroupHeaderSyntaxNodeProtocol) { + self = .declGroup(RawDeclGroupHeaderSyntax(declGroup)) + } + + public init(unsupported: some RawDeclSyntaxNodeProtocol) { + self = .unsupported(RawDeclSyntax(unsupported)) + } + } + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .abiAttributeArguments + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeProvider: RawUnexpectedNodesSyntax? = nil, + provider: Provider, + _ unexpectedAfterProvider: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .abiAttributeArguments, uninitializedCount: 3, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeProvider?.raw + layout[1] = provider.raw + layout[2] = unexpectedAfterProvider?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeProvider: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var provider: RawSyntax { + layoutView.children[1]! + } + + public var unexpectedAfterProvider: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawAccessorBlockSyntax: RawSyntaxNodeProtocol { public enum Accessors: RawSyntaxNodeProtocol { @@ -1380,9 +1517,12 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol { case unavailableFromAsyncArguments(RawUnavailableFromAsyncAttributeArgumentsSyntax) case effectsArguments(RawEffectsAttributeArgumentListSyntax) case documentationArguments(RawDocumentationAttributeArgumentListSyntax) + /// - Note: Requires experimental feature `abiAttribute`. + @_spi(ExperimentalLanguageFeatures) + case abiArguments(RawABIAttributeArgumentsSyntax) public static func isKindOf(_ raw: RawSyntax) -> Bool { - RawLabeledExprListSyntax.isKindOf(raw) || RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilityArgumentListSyntax.isKindOf(raw) || RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) || RawObjCSelectorPieceListSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) || RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) || RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) || RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) || RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) || RawEffectsAttributeArgumentListSyntax.isKindOf(raw) || RawDocumentationAttributeArgumentListSyntax.isKindOf(raw) + RawLabeledExprListSyntax.isKindOf(raw) || RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilityArgumentListSyntax.isKindOf(raw) || RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) || RawObjCSelectorPieceListSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) || RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) || RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) || RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) || RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) || RawEffectsAttributeArgumentListSyntax.isKindOf(raw) || RawDocumentationAttributeArgumentListSyntax.isKindOf(raw) || RawABIAttributeArgumentsSyntax.isKindOf(raw) } public var raw: RawSyntax { @@ -1427,6 +1567,8 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol { return node.raw case .documentationArguments(let node): return node.raw + case .abiArguments(let node): + return node.raw } } @@ -1471,6 +1613,8 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol { self = .effectsArguments(node) } else if let node = node.as(RawDocumentationAttributeArgumentListSyntax.self) { self = .documentationArguments(node) + } else if let node = node.as(RawABIAttributeArgumentsSyntax.self) { + self = .abiArguments(node) } else { return nil } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 075e1953d2d..6970aeb1c53 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -209,6 +209,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { switch kind { case .token: assertionFailure("validateLayout for .token kind is not supported") + case .abiAttributeArguments: + assert(layout.count == 3) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertAnyHasNoError(kind, 1, [ + verify(layout[1], as: RawSyntax.self)]) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) case .accessorBlock: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift index d326035f854..67484165711 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -12,6 +12,426 @@ // //===----------------------------------------------------------------------===// +// MARK: - ABIAttributeArgumentsSyntax + +/// The arguments of the '@abi' attribute +/// +/// - Note: Requires experimental feature `abiAttribute`. +/// +/// ### Children +/// +/// - `provider`: (``AssociatedTypeDeclSyntax`` | ``DeclGroupHeaderSyntax`` | ``DeinitializerDeclSyntax`` | ``EnumCaseDeclSyntax`` | ``FunctionDeclSyntax`` | ``InitializerDeclSyntax`` | ``SubscriptDeclSyntax`` | ``TypeAliasDeclSyntax`` | ``VariableDeclSyntax`` | ``DeclSyntax``) +/// +/// ### Contained in +/// +/// - ``AttributeSyntax``.``AttributeSyntax/arguments`` +#if compiler(>=5.8) +@_spi(ExperimentalLanguageFeatures) +#endif +public struct ABIAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { + public enum Provider: SyntaxChildChoices, SyntaxHashable { + case associatedType(AssociatedTypeDeclSyntax) + case declGroup(DeclGroupHeaderSyntax) + case deinitializer(DeinitializerDeclSyntax) + case enumCase(EnumCaseDeclSyntax) + case function(FunctionDeclSyntax) + case initializer(InitializerDeclSyntax) + case `subscript`(SubscriptDeclSyntax) + case typeAlias(TypeAliasDeclSyntax) + case variable(VariableDeclSyntax) + case unsupported(DeclSyntax) + + public var _syntaxNode: Syntax { + switch self { + case .associatedType(let node): + return node._syntaxNode + case .declGroup(let node): + return node._syntaxNode + case .deinitializer(let node): + return node._syntaxNode + case .enumCase(let node): + return node._syntaxNode + case .function(let node): + return node._syntaxNode + case .initializer(let node): + return node._syntaxNode + case .subscript(let node): + return node._syntaxNode + case .typeAlias(let node): + return node._syntaxNode + case .variable(let node): + return node._syntaxNode + case .unsupported(let node): + return node._syntaxNode + } + } + + public init(_ node: AssociatedTypeDeclSyntax) { + self = .associatedType(node) + } + + public init(_ node: some DeclGroupHeaderSyntaxProtocol) { + self = .declGroup(DeclGroupHeaderSyntax(node)) + } + + public init(_ node: DeinitializerDeclSyntax) { + self = .deinitializer(node) + } + + public init(_ node: EnumCaseDeclSyntax) { + self = .enumCase(node) + } + + public init(_ node: FunctionDeclSyntax) { + self = .function(node) + } + + public init(_ node: InitializerDeclSyntax) { + self = .initializer(node) + } + + public init(_ node: SubscriptDeclSyntax) { + self = .subscript(node) + } + + public init(_ node: TypeAliasDeclSyntax) { + self = .typeAlias(node) + } + + public init(_ node: VariableDeclSyntax) { + self = .variable(node) + } + + public init(_ node: some DeclSyntaxProtocol) { + self = .unsupported(DeclSyntax(node)) + } + + public init?(_ node: __shared some SyntaxProtocol) { + if let node = node.as(AssociatedTypeDeclSyntax.self) { + self = .associatedType(node) + } else if let node = node.as(DeclGroupHeaderSyntax.self) { + self = .declGroup(node) + } else if let node = node.as(DeinitializerDeclSyntax.self) { + self = .deinitializer(node) + } else if let node = node.as(EnumCaseDeclSyntax.self) { + self = .enumCase(node) + } else if let node = node.as(FunctionDeclSyntax.self) { + self = .function(node) + } else if let node = node.as(InitializerDeclSyntax.self) { + self = .initializer(node) + } else if let node = node.as(SubscriptDeclSyntax.self) { + self = .subscript(node) + } else if let node = node.as(TypeAliasDeclSyntax.self) { + self = .typeAlias(node) + } else if let node = node.as(VariableDeclSyntax.self) { + self = .variable(node) + } else if let node = node.as(DeclSyntax.self) { + self = .unsupported(node) + } else { + return nil + } + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(AssociatedTypeDeclSyntax.self), + .node(DeclGroupHeaderSyntax.self), + .node(DeinitializerDeclSyntax.self), + .node(EnumCaseDeclSyntax.self), + .node(FunctionDeclSyntax.self), + .node(InitializerDeclSyntax.self), + .node(SubscriptDeclSyntax.self), + .node(TypeAliasDeclSyntax.self), + .node(VariableDeclSyntax.self), + .node(DeclSyntax.self) + ]) + } + + /// Checks if the current syntax node can be cast to ``AssociatedTypeDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: AssociatedTypeDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``AssociatedTypeDeclSyntax``. + /// + /// - Returns: An instance of ``AssociatedTypeDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: AssociatedTypeDeclSyntax.Type) -> AssociatedTypeDeclSyntax? { + return AssociatedTypeDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``AssociatedTypeDeclSyntax``. + /// + /// - Returns: An instance of ``AssociatedTypeDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: AssociatedTypeDeclSyntax.Type) -> AssociatedTypeDeclSyntax { + return self.as(AssociatedTypeDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to the type conforming to the ``DeclGroupHeaderSyntaxProtocol`` protocol. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: (some DeclGroupHeaderSyntaxProtocol).Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to the type conforming to the ``DeclGroupHeaderSyntaxProtocol`` protocol. + /// + /// - Returns: An instance of the specialized type, or `nil` if the cast fails. + public func `as`(_ syntaxType: S.Type) -> S? { + return S.init(self) + } + + /// Force-casts the current syntax node to the type conforming to the ``DeclGroupHeaderSyntaxProtocol`` protocol. + /// + /// - Returns: An instance of the specialized type. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: S.Type) -> S { + return self.as(S.self)! + } + + /// Checks if the current syntax node can be cast to ``DeinitializerDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: DeinitializerDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``DeinitializerDeclSyntax``. + /// + /// - Returns: An instance of ``DeinitializerDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: DeinitializerDeclSyntax.Type) -> DeinitializerDeclSyntax? { + return DeinitializerDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``DeinitializerDeclSyntax``. + /// + /// - Returns: An instance of ``DeinitializerDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: DeinitializerDeclSyntax.Type) -> DeinitializerDeclSyntax { + return self.as(DeinitializerDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to ``EnumCaseDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: EnumCaseDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``EnumCaseDeclSyntax``. + /// + /// - Returns: An instance of ``EnumCaseDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: EnumCaseDeclSyntax.Type) -> EnumCaseDeclSyntax? { + return EnumCaseDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``EnumCaseDeclSyntax``. + /// + /// - Returns: An instance of ``EnumCaseDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: EnumCaseDeclSyntax.Type) -> EnumCaseDeclSyntax { + return self.as(EnumCaseDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to ``FunctionDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: FunctionDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``FunctionDeclSyntax``. + /// + /// - Returns: An instance of ``FunctionDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: FunctionDeclSyntax.Type) -> FunctionDeclSyntax? { + return FunctionDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``FunctionDeclSyntax``. + /// + /// - Returns: An instance of ``FunctionDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: FunctionDeclSyntax.Type) -> FunctionDeclSyntax { + return self.as(FunctionDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to ``InitializerDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: InitializerDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``InitializerDeclSyntax``. + /// + /// - Returns: An instance of ``InitializerDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: InitializerDeclSyntax.Type) -> InitializerDeclSyntax? { + return InitializerDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``InitializerDeclSyntax``. + /// + /// - Returns: An instance of ``InitializerDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: InitializerDeclSyntax.Type) -> InitializerDeclSyntax { + return self.as(InitializerDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to ``SubscriptDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: SubscriptDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``SubscriptDeclSyntax``. + /// + /// - Returns: An instance of ``SubscriptDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: SubscriptDeclSyntax.Type) -> SubscriptDeclSyntax? { + return SubscriptDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``SubscriptDeclSyntax``. + /// + /// - Returns: An instance of ``SubscriptDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: SubscriptDeclSyntax.Type) -> SubscriptDeclSyntax { + return self.as(SubscriptDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to ``TypeAliasDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: TypeAliasDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``TypeAliasDeclSyntax``. + /// + /// - Returns: An instance of ``TypeAliasDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: TypeAliasDeclSyntax.Type) -> TypeAliasDeclSyntax? { + return TypeAliasDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``TypeAliasDeclSyntax``. + /// + /// - Returns: An instance of ``TypeAliasDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: TypeAliasDeclSyntax.Type) -> TypeAliasDeclSyntax { + return self.as(TypeAliasDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to ``VariableDeclSyntax``. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: VariableDeclSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to ``VariableDeclSyntax``. + /// + /// - Returns: An instance of ``VariableDeclSyntax``, or `nil` if the cast fails. + public func `as`(_ syntaxType: VariableDeclSyntax.Type) -> VariableDeclSyntax? { + return VariableDeclSyntax.init(self) + } + + /// Force-casts the current syntax node to ``VariableDeclSyntax``. + /// + /// - Returns: An instance of ``VariableDeclSyntax``. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: VariableDeclSyntax.Type) -> VariableDeclSyntax { + return self.as(VariableDeclSyntax.self)! + } + + /// Checks if the current syntax node can be cast to the type conforming to the ``DeclSyntaxProtocol`` protocol. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + public func `is`(_ syntaxType: (some DeclSyntaxProtocol).Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to the type conforming to the ``DeclSyntaxProtocol`` protocol. + /// + /// - Returns: An instance of the specialized type, or `nil` if the cast fails. + public func `as`(_ syntaxType: S.Type) -> S? { + return S.init(self) + } + + /// Force-casts the current syntax node to the type conforming to the ``DeclSyntaxProtocol`` protocol. + /// + /// - Returns: An instance of the specialized type. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + public func cast(_ syntaxType: S.Type) -> S { + return self.as(S.self)! + } + } + + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .abiAttributeArguments else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeProvider: UnexpectedNodesSyntax? = nil, + provider: Provider, + _ unexpectedAfterProvider: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeProvider, provider, unexpectedAfterProvider))) { (arena, _) in + let layout: [RawSyntax?] = [unexpectedBeforeProvider?.raw, provider.raw, unexpectedAfterProvider?.raw] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.abiAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeProvider: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ABIAttributeArgumentsSyntax.self) + } + } + + public var provider: Provider { + get { + return Syntax(self).child(at: 1)!.cast(Provider.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ABIAttributeArgumentsSyntax.self) + } + } + + public var unexpectedAfterProvider: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ABIAttributeArgumentsSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeProvider, \Self.provider, \Self.unexpectedAfterProvider]) +} + // MARK: - AccessorBlockSyntax /// ### Children @@ -2379,7 +2799,7 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea /// - `atSign`: `@` /// - `attributeName`: ``TypeSyntax`` /// - `leftParen`: `(`? -/// - `arguments`: (``LabeledExprListSyntax`` | ``TokenSyntax`` | ``StringLiteralExprSyntax`` | ``AvailabilityArgumentListSyntax`` | ``SpecializeAttributeArgumentListSyntax`` | ``ObjCSelectorPieceListSyntax`` | ``ImplementsAttributeArgumentsSyntax`` | ``DifferentiableAttributeArgumentsSyntax`` | ``DerivativeAttributeArgumentsSyntax`` | ``BackDeployedAttributeArgumentsSyntax`` | ``ConventionAttributeArgumentsSyntax`` | ``ConventionWitnessMethodAttributeArgumentsSyntax`` | ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` | ``ExposeAttributeArgumentsSyntax`` | ``OriginallyDefinedInAttributeArgumentsSyntax`` | ``UnderscorePrivateAttributeArgumentsSyntax`` | ``DynamicReplacementAttributeArgumentsSyntax`` | ``UnavailableFromAsyncAttributeArgumentsSyntax`` | ``EffectsAttributeArgumentListSyntax`` | ``DocumentationAttributeArgumentListSyntax``)? +/// - `arguments`: (``LabeledExprListSyntax`` | ``TokenSyntax`` | ``StringLiteralExprSyntax`` | ``AvailabilityArgumentListSyntax`` | ``SpecializeAttributeArgumentListSyntax`` | ``ObjCSelectorPieceListSyntax`` | ``ImplementsAttributeArgumentsSyntax`` | ``DifferentiableAttributeArgumentsSyntax`` | ``DerivativeAttributeArgumentsSyntax`` | ``BackDeployedAttributeArgumentsSyntax`` | ``ConventionAttributeArgumentsSyntax`` | ``ConventionWitnessMethodAttributeArgumentsSyntax`` | ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` | ``ExposeAttributeArgumentsSyntax`` | ``OriginallyDefinedInAttributeArgumentsSyntax`` | ``UnderscorePrivateAttributeArgumentsSyntax`` | ``DynamicReplacementAttributeArgumentsSyntax`` | ``UnavailableFromAsyncAttributeArgumentsSyntax`` | ``EffectsAttributeArgumentListSyntax`` | ``DocumentationAttributeArgumentListSyntax`` | `ABIAttributeArgumentsSyntax`)? /// - `rightParen`: `)`? /// /// ### Contained in @@ -2408,6 +2828,9 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr case unavailableFromAsyncArguments(UnavailableFromAsyncAttributeArgumentsSyntax) case effectsArguments(EffectsAttributeArgumentListSyntax) case documentationArguments(DocumentationAttributeArgumentListSyntax) + /// - Note: Requires experimental feature `abiAttribute`. + @_spi(ExperimentalLanguageFeatures) + case abiArguments(ABIAttributeArgumentsSyntax) public var _syntaxNode: Syntax { switch self { @@ -2451,6 +2874,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr return node._syntaxNode case .documentationArguments(let node): return node._syntaxNode + case .abiArguments(let node): + return node._syntaxNode } } @@ -2534,6 +2959,12 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr self = .documentationArguments(node) } + /// - Note: Requires experimental feature `abiAttribute`. + @_spi(ExperimentalLanguageFeatures) + public init(_ node: ABIAttributeArgumentsSyntax) { + self = .abiArguments(node) + } + public init?(_ node: __shared some SyntaxProtocol) { if let node = node.as(LabeledExprListSyntax.self) { self = .argumentList(node) @@ -2575,6 +3006,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr self = .effectsArguments(node) } else if let node = node.as(DocumentationAttributeArgumentListSyntax.self) { self = .documentationArguments(node) + } else if let node = node.as(ABIAttributeArgumentsSyntax.self) { + self = .abiArguments(node) } else { return nil } @@ -2601,7 +3034,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr .node(DynamicReplacementAttributeArgumentsSyntax.self), .node(UnavailableFromAsyncAttributeArgumentsSyntax.self), .node(EffectsAttributeArgumentListSyntax.self), - .node(DocumentationAttributeArgumentListSyntax.self) + .node(DocumentationAttributeArgumentListSyntax.self), + .node(ABIAttributeArgumentsSyntax.self) ]) } @@ -3044,6 +3478,34 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr public func cast(_ syntaxType: DocumentationAttributeArgumentListSyntax.Type) -> DocumentationAttributeArgumentListSyntax { return self.as(DocumentationAttributeArgumentListSyntax.self)! } + + /// Checks if the current syntax node can be cast to `ABIAttributeArgumentsSyntax`. + /// + /// - Returns: `true` if the node can be cast, `false` otherwise. + /// - Note: Requires experimental feature `abiAttribute`. + @_spi(ExperimentalLanguageFeatures) + public func `is`(_ syntaxType: ABIAttributeArgumentsSyntax.Type) -> Bool { + return self.as(syntaxType) != nil + } + + /// Attempts to cast the current syntax node to `ABIAttributeArgumentsSyntax`. + /// + /// - Returns: An instance of `ABIAttributeArgumentsSyntax`, or `nil` if the cast fails. + /// - Note: Requires experimental feature `abiAttribute`. + @_spi(ExperimentalLanguageFeatures) + public func `as`(_ syntaxType: ABIAttributeArgumentsSyntax.Type) -> ABIAttributeArgumentsSyntax? { + return ABIAttributeArgumentsSyntax.init(self) + } + + /// Force-casts the current syntax node to `ABIAttributeArgumentsSyntax`. + /// + /// - Returns: An instance of `ABIAttributeArgumentsSyntax`. + /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast. + /// - Note: Requires experimental feature `abiAttribute`. + @_spi(ExperimentalLanguageFeatures) + public func cast(_ syntaxType: ABIAttributeArgumentsSyntax.Type) -> ABIAttributeArgumentsSyntax { + return self.as(ABIAttributeArgumentsSyntax.self)! + } } public let _syntaxNode: Syntax diff --git a/Tests/SwiftParserTest/AttributeTests.swift b/Tests/SwiftParserTest/AttributeTests.swift index 882839b06ce..8631d1ae25e 100644 --- a/Tests/SwiftParserTest/AttributeTests.swift +++ b/Tests/SwiftParserTest/AttributeTests.swift @@ -10,8 +10,8 @@ // //===----------------------------------------------------------------------===// -@_spi(RawSyntax) import SwiftParser -@_spi(RawSyntax) import SwiftSyntax +@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftParser +@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax import XCTest final class AttributeTests: ParserTestCase { @@ -965,6 +965,272 @@ final class AttributeTests: ParserTestCase { ) } + func testABIAttribute() { + func abiAttr(_ provider: ABIAttributeArgumentsSyntax.Provider) -> AttributeListSyntax.Element { + return .attribute( + AttributeSyntax( + attributeName: TypeSyntax("abi"), + leftParen: .leftParenToken(), + arguments: .abiArguments( + ABIAttributeArgumentsSyntax( + provider: provider + ) + ), + rightParen: .rightParenToken() + ) + ) + } + + assertParse( + """ + @abi(func fn() -> Int) + func fn1() -> Int { } + """, + substructure: FunctionDeclSyntax( + attributes: [ + abiAttr( + .function( + FunctionDeclSyntax( + name: "fn", + signature: FunctionSignatureSyntax( + parameterClause: FunctionParameterClauseSyntax {}, + returnClause: ReturnClauseSyntax(type: TypeSyntax("Int")) + ), + body: nil + ) + ) + ) + ], + name: "fn1", + signature: FunctionSignatureSyntax( + parameterClause: FunctionParameterClauseSyntax {}, + returnClause: ReturnClauseSyntax(type: TypeSyntax("Int")) + ) + ) {}, + experimentalFeatures: [.abiAttribute] + ) + + assertParse( + """ + @abi(associatedtype AssocTy) + associatedtype AssocTy + + @abi(actor Actor) + actor Actor {} + + @abi(class Class) + class Class {} + + @abi(enum Enum) + enum Enum {} + + @abi(extension Extension) + extension Extension {} + + @abi(protocol Protocol) + protocol Protocol {} + + @abi(struct Struct) + struct Struct {} + + @abi(deinit) + deinit {} + + enum EnumCaseDeclNotParsedAtTopLevel { + @abi(case someCase) + case someCase + } + + @abi(func fn()) + func fn() + + @abi(init()) + init() {} + + @abi(subscript(i: Int) -> Element) + subscript(i: Int) -> Element {} + + @abi(typealias Typealias = @escaping () -> Void) + typealias Typealias = () -> Void + + @abi(let c1, c2) + let c1, c2 + + @abi(var v1, v2) + var v1, v2 + """, + experimentalFeatures: [.abiAttribute] + ) + + assertParse( + """ + @abi(1️⃣<#fnord#>) + func placeholder() {} + """, + substructure: abiAttr( + .unsupported( + DeclSyntax( + MissingDeclSyntax(placeholder: .identifier("<#fnord#>")) + ) + ) + ), + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "editor placeholder in source file") + ], + experimentalFeatures: [.abiAttribute] + ) + + assertParse( + """ + @abi(1️⃣import Fnord) + func invalidDecl() {} + """, + substructure: abiAttr( + .unsupported( + DeclSyntax( + ImportDeclSyntax( + path: [ImportPathComponentSyntax(name: "Fnord")] + ) + ) + ) + ), + experimentalFeatures: [.abiAttribute] + ) + + assertParse( + """ + @abi(class Sub: Super, Proto where Assoc: OtherProto) + class Sub: Super, Proto where Assoc: OtherProto {} + """, + experimentalFeatures: [.abiAttribute] + ) + + // Invalid, but diagnosed in ASTGen + assertParse( + """ + @abi(associatedtype AssocTy = T) + associatedtype AssocTy + + @abi(deinit {}) + deinit {} + + enum EnumCaseDeclNotParsedAtTopLevel { + @abi(case someCase = 42) + case someCase + } + + @abi(func fn() {}) + func fn() + + @abi(init() {}) + init() {} + + @abi(subscript(i: Int) -> Element { get {} set {} }) + subscript(i: Int) -> Element {} + + @abi(let c1 = 1, c2 = 2) + let c1, c2 + + @abi(var v1 = 1, v2 = 2) + var v1, v2 + + @abi(var v3 { get {} set {} }) + var v3 + """, + experimentalFeatures: [.abiAttribute] + ) + + // Caught here + assertParse( + """ + @abi(class Sub: Super, Proto where Assoc: OtherProto 1️⃣{}) + class Sub: Super, Proto where Assoc: OtherProto {} + + @abi(var 2️⃣) + var v1 + + @abi4️⃣(var v23️⃣ + var v2 + + @abi(5️⃣) + func fn2() {} + + @abi6️⃣ + func fn3() {} + + // Suboptimal: + @abi7️⃣ func fn4_abi()8️⃣) + func fn4() {} + """, + diagnostics: [ + DiagnosticSpec( + locationMarker: "1️⃣", + message: "class header in '@abi' attribute cannot have a member block", + fixIts: ["remove member block"] + ), + DiagnosticSpec( + locationMarker: "2️⃣", + message: "expected pattern in variable", + fixIts: ["insert pattern"] + ), + DiagnosticSpec( + locationMarker: "3️⃣", + message: "expected ')' to end attribute", + notes: [ + NoteSpec( + locationMarker: "4️⃣", + message: "to match this opening '('" + ) + ], + fixIts: ["insert ')'"] + ), + // FIXME: Custom fix-it with copy of decl it's attached to + DiagnosticSpec( + locationMarker: "5️⃣", + message: "expected argument for '@abi' attribute", + fixIts: ["insert attribute argument"] + ), + DiagnosticSpec( + locationMarker: "6️⃣", + message: "expected '(', ABI-providing declaration, and ')' in attribute", + fixIts: ["insert '(', ABI-providing declaration, and ')'"] + ), + // FIXME: Suboptimal diagnosis + DiagnosticSpec( + locationMarker: "7️⃣", + message: "expected '(', ABI-providing declaration, and ')' in attribute", + fixIts: ["insert '(', ABI-providing declaration, and ')'"] + ), + DiagnosticSpec( + locationMarker: "8️⃣", + message: "unexpected code ')' before function" + ), + ], + // FIXME: Would love to have the fix-it delete the space before the close paren on the first line + fixedSource: """ + @abi(class Sub: Super, Proto where Assoc: OtherProto ) + class Sub: Super, Proto where Assoc: OtherProto {} + + @abi(var <#pattern#>) + var v1 + + @abi(var v2) + var v2 + + @abi(<#declaration#>) + func fn2() {} + + @abi(<#declaration#>) + func fn3() {} + + // Suboptimal: + @abi(<#declaration#>) func fn4_abi()) + func fn4() {} + """, + experimentalFeatures: [.abiAttribute] + ) + } + func testSpaceBetweenAtAndAttribute() { assertParse( "@1️⃣ custom func foo() {}",