From 9f55f4f2879c41eb2a57a5688860f2b3eced62b4 Mon Sep 17 00:00:00 2001 From: Meghana Gupta Date: Sun, 24 Mar 2024 17:55:03 -0700 Subject: [PATCH 1/2] Merge pull request #2564 from apple/updatelifetimesyntax Update lifetime dependence syntax --- .../Sources/SyntaxSupport/KeywordSpec.swift | 15 +- .../Sources/SyntaxSupport/TypeNodes.swift | 38 +-- Sources/SwiftParser/TokenPrecedence.swift | 2 +- Sources/SwiftParser/Types.swift | 39 ++- .../generated/Parser+TokenSpecSet.swift | 73 ------ .../generated/ChildNameForKeyPath.swift | 42 +-- Sources/SwiftSyntax/generated/Keyword.swift | 25 +- .../SwiftSyntax/generated/SyntaxTraits.swift | 2 +- .../generated/raw/RawSyntaxNodesJKLMN.swift | 112 ++++---- .../generated/raw/RawSyntaxValidation.swift | 25 +- .../syntaxNodes/SyntaxNodesJKLMN.swift | 242 +++++++++--------- Tests/SwiftParserTest/DeclarationTests.swift | 2 +- Tests/SwiftParserTest/TypeTests.swift | 40 ++- 13 files changed, 299 insertions(+), 358 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift index 895411bace0..eaff61fad2f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift +++ b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift @@ -108,9 +108,7 @@ public enum Keyword: CaseIterable { case _Class case _compilerInitialized case _const - case _consume case _consuming - case _copy case _documentation case _dynamicReplacement case _effects @@ -121,7 +119,6 @@ public enum Keyword: CaseIterable { case _local case _modify case _move - case _mutate case _mutating case _NativeClass case _NativeRefCountedObject @@ -186,6 +183,7 @@ public enum Keyword: CaseIterable { case `default` case `defer` case `deinit` + case dependsOn case deprecated case derivative case didSet @@ -275,6 +273,7 @@ public enum Keyword: CaseIterable { case reverse case right case safe + case scoped case `self` case `Self` case Sendable @@ -343,12 +342,8 @@ public enum Keyword: CaseIterable { return KeywordSpec("_compilerInitialized") case ._const: return KeywordSpec("_const") - case ._consume: - return KeywordSpec("_consume", experimentalFeature: .nonescapableTypes) case ._consuming: return KeywordSpec("_consuming", experimentalFeature: .referenceBindings) - case ._copy: - return KeywordSpec("_copy", experimentalFeature: .nonescapableTypes) case ._documentation: return KeywordSpec("_documentation") case ._dynamicReplacement: @@ -369,8 +364,6 @@ public enum Keyword: CaseIterable { return KeywordSpec("_modify") case ._move: return KeywordSpec("_move") - case ._mutate: - return KeywordSpec("_mutate", experimentalFeature: .nonescapableTypes) case ._mutating: return KeywordSpec("_mutating", experimentalFeature: .referenceBindings) case ._NativeClass: @@ -499,6 +492,8 @@ public enum Keyword: CaseIterable { return KeywordSpec("defer", isLexerClassified: true) case .deinit: return KeywordSpec("deinit", isLexerClassified: true) + case .dependsOn: + return KeywordSpec("dependsOn", experimentalFeature: .nonescapableTypes) case .deprecated: return KeywordSpec("deprecated") case .derivative: @@ -675,6 +670,8 @@ public enum Keyword: CaseIterable { return KeywordSpec("right") case .safe: return KeywordSpec("safe") + case .scoped: + return KeywordSpec("scoped", experimentalFeature: .nonescapableTypes) case .self: return KeywordSpec("self", isLexerClassified: true) case .Self: diff --git a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift index f337aa226f3..2658b4e0b3f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift @@ -553,25 +553,14 @@ public let TYPE_NODES: [Node] = [ ### Example `borrow(data)` in `func foo(data: Array) -> borrow(data) ComplexReferenceType` """, - traits: [ - "Parenthesized" - ], children: [ - Child( - name: "leftParen", - kind: .token(choices: [.token(.leftParen)]) - ), Child( name: "arguments", kind: .collection(kind: .lifetimeSpecifierArgumentList, collectionElementName: "Arguments"), documentation: """ The function parameters that the lifetime of the annotated type depends on. """ - ), - Child( - name: "rightParen", - kind: .token(choices: [.token(.rightParen)]) - ), + ) ] ), @@ -581,21 +570,32 @@ public let TYPE_NODES: [Node] = [ experimentalFeature: .nonescapableTypes, nameForDiagnostics: "lifetime specifier", documentation: "A specifier that specifies function parameter on whose lifetime a type depends", + traits: [ + "Parenthesized" + ], children: [ Child( - name: "specifier", - kind: .token(choices: [ - .keyword(._copy), - .keyword(._consume), - .keyword(._borrow), - .keyword(._mutate), - ]), + name: "dependsOnKeyword", + kind: .token(choices: [.keyword(.dependsOn)]), documentation: "The specifier token that's attached to the type." ), + Child( + name: "leftParen", + kind: .token(choices: [.token(.leftParen)]) + ), + Child( + name: "scopedKeyword", + kind: .token(choices: [.keyword(.scoped)]), + isOptional: true + ), Child( name: "arguments", kind: .node(kind: .lifetimeSpecifierArguments) ), + Child( + name: "rightParen", + kind: .token(choices: [.token(.rightParen)]) + ), ] ), diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift index a7e66423ba2..f61d51c1902 100644 --- a/Sources/SwiftParser/TokenPrecedence.swift +++ b/Sources/SwiftParser/TokenPrecedence.swift @@ -233,7 +233,7 @@ enum TokenPrecedence: Comparable { .__setter_access, .indirect, .isolated, .nonisolated, .distributed, ._local, .inout, ._mutating, ._borrow, ._borrowing, .borrowing, ._consuming, .consuming, .consume, ._resultDependsOnSelf, ._resultDependsOn, - .transferring, ._consume, ._copy, ._mutate, + .transferring, .dependsOn, .scoped, // Accessors .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress, .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, ._modify, diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift index 1ba26ee569d..99958f0deae 100644 --- a/Sources/SwiftParser/Types.swift +++ b/Sources/SwiftParser/Types.swift @@ -900,33 +900,33 @@ extension Parser.Lookahead { } extension Parser { - private mutating func parseLifetimeTypeSpecifier( - specifierHandle: TokenConsumptionHandle - ) -> RawTypeSpecifierListSyntax.Element { - let specifier = self.eat(specifierHandle) + private mutating func parseLifetimeTypeSpecifier() -> RawTypeSpecifierListSyntax.Element { + let specifier = self.eat(TokenSpec(.dependsOn)) guard let leftParen = self.consume(if: .leftParen) else { // If there is no left paren, add an entirely missing detail. Otherwise, we start to consume the following type // name as a token inside the detail, which leads to confusing recovery results. let arguments = RawLifetimeSpecifierArgumentsSyntax( - leftParen: missingToken(.leftParen), arguments: RawLifetimeSpecifierArgumentListSyntax( elements: [ RawLifetimeSpecifierArgumentSyntax(parameter: missingToken(.identifier), trailingComma: nil, arena: arena) ], arena: self.arena ), - rightParen: missingToken(.rightParen), arena: self.arena ) let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax( - specifier: specifier, + dependsOnKeyword: specifier, + leftParen: missingToken(.leftParen), + scopedKeyword: nil, arguments: arguments, + rightParen: missingToken(.rightParen), arena: self.arena ) return .lifetimeTypeSpecifier(lifetimeSpecifier) } + let scoped = self.consume(if: .keyword(.scoped)) var keepGoing: RawTokenSyntax? var arguments: [RawLifetimeSpecifierArgumentSyntax] = [] var loopProgress = LoopProgressCondition() @@ -948,15 +948,16 @@ extension Parser { let lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax(elements: arguments, arena: self.arena) let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) let argumentsSyntax = RawLifetimeSpecifierArgumentsSyntax( - leftParen: leftParen, arguments: lifetimeSpecifierArgumentList, - unexpectedBeforeRightParen, - rightParen: rightParen, arena: self.arena ) let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax( - specifier: specifier, + dependsOnKeyword: specifier, + leftParen: leftParen, + scopedKeyword: scoped, arguments: argumentsSyntax, + unexpectedBeforeRightParen, + rightParen: rightParen, arena: self.arena ) return .lifetimeTypeSpecifier(lifetimeSpecifier) @@ -976,20 +977,18 @@ extension Parser { specifiers: RawTypeSpecifierListSyntax, attributes: RawAttributeListSyntax )? { - typealias SimpleOrLifetimeSpecifier = - EitherTokenSpecSet var specifiers: [RawTypeSpecifierListSyntax.Element] = [] - SPECIFIER_PARSING: while canHaveParameterSpecifier, - let (specifierSpec, specifierHandle) = self.at(anyIn: SimpleOrLifetimeSpecifier.self) - { - switch specifierSpec { - case .lhs: specifiers.append(parseSimpleTypeSpecifier(specifierHandle: specifierHandle)) - case .rhs: + SPECIFIER_PARSING: while canHaveParameterSpecifier { + if let (_, specifierHandle) = self.at(anyIn: SimpleTypeSpecifierSyntax.SpecifierOptions.self) { + specifiers.append(parseSimpleTypeSpecifier(specifierHandle: specifierHandle)) + } else if self.at(TokenSpec(.dependsOn)) { if self.experimentalFeatures.contains(.nonescapableTypes) { - specifiers.append(parseLifetimeTypeSpecifier(specifierHandle: specifierHandle)) + specifiers.append(parseLifetimeTypeSpecifier()) } else { break SPECIFIER_PARSING } + } else { + break SPECIFIER_PARSING } } specifiers += misplacedSpecifiers.map { diff --git a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift index 98c91c193d4..2667d7dd55f 100644 --- a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift +++ b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift @@ -2623,79 +2623,6 @@ extension LifetimeSpecifierArgumentSyntax { } } -extension LifetimeTypeSpecifierSyntax { - @_spi(Diagnostics) - public enum SpecifierOptions: TokenSpecSet { - @_spi(ExperimentalLanguageFeatures) - case _copy - @_spi(ExperimentalLanguageFeatures) - case _consume - case _borrow - @_spi(ExperimentalLanguageFeatures) - case _mutate - - init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(._copy) where experimentalFeatures.contains(.nonescapableTypes): - self = ._copy - case TokenSpec(._consume) where experimentalFeatures.contains(.nonescapableTypes): - self = ._consume - case TokenSpec(._borrow): - self = ._borrow - case TokenSpec(._mutate) where experimentalFeatures.contains(.nonescapableTypes): - self = ._mutate - default: - return nil - } - } - - public init?(token: TokenSyntax) { - switch token { - case TokenSpec(._copy): - self = ._copy - case TokenSpec(._consume): - self = ._consume - case TokenSpec(._borrow): - self = ._borrow - case TokenSpec(._mutate): - self = ._mutate - default: - return nil - } - } - - var spec: TokenSpec { - switch self { - case ._copy: - return .keyword(._copy) - case ._consume: - return .keyword(._consume) - case ._borrow: - return .keyword(._borrow) - case ._mutate: - return .keyword(._mutate) - } - } - - /// 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 ._copy: - return .keyword(._copy) - case ._consume: - return .keyword(._consume) - case ._borrow: - return .keyword(._borrow) - case ._mutate: - return .keyword(._mutate) - } - } - } -} - extension MemberTypeSyntax { @_spi(Diagnostics) public enum NameOptions: TokenSpecSet { diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index a738f6b9979..b2666dca2a3 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -2009,30 +2009,34 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "trailingComma" case \LifetimeSpecifierArgumentSyntax.unexpectedAfterTrailingComma: return "unexpectedAfterTrailingComma" - case \LifetimeSpecifierArgumentsSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \LifetimeSpecifierArgumentsSyntax.leftParen: - return "leftParen" - case \LifetimeSpecifierArgumentsSyntax.unexpectedBetweenLeftParenAndArguments: - return "unexpectedBetweenLeftParenAndArguments" + case \LifetimeSpecifierArgumentsSyntax.unexpectedBeforeArguments: + return "unexpectedBeforeArguments" case \LifetimeSpecifierArgumentsSyntax.arguments: return "arguments" - case \LifetimeSpecifierArgumentsSyntax.unexpectedBetweenArgumentsAndRightParen: + case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterArguments: + return "unexpectedAfterArguments" + case \LifetimeTypeSpecifierSyntax.unexpectedBeforeDependsOnKeyword: + return "unexpectedBeforeDependsOnKeyword" + case \LifetimeTypeSpecifierSyntax.dependsOnKeyword: + return "dependsOnKeyword" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenDependsOnKeywordAndLeftParen: + return "unexpectedBetweenDependsOnKeywordAndLeftParen" + case \LifetimeTypeSpecifierSyntax.leftParen: + return "leftParen" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenLeftParenAndScopedKeyword: + return "unexpectedBetweenLeftParenAndScopedKeyword" + case \LifetimeTypeSpecifierSyntax.scopedKeyword: + return "scopedKeyword" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenScopedKeywordAndArguments: + return "unexpectedBetweenScopedKeywordAndArguments" + case \LifetimeTypeSpecifierSyntax.arguments: + return "arguments" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenArgumentsAndRightParen: return "unexpectedBetweenArgumentsAndRightParen" - case \LifetimeSpecifierArgumentsSyntax.rightParen: + case \LifetimeTypeSpecifierSyntax.rightParen: return "rightParen" - case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterRightParen: + case \LifetimeTypeSpecifierSyntax.unexpectedAfterRightParen: return "unexpectedAfterRightParen" - case \LifetimeTypeSpecifierSyntax.unexpectedBeforeSpecifier: - return "unexpectedBeforeSpecifier" - case \LifetimeTypeSpecifierSyntax.specifier: - return "specifier" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenSpecifierAndArguments: - return "unexpectedBetweenSpecifierAndArguments" - case \LifetimeTypeSpecifierSyntax.arguments: - return "arguments" - case \LifetimeTypeSpecifierSyntax.unexpectedAfterArguments: - return "unexpectedAfterArguments" case \MacroDeclSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" case \MacroDeclSyntax.attributes: diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift index c331f2f5716..d38e92e96f6 100644 --- a/Sources/SwiftSyntax/generated/Keyword.swift +++ b/Sources/SwiftSyntax/generated/Keyword.swift @@ -28,11 +28,7 @@ public enum Keyword: UInt8, Hashable, Sendable { case _compilerInitialized case _const @_spi(ExperimentalLanguageFeatures) - case _consume - @_spi(ExperimentalLanguageFeatures) case _consuming - @_spi(ExperimentalLanguageFeatures) - case _copy case _documentation case _dynamicReplacement case _effects @@ -44,8 +40,6 @@ public enum Keyword: UInt8, Hashable, Sendable { case _modify case _move @_spi(ExperimentalLanguageFeatures) - case _mutate - @_spi(ExperimentalLanguageFeatures) case _mutating case _NativeClass case _NativeRefCountedObject @@ -110,6 +104,8 @@ public enum Keyword: UInt8, Hashable, Sendable { case `default` case `defer` case `deinit` + @_spi(ExperimentalLanguageFeatures) + case dependsOn case deprecated case derivative case didSet @@ -201,6 +197,8 @@ public enum Keyword: UInt8, Hashable, Sendable { case reverse case right case safe + @_spi(ExperimentalLanguageFeatures) + case scoped case `self` case `Self` case Sendable @@ -343,8 +341,6 @@ public enum Keyword: UInt8, Hashable, Sendable { } case 5: switch text { - case "_copy": - self = ._copy case "_move": self = ._move case "_read": @@ -428,6 +424,8 @@ public enum Keyword: UInt8, Hashable, Sendable { self = .repeat case "return": self = .return + case "scoped": + self = .scoped case "static": self = .static case "struct": @@ -455,8 +453,6 @@ public enum Keyword: UInt8, Hashable, Sendable { self = ._linear case "_modify": self = ._modify - case "_mutate": - self = ._mutate case "consume": self = .consume case "default": @@ -494,8 +490,6 @@ public enum Keyword: UInt8, Hashable, Sendable { switch text { case "__shared": self = .__shared - case "_consume": - self = ._consume case "_effects": self = ._effects case "_forward": @@ -563,6 +557,8 @@ public enum Keyword: UInt8, Hashable, Sendable { self = .canImport case "consuming": self = .consuming + case "dependsOn": + self = .dependsOn case "extension": self = .extension case "lowerThan": @@ -826,9 +822,7 @@ public enum Keyword: UInt8, Hashable, Sendable { "_Class", "_compilerInitialized", "_const", - "_consume", "_consuming", - "_copy", "_documentation", "_dynamicReplacement", "_effects", @@ -839,7 +833,6 @@ public enum Keyword: UInt8, Hashable, Sendable { "_local", "_modify", "_move", - "_mutate", "_mutating", "_NativeClass", "_NativeRefCountedObject", @@ -904,6 +897,7 @@ public enum Keyword: UInt8, Hashable, Sendable { "default", "defer", "deinit", + "dependsOn", "deprecated", "derivative", "didSet", @@ -993,6 +987,7 @@ public enum Keyword: UInt8, Hashable, Sendable { "reverse", "right", "safe", + "scoped", "self", "Self", "Sendable", diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index 83c8529f9a2..e842583feb6 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -779,7 +779,7 @@ extension LabeledSpecializeArgumentSyntax: WithTrailingCommaSyntax {} extension LifetimeSpecifierArgumentSyntax: WithTrailingCommaSyntax {} -extension LifetimeSpecifierArgumentsSyntax: ParenthesizedSyntax {} +extension LifetimeTypeSpecifierSyntax: ParenthesizedSyntax {} extension MacroDeclSyntax: NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift index d5e9ab34c9d..56087afd1f9 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift @@ -1082,55 +1082,31 @@ public struct RawLifetimeSpecifierArgumentsSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeArguments: RawUnexpectedNodesSyntax? = nil, arguments: RawLifetimeSpecifierArgumentListSyntax, - _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedAfterArguments: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .lifetimeSpecifierArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .lifetimeSpecifierArguments, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftParen?.raw - layout[1] = leftParen.raw - layout[2] = unexpectedBetweenLeftParenAndArguments?.raw - layout[3] = arguments.raw - layout[4] = unexpectedBetweenArgumentsAndRightParen?.raw - layout[5] = rightParen.raw - layout[6] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforeArguments?.raw + layout[1] = arguments.raw + layout[2] = unexpectedAfterArguments?.raw } self.init(unchecked: raw) } - public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeArguments: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - - public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var arguments: RawLifetimeSpecifierArgumentListSyntax { - layoutView.children[3].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))! - } - - public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - - public var rightParen: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + layoutView.children[1].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))! } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } } @@ -1167,44 +1143,80 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, - specifier: RawTokenSyntax, - _ unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDependsOnKeyword: RawUnexpectedNodesSyntax? = nil, + dependsOnKeyword: RawTokenSyntax, + _ unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? = nil, + scopedKeyword: RawTokenSyntax?, + _ unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? = nil, arguments: RawLifetimeSpecifierArgumentsSyntax, - _ unexpectedAfterArguments: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .lifetimeTypeSpecifier, uninitializedCount: 5, arena: arena) { layout in + kind: .lifetimeTypeSpecifier, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeSpecifier?.raw - layout[1] = specifier.raw - layout[2] = unexpectedBetweenSpecifierAndArguments?.raw - layout[3] = arguments.raw - layout[4] = unexpectedAfterArguments?.raw + layout[0] = unexpectedBeforeDependsOnKeyword?.raw + layout[1] = dependsOnKeyword.raw + layout[2] = unexpectedBetweenDependsOnKeywordAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndScopedKeyword?.raw + layout[5] = scopedKeyword?.raw + layout[6] = unexpectedBetweenScopedKeywordAndArguments?.raw + layout[7] = arguments.raw + layout[8] = unexpectedBetweenArgumentsAndRightParen?.raw + layout[9] = rightParen.raw + layout[10] = unexpectedAfterRightParen?.raw } self.init(unchecked: raw) } - public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeDependsOnKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var specifier: RawTokenSyntax { + public var dependsOnKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var arguments: RawLifetimeSpecifierArgumentsSyntax { - layoutView.children[3].map(RawLifetimeSpecifierArgumentsSyntax.init(raw:))! + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var scopedKeyword: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var arguments: RawLifetimeSpecifierArgumentsSyntax { + layoutView.children[7].map(RawLifetimeSpecifierArgumentsSyntax.init(raw:))! + } + + public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var rightParen: RawTokenSyntax { + layoutView.children[9].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 8d22721337f..7a685aa4bb8 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -1726,26 +1726,23 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .lifetimeSpecifierArguments: - assert(layout.count == 7) + assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) + assertNoError(kind, 1, verify(layout[1], as: RawLifetimeSpecifierArgumentListSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawLifetimeSpecifierArgumentListSyntax.self)) - 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 .lifetimeTypeSpecifier: - assert(layout.count == 5) + assert(layout.count == 11) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [ - .keyword("_copy"), - .keyword("_consume"), - .keyword("_borrow"), - .keyword("_mutate") - ])) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("dependsOn")])) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawLifetimeSpecifierArgumentsSyntax.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: RawTokenSyntax?.self, tokenChoices: [.keyword("scoped")])) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawLifetimeSpecifierArgumentsSyntax.self)) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)])) + assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) case .macroDecl: assert(layout.count == 17) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift index 605ea5af339..9f02ec31ce5 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift @@ -1801,9 +1801,7 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ /// /// ### Children /// -/// - `leftParen`: `(` /// - `arguments`: `LifetimeSpecifierArgumentListSyntax` -/// - `rightParen`: `)` #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif @@ -1823,36 +1821,16 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, /// - 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, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeArguments: UnexpectedNodesSyntax? = nil, arguments: LifetimeSpecifierArgumentListSyntax, - _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterArguments: 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(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeArguments, arguments, unexpectedAfterArguments))) { (arena, _) in + let layout: [RawSyntax?] = [unexpectedBeforeArguments?.raw, arguments.raw, unexpectedAfterArguments?.raw] let raw = RawSyntax.makeLayout( kind: SyntaxKind.lifetimeSpecifierArguments, from: layout, @@ -1865,7 +1843,7 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, } } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeArguments: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } @@ -1874,34 +1852,13 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, } } - /// ### Tokens - /// - /// For syntax trees generated by the parser, this is guaranteed to be `(`. - public var leftParen: TokenSyntax { - get { - return Syntax(self).child(at: 1)!.cast(TokenSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self) - } - } - - public var unexpectedBetweenLeftParenAndArguments: 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(LifetimeSpecifierArgumentsSyntax.self) - } - } - /// The function parameters that the lifetime of the annotated type depends on. public var arguments: LifetimeSpecifierArgumentListSyntax { get { - return Syntax(self).child(at: 3)!.cast(LifetimeSpecifierArgumentListSyntax.self) + return Syntax(self).child(at: 1)!.cast(LifetimeSpecifierArgumentListSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self) } } @@ -1916,7 +1873,7 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, public func addArguments(_ element: LifetimeSpecifierArgumentSyntax) -> LifetimeSpecifierArgumentsSyntax { var collection: RawSyntax let arena = SyntaxArena() - if let col = raw.layoutView!.children[3] { + if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.lifetimeSpecifierArgumentList, @@ -1924,7 +1881,7 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, } return Syntax(self) .replacingChild( - at: 3, + at: 1, with: collection, rawNodeArena: arena, allocationArena: arena @@ -1932,46 +1889,17 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, .cast(LifetimeSpecifierArgumentsSyntax.self) } - public var unexpectedBetweenArgumentsAndRightParen: 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(LifetimeSpecifierArgumentsSyntax.self) - } - } - - /// ### Tokens - /// - /// For syntax trees generated by the parser, this is guaranteed to be `)`. - public var rightParen: 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(LifetimeSpecifierArgumentsSyntax.self) - } - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterArguments: UnexpectedNodesSyntax? { get { - return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self) } } public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndArguments, - \Self.arguments, - \Self.unexpectedBetweenArgumentsAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen - ]) + return .layout([\Self.unexpectedBeforeArguments, \Self.arguments, \Self.unexpectedAfterArguments]) } } @@ -1983,8 +1911,11 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, /// /// ### Children /// -/// - `specifier`: (`_copy` | `_consume` | `_borrow` | `_mutate`) +/// - `dependsOnKeyword`: `dependsOn` +/// - `leftParen`: `(` +/// - `scopedKeyword`: `scoped`? /// - `arguments`: `LifetimeSpecifierArgumentsSyntax` +/// - `rightParen`: `)` /// /// ### Contained in /// @@ -2004,33 +1935,51 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// - 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. - /// - specifier: The specifier token that's attached to the type. + /// - dependsOnKeyword: The specifier token that's attached to the 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, - _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: TokenSyntax, - _ unexpectedBetweenSpecifierAndArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? = nil, + dependsOnKeyword: TokenSyntax = .keyword(.dependsOn), + _ unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? = nil, + scopedKeyword: TokenSyntax? = nil, + _ unexpectedBetweenScopedKeywordAndArguments: UnexpectedNodesSyntax? = nil, arguments: LifetimeSpecifierArgumentsSyntax, - _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenArgumentsAndRightParen: 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. self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeSpecifier, - specifier, - unexpectedBetweenSpecifierAndArguments, + unexpectedBeforeDependsOnKeyword, + dependsOnKeyword, + unexpectedBetweenDependsOnKeywordAndLeftParen, + leftParen, + unexpectedBetweenLeftParenAndScopedKeyword, + scopedKeyword, + unexpectedBetweenScopedKeywordAndArguments, arguments, - unexpectedAfterArguments + unexpectedBetweenArgumentsAndRightParen, + rightParen, + unexpectedAfterRightParen ))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifier?.raw, - specifier.raw, - unexpectedBetweenSpecifierAndArguments?.raw, + unexpectedBeforeDependsOnKeyword?.raw, + dependsOnKeyword.raw, + unexpectedBetweenDependsOnKeywordAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndScopedKeyword?.raw, + scopedKeyword?.raw, + unexpectedBetweenScopedKeywordAndArguments?.raw, arguments.raw, - unexpectedAfterArguments?.raw + unexpectedBetweenArgumentsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.lifetimeTypeSpecifier, @@ -2044,7 +1993,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } @@ -2057,12 +2006,8 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// /// ### Tokens /// - /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds: - /// - `_copy` - /// - `_consume` - /// - `_borrow` - /// - `_mutate` - public var specifier: TokenSyntax { + /// For syntax trees generated by the parser, this is guaranteed to be `dependsOn`. + public var dependsOnKeyword: TokenSyntax { get { return Syntax(self).child(at: 1)!.cast(TokenSyntax.self) } @@ -2071,7 +2016,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - public var unexpectedBetweenSpecifierAndArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } @@ -2080,16 +2025,19 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - public var arguments: LifetimeSpecifierArgumentsSyntax { + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `(`. + public var leftParen: TokenSyntax { get { - return Syntax(self).child(at: 3)!.cast(LifetimeSpecifierArgumentsSyntax.self) + return Syntax(self).child(at: 3)!.cast(TokenSyntax.self) } set(value) { self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self) } } - public var unexpectedAfterArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -2098,13 +2046,79 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `scoped`. + public var scopedKeyword: 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(LifetimeTypeSpecifierSyntax.self) + } + } + + public var unexpectedBetweenScopedKeywordAndArguments: 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(LifetimeTypeSpecifierSyntax.self) + } + } + + public var arguments: LifetimeSpecifierArgumentsSyntax { + get { + return Syntax(self).child(at: 7)!.cast(LifetimeSpecifierArgumentsSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self) + } + } + + public var unexpectedBetweenArgumentsAndRightParen: 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(LifetimeTypeSpecifierSyntax.self) + } + } + + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `)`. + public var rightParen: TokenSyntax { + get { + return Syntax(self).child(at: 9)!.cast(TokenSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self) + } + } + + public var unexpectedAfterRightParen: 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(LifetimeTypeSpecifierSyntax.self) + } + } + public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeSpecifier, - \Self.specifier, - \Self.unexpectedBetweenSpecifierAndArguments, + \Self.unexpectedBeforeDependsOnKeyword, + \Self.dependsOnKeyword, + \Self.unexpectedBetweenDependsOnKeywordAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndScopedKeyword, + \Self.scopedKeyword, + \Self.unexpectedBetweenScopedKeywordAndArguments, \Self.arguments, - \Self.unexpectedAfterArguments + \Self.unexpectedBetweenArgumentsAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen ]) } } diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index 30ed2f2e096..19759906dcd 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -3286,7 +3286,7 @@ final class DeclarationTests: ParserTestCase { func testInitializerWithReturnType() { assertParse( - "init(_ ptr: UnsafeRawBufferPointer, _ a: borrowing Array) -> _borrow(a) Self", + "init(_ ptr: UnsafeRawBufferPointer, _ a: borrowing Array) -> dependsOn(a) Self", experimentalFeatures: .nonescapableTypes ) diff --git a/Tests/SwiftParserTest/TypeTests.swift b/Tests/SwiftParserTest/TypeTests.swift index 936ef5f817a..5e5f503c5c3 100644 --- a/Tests/SwiftParserTest/TypeTests.swift +++ b/Tests/SwiftParserTest/TypeTests.swift @@ -331,12 +331,12 @@ final class TypeTests: ParserTestCase { } func testLifetimeSpecifier() { - assertParse("func foo() -> _borrow(x) X", experimentalFeatures: [.nonescapableTypes]) + assertParse("func foo() -> dependsOn(x) X", experimentalFeatures: [.nonescapableTypes]) - assertParse("func foo() -> _borrow(x, y) X", experimentalFeatures: [.nonescapableTypes]) + assertParse("func foo() -> dependsOn(x, y) X", experimentalFeatures: [.nonescapableTypes]) assertParse( - "func foo() -> _borrow(1️⃣) X", + "func foo() -> dependsOn(1️⃣) X", diagnostics: [ DiagnosticSpec( locationMarker: "1️⃣", @@ -344,12 +344,12 @@ final class TypeTests: ParserTestCase { fixIts: ["insert parameter reference"] ) ], - fixedSource: "func foo() -> _borrow(<#identifier#>) X", + fixedSource: "func foo() -> dependsOn(<#identifier#>) X", experimentalFeatures: [.nonescapableTypes] ) assertParse( - "func foo() -> _borrow(x,1️⃣) X", + "func foo() -> dependsOn(x,1️⃣) X", diagnostics: [ DiagnosticSpec( locationMarker: "1️⃣", @@ -357,20 +357,16 @@ final class TypeTests: ParserTestCase { fixIts: ["insert parameter reference"] ) ], - fixedSource: "func foo() -> _borrow(x, <#identifier#>) X", + fixedSource: "func foo() -> dependsOn(x, <#identifier#>) X", experimentalFeatures: [.nonescapableTypes] ) - assertParse("func foo() -> _borrow(x) _borrow(y) X", experimentalFeatures: [.nonescapableTypes]) + assertParse("func foo() -> dependsOn(x) dependsOn(scoped y) X", experimentalFeatures: [.nonescapableTypes]) - assertParse("func foo() -> _mutate(x) X", experimentalFeatures: [.nonescapableTypes]) - - assertParse("func foo() -> _copy(x) X", experimentalFeatures: [.nonescapableTypes]) - - assertParse("func foo() -> _consume(x) X", experimentalFeatures: [.nonescapableTypes]) + assertParse("func foo() -> dependsOn(scoped x) X", experimentalFeatures: [.nonescapableTypes]) assertParse( - "func foo() -> _borrow 1️⃣X", + "func foo() -> dependsOn 1️⃣X", diagnostics: [ DiagnosticSpec( locationMarker: "1️⃣", @@ -378,12 +374,12 @@ final class TypeTests: ParserTestCase { fixIts: ["insert '(', parameter reference, and ')'"] ) ], - fixedSource: "func foo() -> _borrow (<#identifier#>) X", + fixedSource: "func foo() -> dependsOn (<#identifier#>) X", experimentalFeatures: [.nonescapableTypes] ) assertParse( - "func foo() -> _borrow(1️⃣*) X", + "func foo() -> dependsOn(1️⃣*) X", diagnostics: [ DiagnosticSpec( locationMarker: "1️⃣", @@ -392,16 +388,16 @@ final class TypeTests: ParserTestCase { ), DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '*' in lifetime specifier"), ], - fixedSource: "func foo() -> _borrow(<#identifier#>*) X", + fixedSource: "func foo() -> dependsOn(<#identifier#>*) X", experimentalFeatures: [.nonescapableTypes] ) - assertParse("func foo() -> _borrow(0) X", diagnostics: [], experimentalFeatures: [.nonescapableTypes]) + assertParse("func foo() -> dependsOn(0) X", diagnostics: [], experimentalFeatures: [.nonescapableTypes]) - assertParse("func foo() -> _borrow(self) X", experimentalFeatures: [.nonescapableTypes]) + assertParse("func foo() -> dependsOn(self) X", experimentalFeatures: [.nonescapableTypes]) assertParse( - "func foo() -> _borrow1️⃣(0)2️⃣ X", + "func foo() -> dependsOn1️⃣(0)2️⃣ X", diagnostics: [ DiagnosticSpec( locationMarker: "1️⃣", @@ -415,14 +411,14 @@ final class TypeTests: ParserTestCase { ), ], fixedSource: """ - func foo() -> _borrow + func foo() -> dependsOn (0) X """ ) assertParse( - "func foo() -> _borrow(1️⃣-1) X", + "func foo() -> dependsOn(1️⃣-1) X", diagnostics: [ DiagnosticSpec( message: "expected parameter reference in lifetime specifier", @@ -430,7 +426,7 @@ final class TypeTests: ParserTestCase { ), DiagnosticSpec(message: "unexpected code '-1' in lifetime specifier"), ], - fixedSource: "func foo() -> _borrow(<#identifier#>-1) X", + fixedSource: "func foo() -> dependsOn(<#identifier#>-1) X", experimentalFeatures: [.nonescapableTypes] ) } From d216b0cff6381a898b6b3233fe717bae44c53d88 Mon Sep 17 00:00:00 2001 From: Meghana Gupta Date: Tue, 26 Mar 2024 03:55:33 -0700 Subject: [PATCH 2/2] Merge pull request #2567 from apple/followup Follow up of #2564 --- .../Sources/SyntaxSupport/TypeNodes.swift | 30 +--- .../ValidateSyntaxNodes.swift | 1 + Sources/SwiftParser/Types.swift | 29 ++-- .../generated/ChildNameForKeyPath.swift | 6 - .../generated/SyntaxAnyVisitor.swift | 14 -- .../generated/SyntaxBaseNodes.swift | 1 - .../SwiftSyntax/generated/SyntaxEnum.swift | 6 - .../SwiftSyntax/generated/SyntaxKind.swift | 6 - .../generated/SyntaxRewriter.swift | 16 -- .../SwiftSyntax/generated/SyntaxTraits.swift | 2 - .../SwiftSyntax/generated/SyntaxVisitor.swift | 24 --- .../generated/raw/RawSyntaxNodesJKLMN.swift | 67 +------- .../generated/raw/RawSyntaxValidation.swift | 7 +- .../syntaxNodes/SyntaxNodesJKLMN.swift | 155 ++++-------------- 14 files changed, 56 insertions(+), 308 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift index 2658b4e0b3f..f89ddb531d9 100644 --- a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift @@ -542,42 +542,17 @@ public let TYPE_NODES: [Node] = [ elementChoices: [.lifetimeSpecifierArgument] ), - Node( - kind: .lifetimeSpecifierArguments, - base: .syntax, - experimentalFeature: .nonescapableTypes, - nameForDiagnostics: nil, - documentation: """ - An optional argument passed to a type parameter. - - ### Example - `borrow(data)` in `func foo(data: Array) -> borrow(data) ComplexReferenceType` - """, - children: [ - Child( - name: "arguments", - kind: .collection(kind: .lifetimeSpecifierArgumentList, collectionElementName: "Arguments"), - documentation: """ - The function parameters that the lifetime of the annotated type depends on. - """ - ) - ] - ), - Node( kind: .lifetimeTypeSpecifier, base: .syntax, experimentalFeature: .nonescapableTypes, nameForDiagnostics: "lifetime specifier", documentation: "A specifier that specifies function parameter on whose lifetime a type depends", - traits: [ - "Parenthesized" - ], children: [ Child( name: "dependsOnKeyword", kind: .token(choices: [.keyword(.dependsOn)]), - documentation: "The specifier token that's attached to the type." + documentation: "lifetime dependence specifier on the return type" ), Child( name: "leftParen", @@ -586,11 +561,12 @@ public let TYPE_NODES: [Node] = [ Child( name: "scopedKeyword", kind: .token(choices: [.keyword(.scoped)]), + documentation: "lifetime of return value is scoped to the lifetime of the original value", isOptional: true ), Child( name: "arguments", - kind: .node(kind: .lifetimeSpecifierArguments) + kind: .collection(kind: .lifetimeSpecifierArgumentList, collectionElementName: "Arguments") ), Child( name: "rightParen", diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift index 49028b06247..0decc847b3a 100644 --- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift +++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift @@ -550,6 +550,7 @@ class ValidateSyntaxNodes: XCTestCase { node: .yieldedExpressionsClause, message: "could conform to trait 'Parenthesized' but does not" ), + ValidationFailure(node: .lifetimeTypeSpecifier, message: "could conform to trait 'Parenthesized' but does not"), ] ) } diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift index 99958f0deae..0c1102dabf2 100644 --- a/Sources/SwiftParser/Types.swift +++ b/Sources/SwiftParser/Types.swift @@ -901,25 +901,23 @@ extension Parser.Lookahead { extension Parser { private mutating func parseLifetimeTypeSpecifier() -> RawTypeSpecifierListSyntax.Element { - let specifier = self.eat(TokenSpec(.dependsOn)) + let (unexpectedBeforeDependsOnKeyword, dependsOnKeyword) = self.expect(.keyword(.dependsOn)) guard let leftParen = self.consume(if: .leftParen) else { // If there is no left paren, add an entirely missing detail. Otherwise, we start to consume the following type // name as a token inside the detail, which leads to confusing recovery results. - let arguments = RawLifetimeSpecifierArgumentsSyntax( - arguments: RawLifetimeSpecifierArgumentListSyntax( - elements: [ - RawLifetimeSpecifierArgumentSyntax(parameter: missingToken(.identifier), trailingComma: nil, arena: arena) - ], - arena: self.arena - ), + let lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax( + elements: [ + RawLifetimeSpecifierArgumentSyntax(parameter: missingToken(.identifier), trailingComma: nil, arena: arena) + ], arena: self.arena ) let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax( - dependsOnKeyword: specifier, + unexpectedBeforeDependsOnKeyword, + dependsOnKeyword: dependsOnKeyword, leftParen: missingToken(.leftParen), scopedKeyword: nil, - arguments: arguments, + arguments: lifetimeSpecifierArgumentList, rightParen: missingToken(.rightParen), arena: self.arena ) @@ -947,15 +945,12 @@ extension Parser { } while keepGoing != nil && self.hasProgressed(&loopProgress) let lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax(elements: arguments, arena: self.arena) let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) - let argumentsSyntax = RawLifetimeSpecifierArgumentsSyntax( - arguments: lifetimeSpecifierArgumentList, - arena: self.arena - ) let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax( - dependsOnKeyword: specifier, + unexpectedBeforeDependsOnKeyword, + dependsOnKeyword: dependsOnKeyword, leftParen: leftParen, scopedKeyword: scoped, - arguments: argumentsSyntax, + arguments: lifetimeSpecifierArgumentList, unexpectedBeforeRightParen, rightParen: rightParen, arena: self.arena @@ -981,7 +976,7 @@ extension Parser { SPECIFIER_PARSING: while canHaveParameterSpecifier { if let (_, specifierHandle) = self.at(anyIn: SimpleTypeSpecifierSyntax.SpecifierOptions.self) { specifiers.append(parseSimpleTypeSpecifier(specifierHandle: specifierHandle)) - } else if self.at(TokenSpec(.dependsOn)) { + } else if self.at(.keyword(.dependsOn)) { if self.experimentalFeatures.contains(.nonescapableTypes) { specifiers.append(parseLifetimeTypeSpecifier()) } else { diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index b2666dca2a3..adec42bc2ca 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -2009,12 +2009,6 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "trailingComma" case \LifetimeSpecifierArgumentSyntax.unexpectedAfterTrailingComma: return "unexpectedAfterTrailingComma" - case \LifetimeSpecifierArgumentsSyntax.unexpectedBeforeArguments: - return "unexpectedBeforeArguments" - case \LifetimeSpecifierArgumentsSyntax.arguments: - return "arguments" - case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterArguments: - return "unexpectedAfterArguments" case \LifetimeTypeSpecifierSyntax.unexpectedBeforeDependsOnKeyword: return "unexpectedBeforeDependsOnKeyword" case \LifetimeTypeSpecifierSyntax.dependsOnKeyword: diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 17eb0b51b3e..83bef83ebef 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -1374,20 +1374,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } - #if compiler(>=5.8) - @_spi(ExperimentalLanguageFeatures) - #endif - override open func visit(_ node: LifetimeSpecifierArgumentsSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - #if compiler(>=5.8) - @_spi(ExperimentalLanguageFeatures) - #endif - override open func visitPost(_ node: LifetimeSpecifierArgumentsSyntax) { - visitAnyPost(node._syntaxNode) - } - #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index 7ff75ce92c4..e5cd0600dc2 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -1681,7 +1681,6 @@ extension Syntax { .node(LayoutRequirementSyntax.self), .node(LifetimeSpecifierArgumentListSyntax.self), .node(LifetimeSpecifierArgumentSyntax.self), - .node(LifetimeSpecifierArgumentsSyntax.self), .node(LifetimeTypeSpecifierSyntax.self), .node(MacroDeclSyntax.self), .node(MacroExpansionDeclSyntax.self), diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index cf24a56b678..0654f834647 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -191,10 +191,6 @@ public enum SyntaxEnum: Sendable { #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif - case lifetimeSpecifierArguments(LifetimeSpecifierArgumentsSyntax) - #if compiler(>=5.8) - @_spi(ExperimentalLanguageFeatures) - #endif case lifetimeTypeSpecifier(LifetimeTypeSpecifierSyntax) case macroDecl(MacroDeclSyntax) case macroExpansionDecl(MacroExpansionDeclSyntax) @@ -651,8 +647,6 @@ public extension Syntax { return .lifetimeSpecifierArgumentList(LifetimeSpecifierArgumentListSyntax(self)!) case .lifetimeSpecifierArgument: return .lifetimeSpecifierArgument(LifetimeSpecifierArgumentSyntax(self)!) - case .lifetimeSpecifierArguments: - return .lifetimeSpecifierArguments(LifetimeSpecifierArgumentsSyntax(self)!) case .lifetimeTypeSpecifier: return .lifetimeTypeSpecifier(LifetimeTypeSpecifierSyntax(self)!) case .macroDecl: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index 3724843f407..05829bf445b 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -191,10 +191,6 @@ public enum SyntaxKind: Sendable { #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif - case lifetimeSpecifierArguments - #if compiler(>=5.8) - @_spi(ExperimentalLanguageFeatures) - #endif case lifetimeTypeSpecifier case macroDecl case macroExpansionDecl @@ -776,8 +772,6 @@ public enum SyntaxKind: Sendable { return LifetimeSpecifierArgumentListSyntax.self case .lifetimeSpecifierArgument: return LifetimeSpecifierArgumentSyntax.self - case .lifetimeSpecifierArguments: - return LifetimeSpecifierArgumentsSyntax.self case .lifetimeTypeSpecifier: return LifetimeTypeSpecifierSyntax.self case .macroDecl: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index e3b3b26d480..7a2bb82f013 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -1225,16 +1225,6 @@ open class SyntaxRewriter { return visitChildren(node) } - /// Visit a `LifetimeSpecifierArgumentsSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - #if compiler(>=5.8) - @_spi(ExperimentalLanguageFeatures) - #endif - open func visit(_ node: LifetimeSpecifierArgumentsSyntax) -> LifetimeSpecifierArgumentsSyntax { - return visitChildren(node) - } - /// Visit a `LifetimeTypeSpecifierSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2820,10 +2810,6 @@ open class SyntaxRewriter { return { self.visitImpl($0, LifetimeSpecifierArgumentSyntax.self, self.visit) } - case .lifetimeSpecifierArguments: - return { - self.visitImpl($0, LifetimeSpecifierArgumentsSyntax.self, self.visit) - } case .lifetimeTypeSpecifier: return { self.visitImpl($0, LifetimeTypeSpecifierSyntax.self, self.visit) @@ -3642,8 +3628,6 @@ open class SyntaxRewriter { return visitImpl(node, LifetimeSpecifierArgumentListSyntax.self, visit) case .lifetimeSpecifierArgument: return visitImpl(node, LifetimeSpecifierArgumentSyntax.self, visit) - case .lifetimeSpecifierArguments: - return visitImpl(node, LifetimeSpecifierArgumentsSyntax.self, visit) case .lifetimeTypeSpecifier: return visitImpl(node, LifetimeTypeSpecifierSyntax.self, visit) case .macroDecl: diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index e842583feb6..1034e136ffc 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -779,8 +779,6 @@ extension LabeledSpecializeArgumentSyntax: WithTrailingCommaSyntax {} extension LifetimeSpecifierArgumentSyntax: WithTrailingCommaSyntax {} -extension LifetimeTypeSpecifierSyntax: ParenthesizedSyntax {} - extension MacroDeclSyntax: NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {} extension MacroExpansionDeclSyntax: FreestandingMacroExpansionSyntax, WithAttributesSyntax, WithModifiersSyntax {} diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index 80a4de49214..4468b10c27b 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -2019,24 +2019,6 @@ open class SyntaxVisitor { open func visitPost(_ node: LifetimeSpecifierArgumentSyntax) { } - /// Visiting `LifetimeSpecifierArgumentsSyntax` 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: LifetimeSpecifierArgumentsSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `LifetimeSpecifierArgumentsSyntax` and its descendants. - /// - node: the node we just finished visiting. - #if compiler(>=5.8) - @_spi(ExperimentalLanguageFeatures) - #endif - open func visitPost(_ node: LifetimeSpecifierArgumentsSyntax) { - } - /// Visiting `LifetimeTypeSpecifierSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -4220,10 +4202,6 @@ open class SyntaxVisitor { return { self.visitImpl(&$0, LifetimeSpecifierArgumentSyntax.self, self.visit, self.visitPost) } - case .lifetimeSpecifierArguments: - return { - self.visitImpl(&$0, LifetimeSpecifierArgumentsSyntax.self, self.visit, self.visitPost) - } case .lifetimeTypeSpecifier: return { self.visitImpl(&$0, LifetimeTypeSpecifierSyntax.self, self.visit, self.visitPost) @@ -5046,8 +5024,6 @@ open class SyntaxVisitor { visitImpl(&node, LifetimeSpecifierArgumentListSyntax.self, visit, visitPost) case .lifetimeSpecifierArgument: visitImpl(&node, LifetimeSpecifierArgumentSyntax.self, visit, visitPost) - case .lifetimeSpecifierArguments: - visitImpl(&node, LifetimeSpecifierArgumentsSyntax.self, visit, visitPost) case .lifetimeTypeSpecifier: visitImpl(&node, LifetimeTypeSpecifierSyntax.self, visit, visitPost) case .macroDecl: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift index 56087afd1f9..18adc64115b 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift @@ -1049,67 +1049,6 @@ public struct RawLifetimeSpecifierArgumentSyntax: RawSyntaxNodeProtocol { } } -#if compiler(>=5.8) -@_spi(ExperimentalLanguageFeatures) -#endif -@_spi(RawSyntax) -public struct RawLifetimeSpecifierArgumentsSyntax: RawSyntaxNodeProtocol { - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .lifetimeSpecifierArguments - } - - 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( - _ unexpectedBeforeArguments: RawUnexpectedNodesSyntax? = nil, - arguments: RawLifetimeSpecifierArgumentListSyntax, - _ unexpectedAfterArguments: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .lifetimeSpecifierArguments, uninitializedCount: 3, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeArguments?.raw - layout[1] = arguments.raw - layout[2] = unexpectedAfterArguments?.raw - } - self.init(unchecked: raw) - } - - public var unexpectedBeforeArguments: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - - public var arguments: RawLifetimeSpecifierArgumentListSyntax { - layoutView.children[1].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))! - } - - public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - #if compiler(>=5.8) @_spi(ExperimentalLanguageFeatures) #endif @@ -1150,7 +1089,7 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { _ unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? = nil, scopedKeyword: RawTokenSyntax?, _ unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? = nil, - arguments: RawLifetimeSpecifierArgumentsSyntax, + arguments: RawLifetimeSpecifierArgumentListSyntax, _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, rightParen: RawTokenSyntax, _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, @@ -1202,8 +1141,8 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var arguments: RawLifetimeSpecifierArgumentsSyntax { - layoutView.children[7].map(RawLifetimeSpecifierArgumentsSyntax.init(raw:))! + public var arguments: RawLifetimeSpecifierArgumentListSyntax { + layoutView.children[7].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))! } public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 7a685aa4bb8..31ef04df6dd 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -1725,11 +1725,6 @@ 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 .lifetimeSpecifierArguments: - assert(layout.count == 3) - assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawLifetimeSpecifierArgumentListSyntax.self)) - assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) case .lifetimeTypeSpecifier: assert(layout.count == 11) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1739,7 +1734,7 @@ 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("scoped")])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 7, verify(layout[7], as: RawLifetimeSpecifierArgumentsSyntax.self)) + assertNoError(kind, 7, verify(layout[7], as: RawLifetimeSpecifierArgumentListSyntax.self)) assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)])) assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift index 9f02ec31ce5..9db4ef199ab 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift @@ -1790,119 +1790,6 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ } } -// MARK: - LifetimeSpecifierArgumentsSyntax - -/// An optional argument passed to a type parameter. -/// -/// ### Example -/// `borrow(data)` in `func foo(data: Array) -> borrow(data) ComplexReferenceType` -/// -/// - Experiment: Requires experimental feature `nonescapableTypes`. -/// -/// ### Children -/// -/// - `arguments`: `LifetimeSpecifierArgumentListSyntax` -#if compiler(>=5.8) -@_spi(ExperimentalLanguageFeatures) -#endif -public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { - public let _syntaxNode: Syntax - - public init?(_ node: some SyntaxProtocol) { - guard node.raw.kind == .lifetimeSpecifierArguments 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. - /// - arguments: The function parameters that the lifetime of the annotated type depends on. - /// - 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, - _ unexpectedBeforeArguments: UnexpectedNodesSyntax? = nil, - arguments: LifetimeSpecifierArgumentListSyntax, - _ unexpectedAfterArguments: 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(), (unexpectedBeforeArguments, arguments, unexpectedAfterArguments))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeArguments?.raw, arguments.raw, unexpectedAfterArguments?.raw] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.lifetimeSpecifierArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - - ) - return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) - } - } - - public var unexpectedBeforeArguments: 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(LifetimeSpecifierArgumentsSyntax.self) - } - } - - /// The function parameters that the lifetime of the annotated type depends on. - public var arguments: LifetimeSpecifierArgumentListSyntax { - get { - return Syntax(self).child(at: 1)!.cast(LifetimeSpecifierArgumentListSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self) - } - } - - /// Adds the provided `element` to the node's `arguments` - /// collection. - /// - /// - param element: The new `Arguments` to add to the node's - /// `arguments` collection. - /// - returns: A copy of the receiver with the provided `Arguments` - /// appended to its `arguments` collection. - @available(*, deprecated, message: "Use node.arguments.append(newElement) instead") - public func addArguments(_ element: LifetimeSpecifierArgumentSyntax) -> LifetimeSpecifierArgumentsSyntax { - 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.lifetimeSpecifierArgumentList, - from: [element.raw], arena: arena) - } - return Syntax(self) - .replacingChild( - at: 1, - with: collection, - rawNodeArena: arena, - allocationArena: arena - ) - .cast(LifetimeSpecifierArgumentsSyntax.self) - } - - public var unexpectedAfterArguments: 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(LifetimeSpecifierArgumentsSyntax.self) - } - } - - public static var structure: SyntaxNodeStructure { - return .layout([\Self.unexpectedBeforeArguments, \Self.arguments, \Self.unexpectedAfterArguments]) - } -} - // MARK: - LifetimeTypeSpecifierSyntax /// A specifier that specifies function parameter on whose lifetime a type depends @@ -1914,7 +1801,7 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, /// - `dependsOnKeyword`: `dependsOn` /// - `leftParen`: `(` /// - `scopedKeyword`: `scoped`? -/// - `arguments`: `LifetimeSpecifierArgumentsSyntax` +/// - `arguments`: `LifetimeSpecifierArgumentListSyntax` /// - `rightParen`: `)` /// /// ### Contained in @@ -1935,7 +1822,8 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// - 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. - /// - dependsOnKeyword: The specifier token that's attached to the type. + /// - dependsOnKeyword: lifetime dependence specifier on the return type + /// - scopedKeyword: lifetime of return value is scoped to the lifetime of the original value /// - 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, @@ -1946,7 +1834,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf _ unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? = nil, scopedKeyword: TokenSyntax? = nil, _ unexpectedBetweenScopedKeywordAndArguments: UnexpectedNodesSyntax? = nil, - arguments: LifetimeSpecifierArgumentsSyntax, + arguments: LifetimeSpecifierArgumentListSyntax, _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax = .rightParenToken(), _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, @@ -2002,7 +1890,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - /// The specifier token that's attached to the type. + /// lifetime dependence specifier on the return type /// /// ### Tokens /// @@ -2046,6 +1934,8 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } + /// lifetime of return value is scoped to the lifetime of the original value + /// /// ### Tokens /// /// For syntax trees generated by the parser, this is guaranteed to be `scoped`. @@ -2067,15 +1957,42 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - public var arguments: LifetimeSpecifierArgumentsSyntax { + public var arguments: LifetimeSpecifierArgumentListSyntax { get { - return Syntax(self).child(at: 7)!.cast(LifetimeSpecifierArgumentsSyntax.self) + return Syntax(self).child(at: 7)!.cast(LifetimeSpecifierArgumentListSyntax.self) } set(value) { self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self) } } + /// Adds the provided `element` to the node's `arguments` + /// collection. + /// + /// - param element: The new `Arguments` to add to the node's + /// `arguments` collection. + /// - returns: A copy of the receiver with the provided `Arguments` + /// appended to its `arguments` collection. + @available(*, deprecated, message: "Use node.arguments.append(newElement) instead") + public func addArguments(_ element: LifetimeSpecifierArgumentSyntax) -> LifetimeTypeSpecifierSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[7] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.lifetimeSpecifierArgumentList, + from: [element.raw], arena: arena) + } + return Syntax(self) + .replacingChild( + at: 7, + with: collection, + rawNodeArena: arena, + allocationArena: arena + ) + .cast(LifetimeTypeSpecifierSyntax.self) + } + public var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)