diff --git a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift index 23a04c28f90..24983b7a64e 100644 --- a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift @@ -65,6 +65,74 @@ public let DECL_NODES: [Node] = [ ] ), + Node( + kind: .accessesEffect, + base: .syntax, + nameForDiagnostics: "accesses effect", + children: [ + Child( + name: "AccessesKeyword", + kind: .token(choices: [.keyword(text: "accesses")]) + ), + Child( + name: "LeftParen", + kind: .token(choices: [.token(tokenKind: "LeftParenToken")]) + ), + Child( + name: "PropertyList", + kind: .collection(kind: .tupleExprElementList, collectionElementName: "Property"), + nameForDiagnostics: "properties" + ), + Child( + name: "RightParen", + kind: .token(choices: [.token(tokenKind: "RightParenToken")]) + ), + ] + ), + + Node( + kind: .initializesEffect, + base: .syntax, + nameForDiagnostics: "initializes effect", + children: [ + Child( + name: "InitializesKeyword", + kind: .token(choices: [.keyword(text: "initializes")]) + ), + Child( + name: "LeftParen", + kind: .token(choices: [.token(tokenKind: "LeftParenToken")]) + ), + Child( + name: "PropertyList", + kind: .collection(kind: .tupleExprElementList, collectionElementName: "Property"), + nameForDiagnostics: "properties" + ), + Child( + name: "RightParen", + kind: .token(choices: [.token(tokenKind: "RightParenToken")]) + ), + ] + ), + + Node( + kind: .accessorInitEffects, + base: .syntax, + nameForDiagnostics: "init accessor effects", + children: [ + Child( + name: "InitializesEffect", + kind: .node(kind: .initializesEffect), + isOptional: true + ), + Child( + name: "AccessesEffect", + kind: .node(kind: .accessesEffect), + isOptional: true + ), + ] + ), + Node( kind: .accessorDecl, base: .decl, @@ -99,6 +167,7 @@ public let DECL_NODES: [Node] = [ .keyword(text: "mutableAddressWithNativeOwner"), .keyword(text: "_read"), .keyword(text: "_modify"), + .keyword(text: "init"), ]) ), Child( @@ -112,6 +181,11 @@ public let DECL_NODES: [Node] = [ kind: .node(kind: .accessorEffectSpecifiers), isOptional: true ), + Child( + name: "InitEffects", + kind: .node(kind: .accessorInitEffects), + isOptional: true + ), Child( name: "Body", kind: .node(kind: .codeBlock), diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift index 7263fdc8e03..858311e296c 100644 --- a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift +++ b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift @@ -85,6 +85,7 @@ public let KEYWORDS: [KeywordSpec] = [ KeywordSpec("_underlyingVersion"), KeywordSpec("_UnknownLayout"), KeywordSpec("_version"), + KeywordSpec("accesses"), KeywordSpec("actor"), KeywordSpec("addressWithNativeOwner"), KeywordSpec("addressWithOwner"), @@ -152,6 +153,7 @@ public let KEYWORDS: [KeywordSpec] = [ KeywordSpec("indirect"), KeywordSpec("infix"), KeywordSpec("init", isLexerClassified: true), + KeywordSpec("initializes"), KeywordSpec("inline"), KeywordSpec("inout", isLexerClassified: true, requiresTrailingSpace: true), KeywordSpec("internal", isLexerClassified: true, requiresTrailingSpace: true), diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index 81ac3299b70..8f851a05ce2 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -20,9 +20,11 @@ import SwiftSyntaxBuilder public enum SyntaxNodeKind: String, CaseIterable { // Please keep this list sorted alphabetically + case accessesEffect case accessorBlock case accessorDecl case accessorEffectSpecifiers + case accessorInitEffects case accessorList case accessorParameter case actorDecl @@ -168,6 +170,7 @@ public enum SyntaxNodeKind: String, CaseIterable { case inheritedType case initializerClause case initializerDecl + case initializesEffect case integerLiteralExpr case isExpr case isTypePattern diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index fcfba32398b..9c929231480 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -1410,7 +1410,7 @@ extension Parser { } let accessor: RawPatternBindingSyntax.Accessor? - if self.at(.leftBrace) || (inMemberDeclList && self.at(anyIn: AccessorKind.self) != nil) { + if self.at(.leftBrace) || (inMemberDeclList && self.at(anyIn: AccessorKind.self) != nil && !self.at(.keyword(.`init`))) { switch self.parseGetSet() { case .accessors(let accessors): accessor = .accessors(accessors) @@ -1522,7 +1522,7 @@ extension Parser { // // set-name ::= '(' identifier ')' let parameter: RawAccessorParameterSyntax? - if [AccessorKind.set, .willSet, .didSet].contains(introducer.kind), let lparen = self.consume(if: .leftParen) { + if [AccessorKind.set, .willSet, .didSet, .`init`].contains(introducer.kind), let lparen = self.consume(if: .leftParen) { let (unexpectedBeforeName, name) = self.expectIdentifier() let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen) parameter = RawAccessorParameterSyntax( @@ -1538,6 +1538,7 @@ extension Parser { } let effectSpecifiers = self.parseAccessorEffectSpecifiers() + let initEffects = self.parseInitAccessorEffects() let body = self.parseOptionalCodeBlock() return RawAccessorDeclSyntax( @@ -1547,6 +1548,7 @@ extension Parser { accessorKind: introducer.token, parameter: parameter, effectSpecifiers: effectSpecifiers, + initEffects: initEffects, body: body, arena: self.arena ) diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index ede761ba708..ed7bb37f7a9 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -572,3 +572,74 @@ extension Parser { return RawUnexpectedNodesSyntax(unexpected, arena: self.arena) } } + +// MARK: - Parsing `initializes` and `accesses` specifiers in init accessors + +extension Parser { + mutating func parseInitAccessorEffects() -> RawAccessorInitEffectsSyntax? { + let initializes = self.parseInitializesSpecifier() + let accesses = self.parseAccessesSpecifier() + + if initializes == nil, accesses == nil { + return nil + } + + return RawAccessorInitEffectsSyntax( + initializesEffect: initializes, + accessesEffect: accesses, + arena: self.arena + ) + } + + mutating func parseInitializesSpecifier() -> RawInitializesEffectSyntax? { + guard let keyword = self.consume(if: .keyword(.initializes)) else { + return nil + } + + let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen) + + let args = parseArgumentListElements(pattern: .none) + let argumentList = RawTupleExprElementListSyntax( + elements: args, + arena: self.arena + ) + + let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) + + return RawInitializesEffectSyntax( + initializesKeyword: keyword, + unexpectedBeforeLeftParen, + leftParen: leftParen, + propertyList: argumentList, + unexpectedBeforeRightParen, + rightParen: rightParen, + arena: self.arena + ) + } + + mutating func parseAccessesSpecifier() -> RawAccessesEffectSyntax? { + guard let keyword = self.consume(if: .keyword(.accesses)) else { + return nil + } + + let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen) + + let args = parseArgumentListElements(pattern: .none) + let argumentList = RawTupleExprElementListSyntax( + elements: args, + arena: self.arena + ) + + let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) + + return RawAccessesEffectSyntax( + accessesKeyword: keyword, + unexpectedBeforeLeftParen, + leftParen: leftParen, + propertyList: argumentList, + unexpectedBeforeRightParen, + rightParen: rightParen, + arena: self.arena + ) + } +} diff --git a/Sources/SwiftParser/TokenSpecSet.swift b/Sources/SwiftParser/TokenSpecSet.swift index 04e9b4fd610..26e6ef18792 100644 --- a/Sources/SwiftParser/TokenSpecSet.swift +++ b/Sources/SwiftParser/TokenSpecSet.swift @@ -28,6 +28,7 @@ enum AccessorKind: TokenSpecSet { case `set` case `didSet` case `willSet` + case `init` case unsafeAddress case addressWithOwner case addressWithNativeOwner @@ -43,6 +44,7 @@ enum AccessorKind: TokenSpecSet { case TokenSpec(.set): self = .set case TokenSpec(.didSet): self = .didSet case TokenSpec(.willSet): self = .willSet + case TokenSpec(.`init`): self = .`init` case TokenSpec(.unsafeAddress): self = .unsafeAddress case TokenSpec(.addressWithOwner): self = .addressWithOwner case TokenSpec(.addressWithNativeOwner): self = .addressWithNativeOwner @@ -61,6 +63,7 @@ enum AccessorKind: TokenSpecSet { case .set: return .keyword(.set) case .didSet: return .keyword(.didSet) case .willSet: return .keyword(.willSet) + case .`init`: return .keyword(.`init`) case .unsafeAddress: return .keyword(.unsafeAddress) case .addressWithOwner: return .keyword(.addressWithOwner) case .addressWithNativeOwner: return .keyword(.addressWithNativeOwner) diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift index b810a75b0ed..b8d059ea252 100644 --- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift @@ -16,6 +16,8 @@ import SwiftSyntax private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { switch keyPath { + case \AccessesEffectSyntax.propertyList: + return "properties" case \AccessorDeclSyntax.attributes: return "attributes" case \AccessorDeclSyntax.modifier: @@ -208,6 +210,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "function signature" case \InitializerDeclSyntax.genericWhereClause: return "generic where clause" + case \InitializesEffectSyntax.propertyList: + return "properties" case \KeyPathExprSyntax.root: return "root" case \KeyPathSubscriptComponentSyntax.argumentList: diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index 780b3becf4e..637fcd1097e 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -19,10 +19,14 @@ extension SyntaxKind { switch self { case .token: return "token" + case .accessesEffect: + return "accesses effect" case .accessorDecl: return "accessor" case .accessorEffectSpecifiers: return "accessor specifiers" + case .accessorInitEffects: + return "init accessor effects" case .actorDecl: return "actor" case .arrayElement: @@ -225,6 +229,8 @@ extension SyntaxKind { return "inherited type" case .initializerDecl: return "initializer" + case .initializesEffect: + return "initializes effect" case .integerLiteralExpr: return "integer literal" case .isExpr: diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md index aa94f4e9508..2ae3005a0f9 100644 --- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md @@ -305,8 +305,10 @@ These articles are intended for developers wishing to contribute to SwiftSyntax ### Miscellaneous Syntax +- - - +- - - - @@ -336,6 +338,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax - - - +- - - - diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index 081cd080407..6906352879b 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -17,6 +17,24 @@ @_spi(RawSyntax) public func childName(_ keyPath: AnyKeyPath) -> String? { switch keyPath { + case \AccessesEffectSyntax.unexpectedBeforeAccessesKeyword: + return "unexpectedBeforeAccessesKeyword" + case \AccessesEffectSyntax.accessesKeyword: + return "accessesKeyword" + case \AccessesEffectSyntax.unexpectedBetweenAccessesKeywordAndLeftParen: + return "unexpectedBetweenAccessesKeywordAndLeftParen" + case \AccessesEffectSyntax.leftParen: + return "leftParen" + case \AccessesEffectSyntax.unexpectedBetweenLeftParenAndPropertyList: + return "unexpectedBetweenLeftParenAndPropertyList" + case \AccessesEffectSyntax.propertyList: + return "propertyList" + case \AccessesEffectSyntax.unexpectedBetweenPropertyListAndRightParen: + return "unexpectedBetweenPropertyListAndRightParen" + case \AccessesEffectSyntax.rightParen: + return "rightParen" + case \AccessesEffectSyntax.unexpectedAfterRightParen: + return "unexpectedAfterRightParen" case \AccessorBlockSyntax.unexpectedBeforeLeftBrace: return "unexpectedBeforeLeftBrace" case \AccessorBlockSyntax.leftBrace: @@ -51,8 +69,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenParameterAndEffectSpecifiers" case \AccessorDeclSyntax.effectSpecifiers: return "effectSpecifiers" - case \AccessorDeclSyntax.unexpectedBetweenEffectSpecifiersAndBody: - return "unexpectedBetweenEffectSpecifiersAndBody" + case \AccessorDeclSyntax.unexpectedBetweenEffectSpecifiersAndInitEffects: + return "unexpectedBetweenEffectSpecifiersAndInitEffects" + case \AccessorDeclSyntax.initEffects: + return "initEffects" + case \AccessorDeclSyntax.unexpectedBetweenInitEffectsAndBody: + return "unexpectedBetweenInitEffectsAndBody" case \AccessorDeclSyntax.body: return "body" case \AccessorDeclSyntax.unexpectedAfterBody: @@ -67,6 +89,16 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "throwsSpecifier" case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier: return "unexpectedAfterThrowsSpecifier" + case \AccessorInitEffectsSyntax.unexpectedBeforeInitializesEffect: + return "unexpectedBeforeInitializesEffect" + case \AccessorInitEffectsSyntax.initializesEffect: + return "initializesEffect" + case \AccessorInitEffectsSyntax.unexpectedBetweenInitializesEffectAndAccessesEffect: + return "unexpectedBetweenInitializesEffectAndAccessesEffect" + case \AccessorInitEffectsSyntax.accessesEffect: + return "accessesEffect" + case \AccessorInitEffectsSyntax.unexpectedAfterAccessesEffect: + return "unexpectedAfterAccessesEffect" case \AccessorParameterSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" case \AccessorParameterSyntax.leftParen: @@ -1825,6 +1857,24 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "body" case \InitializerDeclSyntax.unexpectedAfterBody: return "unexpectedAfterBody" + case \InitializesEffectSyntax.unexpectedBeforeInitializesKeyword: + return "unexpectedBeforeInitializesKeyword" + case \InitializesEffectSyntax.initializesKeyword: + return "initializesKeyword" + case \InitializesEffectSyntax.unexpectedBetweenInitializesKeywordAndLeftParen: + return "unexpectedBetweenInitializesKeywordAndLeftParen" + case \InitializesEffectSyntax.leftParen: + return "leftParen" + case \InitializesEffectSyntax.unexpectedBetweenLeftParenAndPropertyList: + return "unexpectedBetweenLeftParenAndPropertyList" + case \InitializesEffectSyntax.propertyList: + return "propertyList" + case \InitializesEffectSyntax.unexpectedBetweenPropertyListAndRightParen: + return "unexpectedBetweenPropertyListAndRightParen" + case \InitializesEffectSyntax.rightParen: + return "rightParen" + case \InitializesEffectSyntax.unexpectedAfterRightParen: + return "unexpectedAfterRightParen" case \IntegerLiteralExprSyntax.unexpectedBeforeDigits: return "unexpectedBeforeDigits" case \IntegerLiteralExprSyntax.digits: diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift index 1f5a8df92f2..0b8c1d21a86 100644 --- a/Sources/SwiftSyntax/generated/Keyword.swift +++ b/Sources/SwiftSyntax/generated/Keyword.swift @@ -61,6 +61,7 @@ public enum Keyword: UInt8, Hashable { case _underlyingVersion case _UnknownLayout case _version + case accesses case actor case addressWithNativeOwner case addressWithOwner @@ -128,6 +129,7 @@ public enum Keyword: UInt8, Hashable { case indirect case infix case `init` + case initializes case inline case `inout` case `internal` @@ -475,6 +477,8 @@ public enum Keyword: UInt8, Hashable { self = ._Trivial case "_version": self = ._version + case "accesses": + self = .accesses case "compiler": self = .compiler case "continue": @@ -596,6 +600,8 @@ public enum Keyword: UInt8, Hashable { self = .`fallthrough` case "fileprivate": self = .`fileprivate` + case "initializes": + self = .initializes case "nonisolated": self = .nonisolated case "nonmutating": @@ -804,6 +810,7 @@ public enum Keyword: UInt8, Hashable { "_underlyingVersion", "_UnknownLayout", "_version", + "accesses", "actor", "addressWithNativeOwner", "addressWithOwner", @@ -871,6 +878,7 @@ public enum Keyword: UInt8, Hashable { "indirect", "infix", "init", + "initializes", "inline", "inout", "internal", diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 480d555bef5..3840ac29cfc 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -53,6 +53,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: AccessesEffectSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: AccessesEffectSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: AccessorBlockSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -77,6 +85,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: AccessorInitEffectsSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: AccessorInitEffectsSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: AccessorListSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -1221,6 +1237,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: InitializesEffectSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: InitializesEffectSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index a0437307654..f19cee394bb 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -687,9 +687,11 @@ extension Syntax { public static var structure: SyntaxNodeStructure { return .choices([ .node(TokenSyntax.self), + .node(AccessesEffectSyntax.self), .node(AccessorBlockSyntax.self), .node(AccessorDeclSyntax.self), .node(AccessorEffectSpecifiersSyntax.self), + .node(AccessorInitEffectsSyntax.self), .node(AccessorListSyntax.self), .node(AccessorParameterSyntax.self), .node(ActorDeclSyntax.self), @@ -833,6 +835,7 @@ extension Syntax { .node(InheritedTypeSyntax.self), .node(InitializerClauseSyntax.self), .node(InitializerDeclSyntax.self), + .node(InitializesEffectSyntax.self), .node(IntegerLiteralExprSyntax.self), .node(IsExprSyntax.self), .node(IsTypePatternSyntax.self), diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index dfa61a4a617..509edc1a73a 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -15,9 +15,11 @@ /// Enum to exhaustively switch over all different syntax nodes. public enum SyntaxEnum { case token(TokenSyntax) + case accessesEffect(AccessesEffectSyntax) case accessorBlock(AccessorBlockSyntax) case accessorDecl(AccessorDeclSyntax) case accessorEffectSpecifiers(AccessorEffectSpecifiersSyntax) + case accessorInitEffects(AccessorInitEffectsSyntax) case accessorList(AccessorListSyntax) case accessorParameter(AccessorParameterSyntax) case actorDecl(ActorDeclSyntax) @@ -161,6 +163,7 @@ public enum SyntaxEnum { case inheritedType(InheritedTypeSyntax) case initializerClause(InitializerClauseSyntax) case initializerDecl(InitializerDeclSyntax) + case initializesEffect(InitializesEffectSyntax) case integerLiteralExpr(IntegerLiteralExprSyntax) case isExpr(IsExprSyntax) case isTypePattern(IsTypePatternSyntax) @@ -297,12 +300,16 @@ public extension Syntax { switch raw.kind { case .token: return .token(TokenSyntax(self)!) + case .accessesEffect: + return .accessesEffect(AccessesEffectSyntax(self)!) case .accessorBlock: return .accessorBlock(AccessorBlockSyntax(self)!) case .accessorDecl: return .accessorDecl(AccessorDeclSyntax(self)!) case .accessorEffectSpecifiers: return .accessorEffectSpecifiers(AccessorEffectSpecifiersSyntax(self)!) + case .accessorInitEffects: + return .accessorInitEffects(AccessorInitEffectsSyntax(self)!) case .accessorList: return .accessorList(AccessorListSyntax(self)!) case .accessorParameter: @@ -589,6 +596,8 @@ public extension Syntax { return .initializerClause(InitializerClauseSyntax(self)!) case .initializerDecl: return .initializerDecl(InitializerDeclSyntax(self)!) + case .initializesEffect: + return .initializesEffect(InitializesEffectSyntax(self)!) case .integerLiteralExpr: return .integerLiteralExpr(IntegerLiteralExprSyntax(self)!) case .isExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index 2b475a6bf2e..967b5a5e3cd 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -15,9 +15,11 @@ /// Enumerates the known kinds of Syntax represented in the Syntax tree. public enum SyntaxKind { case token + case accessesEffect case accessorBlock case accessorDecl case accessorEffectSpecifiers + case accessorInitEffects case accessorList case accessorParameter case actorDecl @@ -161,6 +163,7 @@ public enum SyntaxKind { case inheritedType case initializerClause case initializerDecl + case initializesEffect case integerLiteralExpr case isExpr case isTypePattern @@ -416,12 +419,16 @@ public enum SyntaxKind { switch self { case .token: return TokenSyntax.self + case .accessesEffect: + return AccessesEffectSyntax.self case .accessorBlock: return AccessorBlockSyntax.self case .accessorDecl: return AccessorDeclSyntax.self case .accessorEffectSpecifiers: return AccessorEffectSpecifiersSyntax.self + case .accessorInitEffects: + return AccessorInitEffectsSyntax.self case .accessorList: return AccessorListSyntax.self case .accessorParameter: @@ -708,6 +715,8 @@ public enum SyntaxKind { return InitializerClauseSyntax.self case .initializerDecl: return InitializerDeclSyntax.self + case .initializesEffect: + return InitializesEffectSyntax.self case .integerLiteralExpr: return IntegerLiteralExprSyntax.self case .isExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index 9aa254e32df..e6762f914f3 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -25,6 +25,13 @@ open class SyntaxRewriter { public init() { } + /// Visit a ``AccessesEffectSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AccessesEffectSyntax) -> AccessesEffectSyntax { + return Syntax(visitChildren(node)).cast(AccessesEffectSyntax.self) + } + /// Visit a ``AccessorBlockSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -46,6 +53,13 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(AccessorEffectSpecifiersSyntax.self) } + /// Visit a ``AccessorInitEffectsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AccessorInitEffectsSyntax) -> AccessorInitEffectsSyntax { + return Syntax(visitChildren(node)).cast(AccessorInitEffectsSyntax.self) + } + /// Visit a ``AccessorListSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1047,6 +1061,13 @@ open class SyntaxRewriter { return DeclSyntax(visitChildren(node)) } + /// Visit a ``InitializesEffectSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InitializesEffectSyntax) -> InitializesEffectSyntax { + return Syntax(visitChildren(node)).cast(InitializesEffectSyntax.self) + } + /// Visit a ``IntegerLiteralExprSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2017,6 +2038,20 @@ open class SyntaxRewriter { return visit(node.data).cast(TypeSyntax.self) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplAccessesEffectSyntax(_ data: SyntaxData) -> Syntax { + let node = AccessesEffectSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + /// Implementation detail of visit(_:). Do not call directly. private func visitImplAccessorBlockSyntax(_ data: SyntaxData) -> Syntax { let node = AccessorBlockSyntax(data) @@ -2059,6 +2094,20 @@ open class SyntaxRewriter { return Syntax(visit(node)) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplAccessorInitEffectsSyntax(_ data: SyntaxData) -> Syntax { + let node = AccessorInitEffectsSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + /// Implementation detail of visit(_:). Do not call directly. private func visitImplAccessorListSyntax(_ data: SyntaxData) -> Syntax { let node = AccessorListSyntax(data) @@ -4061,6 +4110,20 @@ open class SyntaxRewriter { return Syntax(visit(node)) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplInitializesEffectSyntax(_ data: SyntaxData) -> Syntax { + let node = InitializesEffectSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + /// Implementation detail of visit(_:). Do not call directly. private func visitImplIntegerLiteralExprSyntax(_ data: SyntaxData) -> Syntax { let node = IntegerLiteralExprSyntax(data) @@ -5895,12 +5958,16 @@ open class SyntaxRewriter { switch data.raw.kind { case .token: return visitImplTokenSyntax + case .accessesEffect: + return visitImplAccessesEffectSyntax case .accessorBlock: return visitImplAccessorBlockSyntax case .accessorDecl: return visitImplAccessorDeclSyntax case .accessorEffectSpecifiers: return visitImplAccessorEffectSpecifiersSyntax + case .accessorInitEffects: + return visitImplAccessorInitEffectsSyntax case .accessorList: return visitImplAccessorListSyntax case .accessorParameter: @@ -6187,6 +6254,8 @@ open class SyntaxRewriter { return visitImplInitializerClauseSyntax case .initializerDecl: return visitImplInitializerDeclSyntax + case .initializesEffect: + return visitImplInitializesEffectSyntax case .integerLiteralExpr: return visitImplIntegerLiteralExprSyntax case .isExpr: @@ -6453,12 +6522,16 @@ open class SyntaxRewriter { switch data.raw.kind { case .token: return visitImplTokenSyntax(data) + case .accessesEffect: + return visitImplAccessesEffectSyntax(data) case .accessorBlock: return visitImplAccessorBlockSyntax(data) case .accessorDecl: return visitImplAccessorDeclSyntax(data) case .accessorEffectSpecifiers: return visitImplAccessorEffectSpecifiersSyntax(data) + case .accessorInitEffects: + return visitImplAccessorInitEffectsSyntax(data) case .accessorList: return visitImplAccessorListSyntax(data) case .accessorParameter: @@ -6745,6 +6818,8 @@ open class SyntaxRewriter { return visitImplInitializerClauseSyntax(data) case .initializerDecl: return visitImplInitializerDeclSyntax(data) + case .initializesEffect: + return visitImplInitializesEffectSyntax(data) case .integerLiteralExpr: return visitImplIntegerLiteralExprSyntax(data) case .isExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift index b829db1334e..fe01070f4e3 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift @@ -19,6 +19,11 @@ public protocol SyntaxTransformVisitor { func visit(_ token: TokenSyntax) -> ResultType + /// Visiting ``AccessesEffectSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: AccessesEffectSyntax) -> ResultType + /// Visiting ``AccessorBlockSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -34,6 +39,11 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: AccessorEffectSpecifiersSyntax) -> ResultType + /// Visiting ``AccessorInitEffectsSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: AccessorInitEffectsSyntax) -> ResultType + /// Visiting ``AccessorListSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -749,6 +759,11 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: InitializerDeclSyntax) -> ResultType + /// Visiting ``InitializesEffectSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: InitializesEffectSyntax) -> ResultType + /// Visiting ``IntegerLiteralExprSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -1395,6 +1410,13 @@ extension SyntaxTransformVisitor { visitAny(Syntax(token)) } + /// Visiting ``AccessesEffectSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: AccessesEffectSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting ``AccessorBlockSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -1416,6 +1438,13 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } + /// Visiting ``AccessorInitEffectsSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: AccessorInitEffectsSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting ``AccessorListSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2417,6 +2446,13 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } + /// Visiting ``InitializesEffectSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: InitializesEffectSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting ``IntegerLiteralExprSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -3317,12 +3353,16 @@ extension SyntaxTransformVisitor { switch node.as(SyntaxEnum.self) { case .token(let node): return visit(node) + case .accessesEffect(let derived): + return visit(derived) case .accessorBlock(let derived): return visit(derived) case .accessorDecl(let derived): return visit(derived) case .accessorEffectSpecifiers(let derived): return visit(derived) + case .accessorInitEffects(let derived): + return visit(derived) case .accessorList(let derived): return visit(derived) case .accessorParameter(let derived): @@ -3609,6 +3649,8 @@ extension SyntaxTransformVisitor { return visit(derived) case .initializerDecl(let derived): return visit(derived) + case .initializesEffect(let derived): + return visit(derived) case .integerLiteralExpr(let derived): return visit(derived) case .isExpr(let derived): diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index fa38af78294..31199ec2f4d 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -34,6 +34,18 @@ open class SyntaxVisitor { visit(node.data) } + /// Visiting ``AccessesEffectSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: AccessesEffectSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``AccessesEffectSyntax`` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: AccessesEffectSyntax) { + } + /// Visiting ``AccessorBlockSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -70,6 +82,18 @@ open class SyntaxVisitor { open func visitPost(_ node: AccessorEffectSpecifiersSyntax) { } + /// Visiting ``AccessorInitEffectsSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: AccessorInitEffectsSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``AccessorInitEffectsSyntax`` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: AccessorInitEffectsSyntax) { + } + /// Visiting ``AccessorListSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1786,6 +1810,18 @@ open class SyntaxVisitor { open func visitPost(_ node: InitializerDeclSyntax) { } + /// Visiting ``InitializesEffectSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: InitializesEffectSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``InitializesEffectSyntax`` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: InitializesEffectSyntax) { + } + /// Visiting ``IntegerLiteralExprSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -3334,6 +3370,17 @@ open class SyntaxVisitor { open func visitPost(_ node: TokenSyntax) { } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplAccessesEffectSyntax(_ data: SyntaxData) { + let node = AccessesEffectSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + /// Implementation detail of doVisit(_:_:). Do not call directly. private func visitImplAccessorBlockSyntax(_ data: SyntaxData) { let node = AccessorBlockSyntax(data) @@ -3367,6 +3414,17 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplAccessorInitEffectsSyntax(_ data: SyntaxData) { + let node = AccessorInitEffectsSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + /// Implementation detail of doVisit(_:_:). Do not call directly. private func visitImplAccessorListSyntax(_ data: SyntaxData) { let node = AccessorListSyntax(data) @@ -4940,6 +4998,17 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplInitializesEffectSyntax(_ data: SyntaxData) { + let node = InitializesEffectSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + /// Implementation detail of doVisit(_:_:). Do not call directly. private func visitImplIntegerLiteralExprSyntax(_ data: SyntaxData) { let node = IntegerLiteralExprSyntax(data) @@ -6355,12 +6424,16 @@ open class SyntaxVisitor { _ = visit(node) // No children to visit. visitPost(node) + case .accessesEffect: + visitImplAccessesEffectSyntax(data) case .accessorBlock: visitImplAccessorBlockSyntax(data) case .accessorDecl: visitImplAccessorDeclSyntax(data) case .accessorEffectSpecifiers: visitImplAccessorEffectSpecifiersSyntax(data) + case .accessorInitEffects: + visitImplAccessorInitEffectsSyntax(data) case .accessorList: visitImplAccessorListSyntax(data) case .accessorParameter: @@ -6647,6 +6720,8 @@ open class SyntaxVisitor { visitImplInitializerClauseSyntax(data) case .initializerDecl: visitImplInitializerDeclSyntax(data) + case .initializesEffect: + visitImplInitializesEffectSyntax(data) case .integerLiteralExpr: visitImplIntegerLiteralExprSyntax(data) case .isExpr: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift index 121e887bf86..418c00ba3e6 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift @@ -27,6 +27,100 @@ public protocol RawStmtSyntaxNodeProtocol: RawSyntaxNodeProtocol {} @_spi(RawSyntax) public protocol RawTypeSyntaxNodeProtocol: RawSyntaxNodeProtocol {} +@_spi(RawSyntax) +public struct RawAccessesEffectSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .accessesEffect + } + + 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( + _ unexpectedBeforeAccessesKeyword: RawUnexpectedNodesSyntax? = nil, + accessesKeyword: RawTokenSyntax, + _ unexpectedBetweenAccessesKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndPropertyList: RawUnexpectedNodesSyntax? = nil, + propertyList: RawTupleExprElementListSyntax, + _ unexpectedBetweenPropertyListAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .accessesEffect, uninitializedCount: 9, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeAccessesKeyword?.raw + layout[1] = accessesKeyword.raw + layout[2] = unexpectedBetweenAccessesKeywordAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndPropertyList?.raw + layout[5] = propertyList.raw + layout[6] = unexpectedBetweenPropertyListAndRightParen?.raw + layout[7] = rightParen.raw + layout[8] = unexpectedAfterRightParen?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeAccessesKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var accessesKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenAccessesKeywordAndLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenLeftParenAndPropertyList: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var propertyList: RawTupleExprElementListSyntax { + layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))! + } + + public var unexpectedBetweenPropertyListAndRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var rightParen: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawAccessorBlockSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) @@ -149,13 +243,15 @@ public struct RawAccessorDeclSyntax: RawDeclSyntaxNodeProtocol { parameter: RawAccessorParameterSyntax?, _ unexpectedBetweenParameterAndEffectSpecifiers: RawUnexpectedNodesSyntax? = nil, effectSpecifiers: RawAccessorEffectSpecifiersSyntax?, - _ unexpectedBetweenEffectSpecifiersAndBody: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndInitEffects: RawUnexpectedNodesSyntax? = nil, + initEffects: RawAccessorInitEffectsSyntax?, + _ unexpectedBetweenInitEffectsAndBody: RawUnexpectedNodesSyntax? = nil, body: RawCodeBlockSyntax?, _ unexpectedAfterBody: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessorDecl, uninitializedCount: 13, arena: arena) { layout in + kind: .accessorDecl, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -167,9 +263,11 @@ public struct RawAccessorDeclSyntax: RawDeclSyntaxNodeProtocol { layout[7] = parameter?.raw layout[8] = unexpectedBetweenParameterAndEffectSpecifiers?.raw layout[9] = effectSpecifiers?.raw - layout[10] = unexpectedBetweenEffectSpecifiersAndBody?.raw - layout[11] = body?.raw - layout[12] = unexpectedAfterBody?.raw + layout[10] = unexpectedBetweenEffectSpecifiersAndInitEffects?.raw + layout[11] = initEffects?.raw + layout[12] = unexpectedBetweenInitEffectsAndBody?.raw + layout[13] = body?.raw + layout[14] = unexpectedAfterBody?.raw } self.init(unchecked: raw) } @@ -214,16 +312,24 @@ public struct RawAccessorDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[9].map(RawAccessorEffectSpecifiersSyntax.init(raw:)) } - public var unexpectedBetweenEffectSpecifiersAndBody: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenEffectSpecifiersAndInitEffects: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var initEffects: RawAccessorInitEffectsSyntax? { + layoutView.children[11].map(RawAccessorInitEffectsSyntax.init(raw:)) + } + + public var unexpectedBetweenInitEffectsAndBody: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var body: RawCodeBlockSyntax? { - layoutView.children[11].map(RawCodeBlockSyntax.init(raw:)) + layoutView.children[13].map(RawCodeBlockSyntax.init(raw:)) } public var unexpectedAfterBody: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } } @@ -297,6 +403,76 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawAccessorInitEffectsSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .accessorInitEffects + } + + 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( + _ unexpectedBeforeInitializesEffect: RawUnexpectedNodesSyntax? = nil, + initializesEffect: RawInitializesEffectSyntax?, + _ unexpectedBetweenInitializesEffectAndAccessesEffect: RawUnexpectedNodesSyntax? = nil, + accessesEffect: RawAccessesEffectSyntax?, + _ unexpectedAfterAccessesEffect: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .accessorInitEffects, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeInitializesEffect?.raw + layout[1] = initializesEffect?.raw + layout[2] = unexpectedBetweenInitializesEffectAndAccessesEffect?.raw + layout[3] = accessesEffect?.raw + layout[4] = unexpectedAfterAccessesEffect?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeInitializesEffect: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var initializesEffect: RawInitializesEffectSyntax? { + layoutView.children[1].map(RawInitializesEffectSyntax.init(raw:)) + } + + public var unexpectedBetweenInitializesEffectAndAccessesEffect: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var accessesEffect: RawAccessesEffectSyntax? { + layoutView.children[3].map(RawAccessesEffectSyntax.init(raw:)) + } + + public var unexpectedAfterAccessesEffect: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawAccessorListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) @@ -12241,6 +12417,100 @@ public struct RawInitializerDeclSyntax: RawDeclSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawInitializesEffectSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .initializesEffect + } + + 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( + _ unexpectedBeforeInitializesKeyword: RawUnexpectedNodesSyntax? = nil, + initializesKeyword: RawTokenSyntax, + _ unexpectedBetweenInitializesKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndPropertyList: RawUnexpectedNodesSyntax? = nil, + propertyList: RawTupleExprElementListSyntax, + _ unexpectedBetweenPropertyListAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .initializesEffect, uninitializedCount: 9, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeInitializesKeyword?.raw + layout[1] = initializesKeyword.raw + layout[2] = unexpectedBetweenInitializesKeywordAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndPropertyList?.raw + layout[5] = propertyList.raw + layout[6] = unexpectedBetweenPropertyListAndRightParen?.raw + layout[7] = rightParen.raw + layout[8] = unexpectedAfterRightParen?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeInitializesKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var initializesKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenInitializesKeywordAndLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenLeftParenAndPropertyList: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var propertyList: RawTupleExprElementListSyntax { + layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))! + } + + public var unexpectedBetweenPropertyListAndRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var rightParen: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawIntegerLiteralExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 6b5b5a44857..c791caf7bbf 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -205,6 +205,17 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { switch kind { case .token: assertionFailure("validateLayout for .token kind is not supported") + case .accessesEffect: + assert(layout.count == 9) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("accesses")])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTupleExprElementListSyntax.self)) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)])) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) case .accessorBlock: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -215,7 +226,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightBrace)])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) case .accessorDecl: - assert(layout.count == 13) + 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)) @@ -233,15 +244,18 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { .keyword("mutableAddressWithOwner"), .keyword("mutableAddressWithNativeOwner"), .keyword("_read"), - .keyword("_modify") + .keyword("_modify"), + .keyword("init") ])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 7, verify(layout[7], as: RawAccessorParameterSyntax?.self)) assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 9, verify(layout[9], as: RawAccessorEffectSpecifiersSyntax?.self)) assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 11, verify(layout[11], as: RawCodeBlockSyntax?.self)) + assertNoError(kind, 11, verify(layout[11], as: RawAccessorInitEffectsSyntax?.self)) assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 13, verify(layout[13], as: RawCodeBlockSyntax?.self)) + assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) case .accessorEffectSpecifiers: assert(layout.count == 5) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -249,6 +263,13 @@ 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: [.keyword("throws")])) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + case .accessorInitEffects: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawInitializesEffectSyntax?.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawAccessesEffectSyntax?.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .accessorList: for (index, element) in layout.enumerated() { assertNoError(kind, index, verify(element, as: RawAccessorDeclSyntax.self)) @@ -1572,6 +1593,17 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 15, verify(layout[15], as: RawCodeBlockSyntax?.self)) assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) + case .initializesEffect: + assert(layout.count == 9) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("initializes")])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTupleExprElementListSyntax.self)) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)])) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) case .integerLiteralExpr: assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift index a580371e6ed..c295d454f40 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift @@ -45,7 +45,9 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { parameter: AccessorParameterSyntax? = nil, _ unexpectedBetweenParameterAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, effectSpecifiers: AccessorEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndBody: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndInitEffects: UnexpectedNodesSyntax? = nil, + initEffects: AccessorInitEffectsSyntax? = nil, + _ unexpectedBetweenInitEffectsAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax? = nil, _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -64,7 +66,9 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { parameter, unexpectedBetweenParameterAndEffectSpecifiers, effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndBody, + unexpectedBetweenEffectSpecifiersAndInitEffects, + initEffects, + unexpectedBetweenInitEffectsAndBody, body, unexpectedAfterBody ))) {(arena, _) in @@ -79,7 +83,9 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { parameter?.raw, unexpectedBetweenParameterAndEffectSpecifiers?.raw, effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndBody?.raw, + unexpectedBetweenEffectSpecifiersAndInitEffects?.raw, + initEffects?.raw, + unexpectedBetweenInitEffectsAndBody?.raw, body?.raw, unexpectedAfterBody?.raw ] @@ -205,7 +211,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } - public var unexpectedBetweenEffectSpecifiersAndBody: UnexpectedNodesSyntax? { + public var unexpectedBetweenEffectSpecifiersAndInitEffects: UnexpectedNodesSyntax? { get { return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -214,16 +220,16 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } - public var body: CodeBlockSyntax? { + public var initEffects: AccessorInitEffectsSyntax? { get { - return data.child(at: 11, parent: Syntax(self)).map(CodeBlockSyntax.init) + return data.child(at: 11, parent: Syntax(self)).map(AccessorInitEffectsSyntax.init) } set(value) { self = AccessorDeclSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterBody: UnexpectedNodesSyntax? { + public var unexpectedBetweenInitEffectsAndBody: UnexpectedNodesSyntax? { get { return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -232,6 +238,24 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } + public var body: CodeBlockSyntax? { + get { + return data.child(at: 13, parent: Syntax(self)).map(CodeBlockSyntax.init) + } + set(value) { + self = AccessorDeclSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterBody: UnexpectedNodesSyntax? { + get { + return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessorDeclSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) + } + } + public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeAttributes, @@ -244,7 +268,9 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { \Self.parameter, \Self.unexpectedBetweenParameterAndEffectSpecifiers, \Self.effectSpecifiers, - \Self.unexpectedBetweenEffectSpecifiersAndBody, + \Self.unexpectedBetweenEffectSpecifiersAndInitEffects, + \Self.initEffects, + \Self.unexpectedBetweenInitEffectsAndBody, \Self.body, \Self.unexpectedAfterBody ]) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift index 9477bd63355..e2e9b2a7cce 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift @@ -12,6 +12,193 @@ // //===----------------------------------------------------------------------===// +// MARK: - AccessesEffectSyntax + + +public struct AccessesEffectSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: some SyntaxProtocol) { + guard node.raw.kind == .accessesEffect else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a ``AccessesEffectSyntax`` node from the given ``SyntaxData``. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .accessesEffect) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAccessesKeyword: UnexpectedNodesSyntax? = nil, + accessesKeyword: TokenSyntax = .keyword(.accesses), + _ unexpectedBetweenAccessesKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndPropertyList: UnexpectedNodesSyntax? = nil, + propertyList: TupleExprElementListSyntax, + _ unexpectedBetweenPropertyListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: 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. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeAccessesKeyword, + accessesKeyword, + unexpectedBetweenAccessesKeywordAndLeftParen, + leftParen, + unexpectedBetweenLeftParenAndPropertyList, + propertyList, + unexpectedBetweenPropertyListAndRightParen, + rightParen, + unexpectedAfterRightParen + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeAccessesKeyword?.raw, + accessesKeyword.raw, + unexpectedBetweenAccessesKeywordAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndPropertyList?.raw, + propertyList.raw, + unexpectedBetweenPropertyListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.accessesEffect, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeAccessesKeyword: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var accessesKeyword: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenAccessesKeywordAndLeftParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var leftParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenLeftParenAndPropertyList: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var propertyList: TupleExprElementListSyntax { + get { + return TupleExprElementListSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `element` to the node's `propertyList` + /// collection. + /// - param element: The new `Property` to add to the node's + /// `propertyList` collection. + /// - returns: A copy of the receiver with the provided `Property` + /// appended to its `propertyList` collection. + public func addProperty(_ element: TupleExprElementSyntax) -> AccessesEffectSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return AccessesEffectSyntax(newData) + } + + public var unexpectedBetweenPropertyListAndRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var rightParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessesEffectSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeAccessesKeyword, + \Self.accessesKeyword, + \Self.unexpectedBetweenAccessesKeywordAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndPropertyList, + \Self.propertyList, + \Self.unexpectedBetweenPropertyListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen + ]) + } +} + // MARK: - AccessorBlockSyntax @@ -289,6 +476,122 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { } } +// MARK: - AccessorInitEffectsSyntax + + +public struct AccessorInitEffectsSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: some SyntaxProtocol) { + guard node.raw.kind == .accessorInitEffects else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a ``AccessorInitEffectsSyntax`` node from the given ``SyntaxData``. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .accessorInitEffects) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeInitializesEffect: UnexpectedNodesSyntax? = nil, + initializesEffect: InitializesEffectSyntax? = nil, + _ unexpectedBetweenInitializesEffectAndAccessesEffect: UnexpectedNodesSyntax? = nil, + accessesEffect: AccessesEffectSyntax? = nil, + _ unexpectedAfterAccessesEffect: 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. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeInitializesEffect, + initializesEffect, + unexpectedBetweenInitializesEffectAndAccessesEffect, + accessesEffect, + unexpectedAfterAccessesEffect + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeInitializesEffect?.raw, + initializesEffect?.raw, + unexpectedBetweenInitializesEffectAndAccessesEffect?.raw, + accessesEffect?.raw, + unexpectedAfterAccessesEffect?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.accessorInitEffects, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeInitializesEffect: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessorInitEffectsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var initializesEffect: InitializesEffectSyntax? { + get { + return data.child(at: 1, parent: Syntax(self)).map(InitializesEffectSyntax.init) + } + set(value) { + self = AccessorInitEffectsSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenInitializesEffectAndAccessesEffect: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessorInitEffectsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var accessesEffect: AccessesEffectSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(AccessesEffectSyntax.init) + } + set(value) { + self = AccessorInitEffectsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterAccessesEffect: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AccessorInitEffectsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeInitializesEffect, + \Self.initializesEffect, + \Self.unexpectedBetweenInitializesEffectAndAccessesEffect, + \Self.accessesEffect, + \Self.unexpectedAfterAccessesEffect + ]) + } +} + // MARK: - AccessorParameterSyntax @@ -10601,6 +10904,193 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { } } +// MARK: - InitializesEffectSyntax + + +public struct InitializesEffectSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: some SyntaxProtocol) { + guard node.raw.kind == .initializesEffect else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a ``InitializesEffectSyntax`` node from the given ``SyntaxData``. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .initializesEffect) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeInitializesKeyword: UnexpectedNodesSyntax? = nil, + initializesKeyword: TokenSyntax = .keyword(.initializes), + _ unexpectedBetweenInitializesKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndPropertyList: UnexpectedNodesSyntax? = nil, + propertyList: TupleExprElementListSyntax, + _ unexpectedBetweenPropertyListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: 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. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeInitializesKeyword, + initializesKeyword, + unexpectedBetweenInitializesKeywordAndLeftParen, + leftParen, + unexpectedBetweenLeftParenAndPropertyList, + propertyList, + unexpectedBetweenPropertyListAndRightParen, + rightParen, + unexpectedAfterRightParen + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeInitializesKeyword?.raw, + initializesKeyword.raw, + unexpectedBetweenInitializesKeywordAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndPropertyList?.raw, + propertyList.raw, + unexpectedBetweenPropertyListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.initializesEffect, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeInitializesKeyword: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var initializesKeyword: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenInitializesKeywordAndLeftParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var leftParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenLeftParenAndPropertyList: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var propertyList: TupleExprElementListSyntax { + get { + return TupleExprElementListSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `element` to the node's `propertyList` + /// collection. + /// - param element: The new `Property` to add to the node's + /// `propertyList` collection. + /// - returns: A copy of the receiver with the provided `Property` + /// appended to its `propertyList` collection. + public func addProperty(_ element: TupleExprElementSyntax) -> InitializesEffectSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return InitializesEffectSyntax(newData) + } + + public var unexpectedBetweenPropertyListAndRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var rightParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = InitializesEffectSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeInitializesKeyword, + \Self.initializesKeyword, + \Self.unexpectedBetweenInitializesKeywordAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndPropertyList, + \Self.propertyList, + \Self.unexpectedBetweenPropertyListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen + ]) + } +} + // MARK: - KeyPathComponentSyntax diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index 9be44b7b8d6..ed6a333bae5 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -14,6 +14,37 @@ import SwiftSyntax +extension AccessesEffectSyntax { + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeAccessesKeyword: UnexpectedNodesSyntax? = nil, + accessesKeyword: TokenSyntax = .keyword(.accesses), + unexpectedBetweenAccessesKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + unexpectedBetweenLeftParenAndPropertyList: UnexpectedNodesSyntax? = nil, + unexpectedBetweenPropertyListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + @TupleExprElementListBuilder propertyListBuilder: () throws -> TupleExprElementListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAccessesKeyword, + accessesKeyword: accessesKeyword, + unexpectedBetweenAccessesKeywordAndLeftParen, + leftParen: leftParen, + unexpectedBetweenLeftParenAndPropertyList, + propertyList: propertyListBuilder(), + unexpectedBetweenPropertyListAndRightParen, + rightParen: rightParen, + unexpectedAfterRightParen, + trailingTrivia: trailingTrivia + ) + } +} + extension AccessorDeclSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( @@ -28,7 +59,9 @@ extension AccessorDeclSyntax { parameter: AccessorParameterSyntax? = nil, unexpectedBetweenParameterAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, effectSpecifiers: AccessorEffectSpecifiersSyntax? = nil, - unexpectedBetweenEffectSpecifiersAndBody: UnexpectedNodesSyntax? = nil, + unexpectedBetweenEffectSpecifiersAndInitEffects: UnexpectedNodesSyntax? = nil, + initEffects: AccessorInitEffectsSyntax? = nil, + unexpectedBetweenInitEffectsAndBody: UnexpectedNodesSyntax? = nil, unexpectedAfterBody: UnexpectedNodesSyntax? = nil, @CodeBlockItemListBuilder bodyBuilder: () throws -> CodeBlockItemListSyntax?, trailingTrivia: Trivia? = nil @@ -45,7 +78,9 @@ extension AccessorDeclSyntax { parameter: parameter, unexpectedBetweenParameterAndEffectSpecifiers, effectSpecifiers: effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndBody, + unexpectedBetweenEffectSpecifiersAndInitEffects, + initEffects: initEffects, + unexpectedBetweenInitEffectsAndBody, body: bodyBuilder().map { CodeBlockSyntax(statements: $0) }, @@ -866,6 +901,37 @@ extension InitializerDeclSyntax { } } +extension InitializesEffectSyntax { + /// A convenience initializer that allows initializing syntax collections using result builders + public init( + leadingTrivia: Trivia? = nil, + unexpectedBeforeInitializesKeyword: UnexpectedNodesSyntax? = nil, + initializesKeyword: TokenSyntax = .keyword(.initializes), + unexpectedBetweenInitializesKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + unexpectedBetweenLeftParenAndPropertyList: UnexpectedNodesSyntax? = nil, + unexpectedBetweenPropertyListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + @TupleExprElementListBuilder propertyListBuilder: () throws -> TupleExprElementListSyntax, + trailingTrivia: Trivia? = nil + ) rethrows { + try self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeInitializesKeyword, + initializesKeyword: initializesKeyword, + unexpectedBetweenInitializesKeywordAndLeftParen, + leftParen: leftParen, + unexpectedBetweenLeftParenAndPropertyList, + propertyList: propertyListBuilder(), + unexpectedBetweenPropertyListAndRightParen, + rightParen: rightParen, + unexpectedAfterRightParen, + trailingTrivia: trailingTrivia + ) + } +} + extension KeyPathSubscriptComponentSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init( diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index e4a93b5a5a0..ec2dde26ca3 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -869,6 +869,97 @@ final class DeclarationTests: XCTestCase { ) } + func testInitAccessor() { + assertParse( + """ + struct S { + var value: Int { + init {} + get {} + set {} + } + } + """ + ) + + assertParse( + """ + struct S { + let _value: Int + + init() { + } + } + """ + ) + + assertParse( + """ + struct S { + var value: Int { + init(newValue) {} + get {} + set(newValue) {} + } + } + """ + ) + + assertParse( + """ + struct S { + var value: Int { + init(newValue) {} + get {} + set(newValue) {} + } + } + """ + ) + } + + func testInitAccessorEffects() { + assertParse( + """ + struct S { + var value: Int { + init initializes(x) {} + } + } + """ + ) + + assertParse( + """ + struct S { + var value: Int { + init accesses(x) {} + } + } + """ + ) + + assertParse( + """ + struct S { + var value: Int { + init initializes(x) accesses(y) {} + } + } + """ + ) + + assertParse( + """ + struct S { + var value: Int { + init initializes(x, y, z) accesses(x, y, z) {} + } + } + """ + ) + } + func testExpressionMember() { assertParse( """