From 8cc38d373877abc8e8526d68df2f91ffff9af425 Mon Sep 17 00:00:00 2001 From: Meghana Gupta Date: Fri, 22 Mar 2024 23:09:16 -0700 Subject: [PATCH 1/3] Update lifetime dependence syntax --- .../Sources/SyntaxSupport/KeywordSpec.swift | 6 + .../Sources/SyntaxSupport/TypeNodes.swift | 34 +-- Sources/SwiftParser/TokenPrecedence.swift | 2 +- Sources/SwiftParser/Types.swift | 35 ++- .../generated/Parser+TokenSpecSet.swift | 73 ------ .../generated/ChildNameForKeyPath.swift | 36 +-- Sources/SwiftSyntax/generated/Keyword.swift | 10 + .../SwiftSyntax/generated/SyntaxTraits.swift | 2 +- .../generated/raw/RawSyntaxNodesJKLMN.swift | 100 ++++---- .../generated/raw/RawSyntaxValidation.swift | 25 +- .../syntaxNodes/SyntaxNodesJKLMN.swift | 222 ++++++++++-------- Tests/SwiftParserTest/DeclarationTests.swift | 2 +- Tests/SwiftParserTest/TypeTests.swift | 40 ++-- 13 files changed, 277 insertions(+), 310 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift index 895411bace0..a71daaa5e37 100644 --- a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift +++ b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift @@ -186,6 +186,7 @@ public enum Keyword: CaseIterable { case `default` case `defer` case `deinit` + case dependsOn case deprecated case derivative case didSet @@ -275,6 +276,7 @@ public enum Keyword: CaseIterable { case reverse case right case safe + case scoped case `self` case `Self` case Sendable @@ -499,6 +501,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 +679,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..f4c5c019dce 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,34 @@ 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), + .keyword(.dependsOn) ]), documentation: "The specifier token that's attached to the type." ), + Child( + name: "leftParen", + kind: .token(choices: [.token(.leftParen)]) + ), + Child( + name: "scoped", + 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..307b5e5f3f8 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, ._consume, ._copy, ._mutate, .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..d83c0b2f56c 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, + leftParen: missingToken(.leftParen), + scoped: 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, + leftParen: leftParen, + scoped: 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..6c92ee267d9 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: - return "unexpectedBetweenArgumentsAndRightParen" - case \LifetimeSpecifierArgumentsSyntax.rightParen: - return "rightParen" - case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterRightParen: - return "unexpectedAfterRightParen" + case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterArguments: + return "unexpectedAfterArguments" case \LifetimeTypeSpecifierSyntax.unexpectedBeforeSpecifier: return "unexpectedBeforeSpecifier" case \LifetimeTypeSpecifierSyntax.specifier: return "specifier" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenSpecifierAndArguments: - return "unexpectedBetweenSpecifierAndArguments" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenSpecifierAndLeftParen: + return "unexpectedBetweenSpecifierAndLeftParen" + case \LifetimeTypeSpecifierSyntax.leftParen: + return "leftParen" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenLeftParenAndScoped: + return "unexpectedBetweenLeftParenAndScoped" + case \LifetimeTypeSpecifierSyntax.scoped: + return "scoped" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenScopedAndArguments: + return "unexpectedBetweenScopedAndArguments" case \LifetimeTypeSpecifierSyntax.arguments: return "arguments" - case \LifetimeTypeSpecifierSyntax.unexpectedAfterArguments: - return "unexpectedAfterArguments" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenArgumentsAndRightParen: + return "unexpectedBetweenArgumentsAndRightParen" + case \LifetimeTypeSpecifierSyntax.rightParen: + return "rightParen" + case \LifetimeTypeSpecifierSyntax.unexpectedAfterRightParen: + return "unexpectedAfterRightParen" case \MacroDeclSyntax.unexpectedBeforeAttributes: return "unexpectedBeforeAttributes" case \MacroDeclSyntax.attributes: diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift index c331f2f5716..924e4d4c84d 100644 --- a/Sources/SwiftSyntax/generated/Keyword.swift +++ b/Sources/SwiftSyntax/generated/Keyword.swift @@ -110,6 +110,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 +203,8 @@ public enum Keyword: UInt8, Hashable, Sendable { case reverse case right case safe + @_spi(ExperimentalLanguageFeatures) + case scoped case `self` case `Self` case Sendable @@ -428,6 +432,8 @@ public enum Keyword: UInt8, Hashable, Sendable { self = .repeat case "return": self = .return + case "scoped": + self = .scoped case "static": self = .static case "struct": @@ -563,6 +569,8 @@ public enum Keyword: UInt8, Hashable, Sendable { self = .canImport case "consuming": self = .consuming + case "dependsOn": + self = .dependsOn case "extension": self = .extension case "lowerThan": @@ -904,6 +912,7 @@ public enum Keyword: UInt8, Hashable, Sendable { "default", "defer", "deinit", + "dependsOn", "deprecated", "derivative", "didSet", @@ -993,6 +1002,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..ae7d70b5407 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:)) } } @@ -1169,19 +1145,31 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { public init( _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, specifier: RawTokenSyntax, - _ unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndScoped: RawUnexpectedNodesSyntax? = nil, + scoped: RawTokenSyntax?, + _ unexpectedBetweenScopedAndArguments: 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[2] = unexpectedBetweenSpecifierAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndScoped?.raw + layout[5] = scoped?.raw + layout[6] = unexpectedBetweenScopedAndArguments?.raw + layout[7] = arguments.raw + layout[8] = unexpectedBetweenArgumentsAndRightParen?.raw + layout[9] = rightParen.raw + layout[10] = unexpectedAfterRightParen?.raw } self.init(unchecked: raw) } @@ -1194,17 +1182,41 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenSpecifierAndLeftParen: 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 unexpectedBetweenLeftParenAndScoped: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var scoped: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenScopedAndArguments: 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..f9c5501b1de 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`) +/// - `specifier`: `dependsOn` +/// - `leftParen`: `(` +/// - `scoped`: `scoped`? /// - `arguments`: `LifetimeSpecifierArgumentsSyntax` +/// - `rightParen`: `)` /// /// ### Contained in /// @@ -2009,10 +1940,16 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf public init( leadingTrivia: Trivia? = nil, _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: TokenSyntax, - _ unexpectedBetweenSpecifierAndArguments: UnexpectedNodesSyntax? = nil, + specifier: TokenSyntax = .keyword(.dependsOn), + _ unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndScoped: UnexpectedNodesSyntax? = nil, + scoped: TokenSyntax? = nil, + _ unexpectedBetweenScopedAndArguments: UnexpectedNodesSyntax? = nil, arguments: LifetimeSpecifierArgumentsSyntax, - _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2021,16 +1958,28 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf self = withExtendedLifetime((SyntaxArena(), ( unexpectedBeforeSpecifier, specifier, - unexpectedBetweenSpecifierAndArguments, + unexpectedBetweenSpecifierAndLeftParen, + leftParen, + unexpectedBetweenLeftParenAndScoped, + scoped, + unexpectedBetweenScopedAndArguments, arguments, - unexpectedAfterArguments + unexpectedBetweenArgumentsAndRightParen, + rightParen, + unexpectedAfterRightParen ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeSpecifier?.raw, specifier.raw, - unexpectedBetweenSpecifierAndArguments?.raw, + unexpectedBetweenSpecifierAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndScoped?.raw, + scoped?.raw, + unexpectedBetweenScopedAndArguments?.raw, arguments.raw, - unexpectedAfterArguments?.raw + unexpectedBetweenArgumentsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.lifetimeTypeSpecifier, @@ -2057,11 +2006,7 @@ 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` + /// For syntax trees generated by the parser, this is guaranteed to be `dependsOn`. public var specifier: 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 unexpectedBetweenSpecifierAndLeftParen: 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 unexpectedBetweenLeftParenAndScoped: 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 scoped: 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 unexpectedBetweenScopedAndArguments: 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.unexpectedBetweenSpecifierAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndScoped, + \Self.scoped, + \Self.unexpectedBetweenScopedAndArguments, \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 42de0a8b5c9699960087762e0ef496a65ef9b578 Mon Sep 17 00:00:00 2001 From: Meghana Gupta Date: Sat, 23 Mar 2024 19:47:39 -0700 Subject: [PATCH 2/3] Remove _consume/_copy/_mutate --- .../Sources/SyntaxSupport/KeywordSpec.swift | 9 --------- Sources/SwiftParser/TokenPrecedence.swift | 2 +- Sources/SwiftSyntax/generated/Keyword.swift | 15 --------------- 3 files changed, 1 insertion(+), 25 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift index a71daaa5e37..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 @@ -345,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: @@ -371,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: diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift index 307b5e5f3f8..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, .dependsOn, .scoped, + .transferring, .dependsOn, .scoped, // Accessors .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress, .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, ._modify, diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift index 924e4d4c84d..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 @@ -347,8 +341,6 @@ public enum Keyword: UInt8, Hashable, Sendable { } case 5: switch text { - case "_copy": - self = ._copy case "_move": self = ._move case "_read": @@ -461,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": @@ -500,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": @@ -834,9 +822,7 @@ public enum Keyword: UInt8, Hashable, Sendable { "_Class", "_compilerInitialized", "_const", - "_consume", "_consuming", - "_copy", "_documentation", "_dynamicReplacement", "_effects", @@ -847,7 +833,6 @@ public enum Keyword: UInt8, Hashable, Sendable { "_local", "_modify", "_move", - "_mutate", "_mutating", "_NativeClass", "_NativeRefCountedObject", From a22fb3dbcff6b25edbb76b15a2aedba41550d849 Mon Sep 17 00:00:00 2001 From: Meghana Gupta Date: Sat, 23 Mar 2024 23:39:42 -0700 Subject: [PATCH 3/3] Fix name to make validation successful --- .../Sources/SyntaxSupport/TypeNodes.swift | 8 +-- Sources/SwiftParser/Types.swift | 8 +-- .../generated/ChildNameForKeyPath.swift | 24 +++---- .../generated/raw/RawSyntaxNodesJKLMN.swift | 36 +++++----- .../syntaxNodes/SyntaxNodesJKLMN.swift | 66 +++++++++---------- 5 files changed, 70 insertions(+), 72 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift index f4c5c019dce..2658b4e0b3f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift @@ -575,10 +575,8 @@ public let TYPE_NODES: [Node] = [ ], children: [ Child( - name: "specifier", - kind: .token(choices: [ - .keyword(.dependsOn) - ]), + name: "dependsOnKeyword", + kind: .token(choices: [.keyword(.dependsOn)]), documentation: "The specifier token that's attached to the type." ), Child( @@ -586,7 +584,7 @@ public let TYPE_NODES: [Node] = [ kind: .token(choices: [.token(.leftParen)]) ), Child( - name: "scoped", + name: "scopedKeyword", kind: .token(choices: [.keyword(.scoped)]), isOptional: true ), diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift index d83c0b2f56c..99958f0deae 100644 --- a/Sources/SwiftParser/Types.swift +++ b/Sources/SwiftParser/Types.swift @@ -916,9 +916,9 @@ extension Parser { arena: self.arena ) let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax( - specifier: specifier, + dependsOnKeyword: specifier, leftParen: missingToken(.leftParen), - scoped: nil, + scopedKeyword: nil, arguments: arguments, rightParen: missingToken(.rightParen), arena: self.arena @@ -952,9 +952,9 @@ extension Parser { arena: self.arena ) let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax( - specifier: specifier, + dependsOnKeyword: specifier, leftParen: leftParen, - scoped: scoped, + scopedKeyword: scoped, arguments: argumentsSyntax, unexpectedBeforeRightParen, rightParen: rightParen, diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index 6c92ee267d9..b2666dca2a3 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -2015,20 +2015,20 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "arguments" case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterArguments: return "unexpectedAfterArguments" - case \LifetimeTypeSpecifierSyntax.unexpectedBeforeSpecifier: - return "unexpectedBeforeSpecifier" - case \LifetimeTypeSpecifierSyntax.specifier: - return "specifier" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenSpecifierAndLeftParen: - return "unexpectedBetweenSpecifierAndLeftParen" + case \LifetimeTypeSpecifierSyntax.unexpectedBeforeDependsOnKeyword: + return "unexpectedBeforeDependsOnKeyword" + case \LifetimeTypeSpecifierSyntax.dependsOnKeyword: + return "dependsOnKeyword" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenDependsOnKeywordAndLeftParen: + return "unexpectedBetweenDependsOnKeywordAndLeftParen" case \LifetimeTypeSpecifierSyntax.leftParen: return "leftParen" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenLeftParenAndScoped: - return "unexpectedBetweenLeftParenAndScoped" - case \LifetimeTypeSpecifierSyntax.scoped: - return "scoped" - case \LifetimeTypeSpecifierSyntax.unexpectedBetweenScopedAndArguments: - return "unexpectedBetweenScopedAndArguments" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenLeftParenAndScopedKeyword: + return "unexpectedBetweenLeftParenAndScopedKeyword" + case \LifetimeTypeSpecifierSyntax.scopedKeyword: + return "scopedKeyword" + case \LifetimeTypeSpecifierSyntax.unexpectedBetweenScopedKeywordAndArguments: + return "unexpectedBetweenScopedKeywordAndArguments" case \LifetimeTypeSpecifierSyntax.arguments: return "arguments" case \LifetimeTypeSpecifierSyntax.unexpectedBetweenArgumentsAndRightParen: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift index ae7d70b5407..56087afd1f9 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift @@ -1143,13 +1143,13 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, - specifier: RawTokenSyntax, - _ unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDependsOnKeyword: RawUnexpectedNodesSyntax? = nil, + dependsOnKeyword: RawTokenSyntax, + _ unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndScoped: RawUnexpectedNodesSyntax? = nil, - scoped: RawTokenSyntax?, - _ unexpectedBetweenScopedAndArguments: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? = nil, + scopedKeyword: RawTokenSyntax?, + _ unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? = nil, arguments: RawLifetimeSpecifierArgumentsSyntax, _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, rightParen: RawTokenSyntax, @@ -1159,13 +1159,13 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { let raw = RawSyntax.makeLayout( kind: .lifetimeTypeSpecifier, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeSpecifier?.raw - layout[1] = specifier.raw - layout[2] = unexpectedBetweenSpecifierAndLeftParen?.raw + layout[0] = unexpectedBeforeDependsOnKeyword?.raw + layout[1] = dependsOnKeyword.raw + layout[2] = unexpectedBetweenDependsOnKeywordAndLeftParen?.raw layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndScoped?.raw - layout[5] = scoped?.raw - layout[6] = unexpectedBetweenScopedAndArguments?.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 @@ -1174,15 +1174,15 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { 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 unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } @@ -1190,15 +1190,15 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndScoped: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var scoped: RawTokenSyntax? { + public var scopedKeyword: RawTokenSyntax? { layoutView.children[5].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenScopedAndArguments: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift index f9c5501b1de..9f02ec31ce5 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift @@ -1911,9 +1911,9 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, /// /// ### Children /// -/// - `specifier`: `dependsOn` +/// - `dependsOnKeyword`: `dependsOn` /// - `leftParen`: `(` -/// - `scoped`: `scoped`? +/// - `scopedKeyword`: `scoped`? /// - `arguments`: `LifetimeSpecifierArgumentsSyntax` /// - `rightParen`: `)` /// @@ -1935,17 +1935,17 @@ 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 = .keyword(.dependsOn), - _ unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? = nil, + dependsOnKeyword: TokenSyntax = .keyword(.dependsOn), + _ unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndScoped: UnexpectedNodesSyntax? = nil, - scoped: TokenSyntax? = nil, - _ unexpectedBetweenScopedAndArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? = nil, + scopedKeyword: TokenSyntax? = nil, + _ unexpectedBetweenScopedKeywordAndArguments: UnexpectedNodesSyntax? = nil, arguments: LifetimeSpecifierArgumentsSyntax, _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax = .rightParenToken(), @@ -1956,26 +1956,26 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf // 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, - unexpectedBetweenSpecifierAndLeftParen, + unexpectedBeforeDependsOnKeyword, + dependsOnKeyword, + unexpectedBetweenDependsOnKeywordAndLeftParen, leftParen, - unexpectedBetweenLeftParenAndScoped, - scoped, - unexpectedBetweenScopedAndArguments, + unexpectedBetweenLeftParenAndScopedKeyword, + scopedKeyword, + unexpectedBetweenScopedKeywordAndArguments, arguments, unexpectedBetweenArgumentsAndRightParen, rightParen, unexpectedAfterRightParen ))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifier?.raw, - specifier.raw, - unexpectedBetweenSpecifierAndLeftParen?.raw, + unexpectedBeforeDependsOnKeyword?.raw, + dependsOnKeyword.raw, + unexpectedBetweenDependsOnKeywordAndLeftParen?.raw, leftParen.raw, - unexpectedBetweenLeftParenAndScoped?.raw, - scoped?.raw, - unexpectedBetweenScopedAndArguments?.raw, + unexpectedBetweenLeftParenAndScopedKeyword?.raw, + scopedKeyword?.raw, + unexpectedBetweenScopedKeywordAndArguments?.raw, arguments.raw, unexpectedBetweenArgumentsAndRightParen?.raw, rightParen.raw, @@ -1993,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) } @@ -2007,7 +2007,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// ### Tokens /// /// For syntax trees generated by the parser, this is guaranteed to be `dependsOn`. - public var specifier: TokenSyntax { + public var dependsOnKeyword: TokenSyntax { get { return Syntax(self).child(at: 1)!.cast(TokenSyntax.self) } @@ -2016,7 +2016,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - public var unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } @@ -2037,7 +2037,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - public var unexpectedBetweenLeftParenAndScoped: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -2049,7 +2049,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf /// ### Tokens /// /// For syntax trees generated by the parser, this is guaranteed to be `scoped`. - public var scoped: TokenSyntax? { + public var scopedKeyword: TokenSyntax? { get { return Syntax(self).child(at: 5)?.cast(TokenSyntax.self) } @@ -2058,7 +2058,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf } } - public var unexpectedBetweenScopedAndArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenScopedKeywordAndArguments: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } @@ -2108,13 +2108,13 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeSpecifier, - \Self.specifier, - \Self.unexpectedBetweenSpecifierAndLeftParen, + \Self.unexpectedBeforeDependsOnKeyword, + \Self.dependsOnKeyword, + \Self.unexpectedBetweenDependsOnKeywordAndLeftParen, \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndScoped, - \Self.scoped, - \Self.unexpectedBetweenScopedAndArguments, + \Self.unexpectedBetweenLeftParenAndScopedKeyword, + \Self.scopedKeyword, + \Self.unexpectedBetweenScopedKeywordAndArguments, \Self.arguments, \Self.unexpectedBetweenArgumentsAndRightParen, \Self.rightParen,