From ad2ae200e38b34e2a45e661869a8260e282e6f7c Mon Sep 17 00:00:00 2001 From: TTOzzi Date: Sun, 4 Jun 2023 17:10:11 +0900 Subject: [PATCH] Change children naming inconsistencies between similar/dual syntax nodes --- .../SyntaxSupport/AttributeNodes.swift | 8 +- .../Sources/SyntaxSupport/GenericNodes.swift | 4 +- .../Sources/SyntaxSupport/StmtNodes.swift | 2 +- Sources/SwiftParser/Attributes.swift | 4 +- Sources/SwiftParser/Declarations.swift | 4 +- Sources/SwiftParser/Statements.swift | 4 +- .../OpaqueParameterToGeneric.swift | 6 +- .../SwiftSyntaxCompatibility.swift | 230 ++++++++++++++++++ .../generated/ChildNameForKeyPath.swift | 48 ++-- .../generated/raw/RawSyntaxNodes.swift | 72 +++--- .../generated/syntaxNodes/SyntaxNodes.swift | 162 ++++++------ .../generated/BuildableNodes.swift | 12 +- 12 files changed, 393 insertions(+), 163 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift index a847083845e..da02d28f5a2 100644 --- a/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift @@ -168,8 +168,8 @@ public let ATTRIBUTE_NODES: [Node] = [ documentation: "The colon separating the label and the value" ), Child( - name: "AvailabilityList", - kind: .collection(kind: .availabilitySpecList, collectionElementName: "Availability") + name: "AvailabilityArguments", + kind: .collection(kind: .availabilitySpecList, collectionElementName: "AvailabilityArgument") ), Child( name: "Semicolon", @@ -227,8 +227,8 @@ public let ATTRIBUTE_NODES: [Node] = [ documentation: "The colon separating \"before\" and the parameter list." ), Child( - name: "VersionList", - kind: .collection(kind: .availabilityVersionRestrictionList, collectionElementName: "Availability"), + name: "Platforms", + kind: .collection(kind: .availabilityVersionRestrictionList, collectionElementName: "Platform"), documentation: "The list of OS versions in which the declaration became ABI stable." ), ] diff --git a/CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift b/CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift index c5a47c5c83e..34b4e4fe07f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift @@ -44,8 +44,8 @@ public let GENERIC_NODES: [Node] = [ kind: .token(choices: [.token(tokenKind: "LeftAngleToken")]) ), Child( - name: "GenericParameterList", - kind: .collection(kind: .genericParameterList, collectionElementName: "GenericParameter") + name: "Parameters", + kind: .collection(kind: .genericParameterList, collectionElementName: "Parameter") ), Child( name: "GenericWhereClause", diff --git a/CodeGeneration/Sources/SyntaxSupport/StmtNodes.swift b/CodeGeneration/Sources/SyntaxSupport/StmtNodes.swift index 47dbe062341..971dee9f38e 100644 --- a/CodeGeneration/Sources/SyntaxSupport/StmtNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/StmtNodes.swift @@ -26,7 +26,7 @@ public let STMT_NODES: [Node] = [ kind: .token(choices: [.token(tokenKind: "LeftParenToken")]) ), Child( - name: "AvailabilitySpec", + name: "AvailabilityArguments", kind: .collection(kind: .availabilitySpecList, collectionElementName: "AvailabilityArgument") ), Child( diff --git a/Sources/SwiftParser/Attributes.swift b/Sources/SwiftParser/Attributes.swift index 4de56ac7eb0..aa3ae29ad78 100644 --- a/Sources/SwiftParser/Attributes.swift +++ b/Sources/SwiftParser/Attributes.swift @@ -729,7 +729,7 @@ extension Parser { label: ident, unexpectedBeforeColon, colon: colon, - availabilityList: availability, + availabilityArguments: availability, unexpectedBeforeSemi, semicolon: semi, arena: self.arena @@ -949,7 +949,7 @@ extension Parser { beforeLabel: label, unexpectedBeforeColon, colon: colon, - versionList: RawAvailabilityVersionRestrictionListSyntax(elements: elements, arena: self.arena), + platforms: RawAvailabilityVersionRestrictionListSyntax(elements: elements, arena: self.arena), arena: self.arena ) } diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index 600106239c2..e806c9df90c 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -469,7 +469,7 @@ extension Parser { return RawGenericParameterClauseSyntax( remainingTokens, leftAngleBracket: missingToken(.leftAngle), - genericParameterList: RawGenericParameterListSyntax(elements: [], arena: self.arena), + parameters: RawGenericParameterListSyntax(elements: [], arena: self.arena), genericWhereClause: nil, rightAngleBracket: missingToken(.rightAngle), arena: self.arena @@ -574,7 +574,7 @@ extension Parser { } return RawGenericParameterClauseSyntax( leftAngleBracket: langle, - genericParameterList: parameters, + parameters: parameters, genericWhereClause: whereClause, rightAngleBracket: rangle, arena: self.arena diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index 3bf9b3f2742..7b4779398f1 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -336,7 +336,7 @@ extension Parser { precondition(self.at(.poundAvailableKeyword, .poundUnavailableKeyword)) let keyword = self.consumeAnyToken() let (unexpectedBeforeLParen, lparen) = self.expect(.leftParen) - let spec = self.parseAvailabilitySpecList() + let arguments = self.parseAvailabilitySpecList() let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen) let unexpectedAfterRParen: RawUnexpectedNodesSyntax? if let (equalOperator, falseKeyword) = self.consume(if: { $0.isContextualPunctuator("==") }, followedBy: { TokenSpec.keyword(.false) ~= $0 }) { @@ -349,7 +349,7 @@ extension Parser { availabilityKeyword: keyword, unexpectedBeforeLParen, leftParen: lparen, - availabilitySpec: spec, + availabilityArguments: arguments, unexpectedBeforeRParen, rightParen: rparen, unexpectedAfterRParen, diff --git a/Sources/SwiftRefactor/OpaqueParameterToGeneric.swift b/Sources/SwiftRefactor/OpaqueParameterToGeneric.swift index 21aef2bf757..59a260ba843 100644 --- a/Sources/SwiftRefactor/OpaqueParameterToGeneric.swift +++ b/Sources/SwiftRefactor/OpaqueParameterToGeneric.swift @@ -134,7 +134,7 @@ public struct OpaqueParameterToGeneric: RefactoringProvider { var newGenericParams: [GenericParameterSyntax] = [] if let genericParams { - newGenericParams.append(contentsOf: genericParams.genericParameterList) + newGenericParams.append(contentsOf: genericParams.parameters) } for rewritten in rewriter.rewrittenSomeParameters { @@ -154,13 +154,13 @@ public struct OpaqueParameterToGeneric: RefactoringProvider { let newGenericParamClause: GenericParameterClauseSyntax if let genericParams { newGenericParamClause = genericParams.with( - \.genericParameterList, + \.parameters, newGenericParamSyntax ) } else { newGenericParamClause = GenericParameterClauseSyntax( leftAngleBracket: .leftAngleToken(), - genericParameterList: newGenericParamSyntax, + parameters: newGenericParamSyntax, genericWhereClause: nil, rightAngleBracket: .rightAngleToken() ) diff --git a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift index bd4f42008e6..1f0e7e06a49 100644 --- a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift +++ b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift @@ -22,6 +22,171 @@ public typealias AccessPathComponentSyntax = ImportPathComponentSyntax @available(*, deprecated, renamed: "WithAttributesSyntax") public typealias AttributedSyntax = WithAttributesSyntax +public extension AvailabilityConditionSyntax { + @available(*, deprecated, renamed: "unexpectedBetweenLeftParenAndAvailabilityArguments") + var unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? { + get { unexpectedBetweenLeftParenAndAvailabilityArguments } + set { unexpectedBetweenLeftParenAndAvailabilityArguments = newValue } + } + + @available(*, deprecated, renamed: "availabilityArguments") + var availabilitySpec: AvailabilitySpecListSyntax { + get { availabilityArguments } + set { availabilityArguments = newValue } + } + + @available(*, deprecated, renamed: "unexpectedBetweenAvailabilityArgumentsAndRightParen") + var unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? { + get { unexpectedBetweenAvailabilityArgumentsAndRightParen } + set { unexpectedBetweenAvailabilityArgumentsAndRightParen = newValue } + } + + @available(*, deprecated, message: "Use an initializer with an availabilityArguments argument") + init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? = nil, + availabilityKeyword: TokenSyntax, + _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, + availabilitySpec: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAvailabilityKeyword, + availabilityKeyword: availabilityKeyword, + unexpectedBetweenAvailabilityKeywordAndLeftParen, + leftParen: leftParen, + unexpectedBetweenLeftParenAndAvailabilitySpec, + availabilityArguments: availabilitySpec, + unexpectedBetweenAvailabilitySpecAndRightParen, + rightParen: rightParen, + unexpectedAfterRightParen, + trailingTrivia: trailingTrivia + ) + } +} + +public extension AvailabilityEntrySyntax { + @available(*, deprecated, renamed: "unexpectedBetweenColonAndAvailabilityArguments") + var unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? { + get { unexpectedBetweenColonAndAvailabilityArguments } + set { unexpectedBetweenColonAndAvailabilityArguments = newValue } + } + + @available(*, deprecated, renamed: "availabilityArguments") + var availabilityList: AvailabilitySpecListSyntax { + get { availabilityArguments } + set { availabilityArguments = newValue } + } + + @available(*, deprecated, renamed: "unexpectedBetweenAvailabilityArgumentsAndSemicolon") + var unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? { + get { unexpectedBetweenAvailabilityArgumentsAndSemicolon } + set { unexpectedBetweenAvailabilityArgumentsAndSemicolon = newValue } + } + + /// Adds the provided `element` to the node's `availabilityList` + /// collection. + /// - param element: The new `Availability` to add to the node's + /// `availabilityList` collection. + /// - returns: A copy of the receiver with the provided `Availability` + /// appended to its `availabilityList` collection. + @available(*, deprecated, renamed: "addAvailabilityArgument") + func addAvailability(_ element: AvailabilityArgumentSyntax) -> AvailabilityEntrySyntax { + addAvailabilityArgument(element) + } + + @available(*, deprecated, message: "Use an initializer with an availabilityArguments argument") + init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax = .keyword(.availability), + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, + availabilityList: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax = .semicolonToken(), + _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeLabel, + label: label, + unexpectedBetweenLabelAndColon, + colon: colon, + unexpectedBetweenColonAndAvailabilityList, + availabilityArguments: availabilityList, + unexpectedBetweenAvailabilityListAndSemicolon, + semicolon: semicolon, + unexpectedAfterSemicolon, + trailingTrivia: trailingTrivia + ) + } +} + +public extension BackDeployedAttributeSpecListSyntax { + @available(*, deprecated, renamed: "unexpectedBetweenColonAndPlatforms") + var unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? { + get { unexpectedBetweenColonAndPlatforms } + set { unexpectedBetweenColonAndPlatforms = newValue } + } + + @available(*, deprecated, renamed: "platforms") + var versionList: AvailabilityVersionRestrictionListSyntax { + get { platforms } + set { platforms = newValue } + } + + @available(*, deprecated, renamed: "unexpectedAfterPlatforms") + var unexpectedAfterVersionList: UnexpectedNodesSyntax? { + get { unexpectedAfterPlatforms } + set { unexpectedAfterPlatforms = newValue } + } + + /// Adds the provided `element` to the node's `versionList` + /// collection. + /// - param element: The new `Availability` to add to the node's + /// `versionList` collection. + /// - returns: A copy of the receiver with the provided `Availability` + /// appended to its `versionList` collection. + @available(*, deprecated, renamed: "addPlatform") + func addAvailability(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> BackDeployedAttributeSpecListSyntax { + addPlatform(element) + } + + @available(*, deprecated, message: "Use an initializer with a platforms argument") + init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, + beforeLabel: TokenSyntax = .keyword(.before), + _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, + versionList: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeBeforeLabel, + beforeLabel: beforeLabel, + unexpectedBetweenBeforeLabelAndColon, + colon: colon, + unexpectedBetweenColonAndVersionList, + platforms: versionList, + unexpectedAfterVersionList, + trailingTrivia: trailingTrivia + ) + } +} + public extension DeclGroupSyntax { @available(*, deprecated, renamed: "memberBlock") var members: MemberDeclBlockSyntax { @@ -209,6 +374,66 @@ public extension FunctionTypeSyntax { } } +public extension GenericParameterClauseSyntax { + @available(*, deprecated, renamed: "unexpectedBetweenLeftAngleBracketAndParameters") + var unexpectedBetweenLeftAngleBracketAndGenericParameterList: UnexpectedNodesSyntax? { + get { unexpectedBetweenLeftAngleBracketAndParameters } + set { unexpectedBetweenLeftAngleBracketAndParameters = newValue } + } + + @available(*, deprecated, renamed: "parameters") + var genericParameterList: GenericParameterListSyntax { + get { parameters } + set { parameters = newValue } + } + + @available(*, deprecated, renamed: "unexpectedBetweenParametersAndGenericWhereClause") + var unexpectedBetweenGenericParameterListAndGenericWhereClause: UnexpectedNodesSyntax? { + get { unexpectedBetweenParametersAndGenericWhereClause } + set { unexpectedBetweenParametersAndGenericWhereClause = newValue } + } + + /// Adds the provided `element` to the node's `genericParameterList` + /// collection. + /// - param element: The new `GenericParameter` to add to the node's + /// `genericParameterList` collection. + /// - returns: A copy of the receiver with the provided `GenericParameter` + /// appended to its `genericParameterList` collection. + @available(*, deprecated, renamed: "addParameter") + func addGenericParameter(_ element: GenericParameterSyntax) -> GenericParameterClauseSyntax { + addParameter(element) + } + + @available(*, deprecated, message: "Use an initializer with a parameters argument") + init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, + leftAngleBracket: TokenSyntax = .leftAngleToken(), + _ unexpectedBetweenLeftAngleBracketAndGenericParameterList: UnexpectedNodesSyntax? = nil, + genericParameterList: GenericParameterListSyntax, + _ unexpectedBetweenGenericParameterListAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndRightAngleBracket: UnexpectedNodesSyntax? = nil, + rightAngleBracket: TokenSyntax = .rightAngleToken(), + _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeLeftAngleBracket, + leftAngleBracket: leftAngleBracket, + unexpectedBetweenLeftAngleBracketAndGenericParameterList, + parameters: genericParameterList, + unexpectedBetweenGenericParameterListAndGenericWhereClause, + genericWhereClause: genericWhereClause, + unexpectedBetweenGenericWhereClauseAndRightAngleBracket, + rightAngleBracket: rightAngleBracket, + unexpectedAfterRightAngleBracket, + trailingTrivia: trailingTrivia + ) + } +} + public extension ImportDeclSyntax { @available(*, deprecated, renamed: "unexpectedBetweenModifiersAndImportKeyword") var unexpectedBetweenModifiersAndImportTok: UnexpectedNodesSyntax? { @@ -386,3 +611,8 @@ public extension TupleExprSyntax { ) } } + +//==========================================================================// +// IMPORTANT: If you are tempted to add a compatiblity layer code here // +// please insert it in alphabetical order above // +//==========================================================================// diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index 95b62d924a4..6c289bb6886 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -303,12 +303,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAvailabilityKeywordAndLeftParen" case \AvailabilityConditionSyntax.leftParen: return "leftParen" - case \AvailabilityConditionSyntax.unexpectedBetweenLeftParenAndAvailabilitySpec: - return "unexpectedBetweenLeftParenAndAvailabilitySpec" - case \AvailabilityConditionSyntax.availabilitySpec: - return "availabilitySpec" - case \AvailabilityConditionSyntax.unexpectedBetweenAvailabilitySpecAndRightParen: - return "unexpectedBetweenAvailabilitySpecAndRightParen" + case \AvailabilityConditionSyntax.unexpectedBetweenLeftParenAndAvailabilityArguments: + return "unexpectedBetweenLeftParenAndAvailabilityArguments" + case \AvailabilityConditionSyntax.availabilityArguments: + return "availabilityArguments" + case \AvailabilityConditionSyntax.unexpectedBetweenAvailabilityArgumentsAndRightParen: + return "unexpectedBetweenAvailabilityArgumentsAndRightParen" case \AvailabilityConditionSyntax.rightParen: return "rightParen" case \AvailabilityConditionSyntax.unexpectedAfterRightParen: @@ -321,12 +321,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenLabelAndColon" case \AvailabilityEntrySyntax.colon: return "colon" - case \AvailabilityEntrySyntax.unexpectedBetweenColonAndAvailabilityList: - return "unexpectedBetweenColonAndAvailabilityList" - case \AvailabilityEntrySyntax.availabilityList: - return "availabilityList" - case \AvailabilityEntrySyntax.unexpectedBetweenAvailabilityListAndSemicolon: - return "unexpectedBetweenAvailabilityListAndSemicolon" + case \AvailabilityEntrySyntax.unexpectedBetweenColonAndAvailabilityArguments: + return "unexpectedBetweenColonAndAvailabilityArguments" + case \AvailabilityEntrySyntax.availabilityArguments: + return "availabilityArguments" + case \AvailabilityEntrySyntax.unexpectedBetweenAvailabilityArgumentsAndSemicolon: + return "unexpectedBetweenAvailabilityArgumentsAndSemicolon" case \AvailabilityEntrySyntax.semicolon: return "semicolon" case \AvailabilityEntrySyntax.unexpectedAfterSemicolon: @@ -383,12 +383,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenBeforeLabelAndColon" case \BackDeployedAttributeSpecListSyntax.colon: return "colon" - case \BackDeployedAttributeSpecListSyntax.unexpectedBetweenColonAndVersionList: - return "unexpectedBetweenColonAndVersionList" - case \BackDeployedAttributeSpecListSyntax.versionList: - return "versionList" - case \BackDeployedAttributeSpecListSyntax.unexpectedAfterVersionList: - return "unexpectedAfterVersionList" + case \BackDeployedAttributeSpecListSyntax.unexpectedBetweenColonAndPlatforms: + return "unexpectedBetweenColonAndPlatforms" + case \BackDeployedAttributeSpecListSyntax.platforms: + return "platforms" + case \BackDeployedAttributeSpecListSyntax.unexpectedAfterPlatforms: + return "unexpectedAfterPlatforms" case \BinaryOperatorExprSyntax.unexpectedBeforeOperatorToken: return "unexpectedBeforeOperatorToken" case \BinaryOperatorExprSyntax.operatorToken: @@ -1579,12 +1579,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBeforeLeftAngleBracket" case \GenericParameterClauseSyntax.leftAngleBracket: return "leftAngleBracket" - case \GenericParameterClauseSyntax.unexpectedBetweenLeftAngleBracketAndGenericParameterList: - return "unexpectedBetweenLeftAngleBracketAndGenericParameterList" - case \GenericParameterClauseSyntax.genericParameterList: - return "genericParameterList" - case \GenericParameterClauseSyntax.unexpectedBetweenGenericParameterListAndGenericWhereClause: - return "unexpectedBetweenGenericParameterListAndGenericWhereClause" + case \GenericParameterClauseSyntax.unexpectedBetweenLeftAngleBracketAndParameters: + return "unexpectedBetweenLeftAngleBracketAndParameters" + case \GenericParameterClauseSyntax.parameters: + return "parameters" + case \GenericParameterClauseSyntax.unexpectedBetweenParametersAndGenericWhereClause: + return "unexpectedBetweenParametersAndGenericWhereClause" case \GenericParameterClauseSyntax.genericWhereClause: return "genericWhereClause" case \GenericParameterClauseSyntax.unexpectedBetweenGenericWhereClauseAndRightAngleBracket: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift index 3cc0ebb9a41..2d75afd7e70 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift @@ -1948,9 +1948,9 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { availabilityKeyword: RawTokenSyntax, _ unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? = nil, - availabilitySpec: RawAvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndAvailabilityArguments: RawUnexpectedNodesSyntax? = nil, + availabilityArguments: RawAvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, rightParen: RawTokenSyntax, _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena @@ -1962,9 +1962,9 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { layout[1] = availabilityKeyword.raw layout[2] = unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndAvailabilitySpec?.raw - layout[5] = availabilitySpec.raw - layout[6] = unexpectedBetweenAvailabilitySpecAndRightParen?.raw + layout[4] = unexpectedBetweenLeftParenAndAvailabilityArguments?.raw + layout[5] = availabilityArguments.raw + layout[6] = unexpectedBetweenAvailabilityArgumentsAndRightParen?.raw layout[7] = rightParen.raw layout[8] = unexpectedAfterRightParen?.raw } @@ -1987,15 +1987,15 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndAvailabilityArguments: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var availabilitySpec: RawAvailabilitySpecListSyntax { + public var availabilityArguments: RawAvailabilitySpecListSyntax { layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw:))! } - public var unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityArgumentsAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } @@ -2042,9 +2042,9 @@ public struct RawAvailabilityEntrySyntax: RawSyntaxNodeProtocol { label: RawTokenSyntax, _ unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? = nil, colon: RawTokenSyntax, - _ unexpectedBetweenColonAndAvailabilityList: RawUnexpectedNodesSyntax? = nil, - availabilityList: RawAvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilityListAndSemicolon: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndAvailabilityArguments: RawUnexpectedNodesSyntax? = nil, + availabilityArguments: RawAvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityArgumentsAndSemicolon: RawUnexpectedNodesSyntax? = nil, semicolon: RawTokenSyntax, _ unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena @@ -2056,9 +2056,9 @@ public struct RawAvailabilityEntrySyntax: RawSyntaxNodeProtocol { layout[1] = label.raw layout[2] = unexpectedBetweenLabelAndColon?.raw layout[3] = colon.raw - layout[4] = unexpectedBetweenColonAndAvailabilityList?.raw - layout[5] = availabilityList.raw - layout[6] = unexpectedBetweenAvailabilityListAndSemicolon?.raw + layout[4] = unexpectedBetweenColonAndAvailabilityArguments?.raw + layout[5] = availabilityArguments.raw + layout[6] = unexpectedBetweenAvailabilityArgumentsAndSemicolon?.raw layout[7] = semicolon.raw layout[8] = unexpectedAfterSemicolon?.raw } @@ -2081,15 +2081,15 @@ public struct RawAvailabilityEntrySyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenColonAndAvailabilityList: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndAvailabilityArguments: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var availabilityList: RawAvailabilitySpecListSyntax { + public var availabilityArguments: RawAvailabilitySpecListSyntax { layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw:))! } - public var unexpectedBetweenAvailabilityListAndSemicolon: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityArgumentsAndSemicolon: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } @@ -2558,9 +2558,9 @@ public struct RawBackDeployedAttributeSpecListSyntax: RawSyntaxNodeProtocol { beforeLabel: RawTokenSyntax, _ unexpectedBetweenBeforeLabelAndColon: RawUnexpectedNodesSyntax? = nil, colon: RawTokenSyntax, - _ unexpectedBetweenColonAndVersionList: RawUnexpectedNodesSyntax? = nil, - versionList: RawAvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterVersionList: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndPlatforms: RawUnexpectedNodesSyntax? = nil, + platforms: RawAvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterPlatforms: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( @@ -2570,9 +2570,9 @@ public struct RawBackDeployedAttributeSpecListSyntax: RawSyntaxNodeProtocol { layout[1] = beforeLabel.raw layout[2] = unexpectedBetweenBeforeLabelAndColon?.raw layout[3] = colon.raw - layout[4] = unexpectedBetweenColonAndVersionList?.raw - layout[5] = versionList.raw - layout[6] = unexpectedAfterVersionList?.raw + layout[4] = unexpectedBetweenColonAndPlatforms?.raw + layout[5] = platforms.raw + layout[6] = unexpectedAfterPlatforms?.raw } self.init(unchecked: raw) } @@ -2593,15 +2593,15 @@ public struct RawBackDeployedAttributeSpecListSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenColonAndVersionList: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndPlatforms: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var versionList: RawAvailabilityVersionRestrictionListSyntax { + public var platforms: RawAvailabilityVersionRestrictionListSyntax { layoutView.children[5].map(RawAvailabilityVersionRestrictionListSyntax.init(raw:))! } - public var unexpectedAfterVersionList: RawUnexpectedNodesSyntax? { + public var unexpectedAfterPlatforms: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } @@ -10475,9 +10475,9 @@ public struct RawGenericParameterClauseSyntax: RawSyntaxNodeProtocol { public init( _ unexpectedBeforeLeftAngleBracket: RawUnexpectedNodesSyntax? = nil, leftAngleBracket: RawTokenSyntax, - _ unexpectedBetweenLeftAngleBracketAndGenericParameterList: RawUnexpectedNodesSyntax? = nil, - genericParameterList: RawGenericParameterListSyntax, - _ unexpectedBetweenGenericParameterListAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftAngleBracketAndParameters: RawUnexpectedNodesSyntax? = nil, + parameters: RawGenericParameterListSyntax, + _ unexpectedBetweenParametersAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, _ unexpectedBetweenGenericWhereClauseAndRightAngleBracket: RawUnexpectedNodesSyntax? = nil, rightAngleBracket: RawTokenSyntax, @@ -10489,9 +10489,9 @@ public struct RawGenericParameterClauseSyntax: RawSyntaxNodeProtocol { layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftAngleBracket?.raw layout[1] = leftAngleBracket.raw - layout[2] = unexpectedBetweenLeftAngleBracketAndGenericParameterList?.raw - layout[3] = genericParameterList.raw - layout[4] = unexpectedBetweenGenericParameterListAndGenericWhereClause?.raw + layout[2] = unexpectedBetweenLeftAngleBracketAndParameters?.raw + layout[3] = parameters.raw + layout[4] = unexpectedBetweenParametersAndGenericWhereClause?.raw layout[5] = genericWhereClause?.raw layout[6] = unexpectedBetweenGenericWhereClauseAndRightAngleBracket?.raw layout[7] = rightAngleBracket.raw @@ -10508,15 +10508,15 @@ public struct RawGenericParameterClauseSyntax: RawSyntaxNodeProtocol { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftAngleBracketAndGenericParameterList: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftAngleBracketAndParameters: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericParameterList: RawGenericParameterListSyntax { + public var parameters: RawGenericParameterListSyntax { layoutView.children[3].map(RawGenericParameterListSyntax.init(raw:))! } - public var unexpectedBetweenGenericParameterListAndGenericWhereClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenParametersAndGenericWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift index e2e9b2a7cce..2e769c156b8 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift @@ -1508,9 +1508,9 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { availabilityKeyword: TokenSyntax, _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, - availabilitySpec: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndAvailabilityArguments: UnexpectedNodesSyntax? = nil, + availabilityArguments: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax = .rightParenToken(), _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -1523,9 +1523,9 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { availabilityKeyword, unexpectedBetweenAvailabilityKeywordAndLeftParen, leftParen, - unexpectedBetweenLeftParenAndAvailabilitySpec, - availabilitySpec, - unexpectedBetweenAvailabilitySpecAndRightParen, + unexpectedBetweenLeftParenAndAvailabilityArguments, + availabilityArguments, + unexpectedBetweenAvailabilityArgumentsAndRightParen, rightParen, unexpectedAfterRightParen ))) {(arena, _) in @@ -1534,9 +1534,9 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { availabilityKeyword.raw, unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw, leftParen.raw, - unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, - availabilitySpec.raw, - unexpectedBetweenAvailabilitySpecAndRightParen?.raw, + unexpectedBetweenLeftParenAndAvailabilityArguments?.raw, + availabilityArguments.raw, + unexpectedBetweenAvailabilityArgumentsAndRightParen?.raw, rightParen.raw, unexpectedAfterRightParen?.raw ] @@ -1589,7 +1589,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { } } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndAvailabilityArguments: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -1598,7 +1598,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { } } - public var availabilitySpec: AvailabilitySpecListSyntax { + public var availabilityArguments: AvailabilitySpecListSyntax { get { return AvailabilitySpecListSyntax(data.child(at: 5, parent: Syntax(self))!) } @@ -1607,12 +1607,12 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { } } - /// Adds the provided `element` to the node's `availabilitySpec` + /// Adds the provided `element` to the node's `availabilityArguments` /// collection. /// - param element: The new `AvailabilityArgument` to add to the node's - /// `availabilitySpec` collection. + /// `availabilityArguments` collection. /// - returns: A copy of the receiver with the provided `AvailabilityArgument` - /// appended to its `availabilitySpec` collection. + /// appended to its `availabilityArguments` collection. public func addAvailabilityArgument(_ element: AvailabilityArgumentSyntax) -> AvailabilityConditionSyntax { var collection: RawSyntax let arena = SyntaxArena() @@ -1626,7 +1626,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { return AvailabilityConditionSyntax(newData) } - public var unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityArgumentsAndRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -1659,9 +1659,9 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { \Self.availabilityKeyword, \Self.unexpectedBetweenAvailabilityKeywordAndLeftParen, \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, - \Self.availabilitySpec, - \Self.unexpectedBetweenAvailabilitySpecAndRightParen, + \Self.unexpectedBetweenLeftParenAndAvailabilityArguments, + \Self.availabilityArguments, + \Self.unexpectedBetweenAvailabilityArgumentsAndRightParen, \Self.rightParen, \Self.unexpectedAfterRightParen ]) @@ -1695,9 +1695,9 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { label: TokenSyntax = .keyword(.availability), _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, - availabilityList: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndAvailabilityArguments: UnexpectedNodesSyntax? = nil, + availabilityArguments: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityArgumentsAndSemicolon: UnexpectedNodesSyntax? = nil, semicolon: TokenSyntax = .semicolonToken(), _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -1710,9 +1710,9 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { label, unexpectedBetweenLabelAndColon, colon, - unexpectedBetweenColonAndAvailabilityList, - availabilityList, - unexpectedBetweenAvailabilityListAndSemicolon, + unexpectedBetweenColonAndAvailabilityArguments, + availabilityArguments, + unexpectedBetweenAvailabilityArgumentsAndSemicolon, semicolon, unexpectedAfterSemicolon ))) {(arena, _) in @@ -1721,9 +1721,9 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { label.raw, unexpectedBetweenLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndAvailabilityList?.raw, - availabilityList.raw, - unexpectedBetweenAvailabilityListAndSemicolon?.raw, + unexpectedBetweenColonAndAvailabilityArguments?.raw, + availabilityArguments.raw, + unexpectedBetweenAvailabilityArgumentsAndSemicolon?.raw, semicolon.raw, unexpectedAfterSemicolon?.raw ] @@ -1778,7 +1778,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { } } - public var unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndAvailabilityArguments: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -1787,7 +1787,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { } } - public var availabilityList: AvailabilitySpecListSyntax { + public var availabilityArguments: AvailabilitySpecListSyntax { get { return AvailabilitySpecListSyntax(data.child(at: 5, parent: Syntax(self))!) } @@ -1796,13 +1796,13 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { } } - /// Adds the provided `element` to the node's `availabilityList` + /// Adds the provided `element` to the node's `availabilityArguments` /// collection. - /// - param element: The new `Availability` to add to the node's - /// `availabilityList` collection. - /// - returns: A copy of the receiver with the provided `Availability` - /// appended to its `availabilityList` collection. - public func addAvailability(_ element: AvailabilityArgumentSyntax) -> AvailabilityEntrySyntax { + /// - param element: The new `AvailabilityArgument` to add to the node's + /// `availabilityArguments` collection. + /// - returns: A copy of the receiver with the provided `AvailabilityArgument` + /// appended to its `availabilityArguments` collection. + public func addAvailabilityArgument(_ element: AvailabilityArgumentSyntax) -> AvailabilityEntrySyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[5] { @@ -1815,7 +1815,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { return AvailabilityEntrySyntax(newData) } - public var unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityArgumentsAndSemicolon: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -1848,9 +1848,9 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { \Self.label, \Self.unexpectedBetweenLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndAvailabilityList, - \Self.availabilityList, - \Self.unexpectedBetweenAvailabilityListAndSemicolon, + \Self.unexpectedBetweenColonAndAvailabilityArguments, + \Self.availabilityArguments, + \Self.unexpectedBetweenAvailabilityArgumentsAndSemicolon, \Self.semicolon, \Self.unexpectedAfterSemicolon ]) @@ -2305,9 +2305,9 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl beforeLabel: TokenSyntax = .keyword(.before), _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, - versionList: AvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndPlatforms: UnexpectedNodesSyntax? = nil, + platforms: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterPlatforms: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2318,18 +2318,18 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl beforeLabel, unexpectedBetweenBeforeLabelAndColon, colon, - unexpectedBetweenColonAndVersionList, - versionList, - unexpectedAfterVersionList + unexpectedBetweenColonAndPlatforms, + platforms, + unexpectedAfterPlatforms ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBeforeLabel?.raw, beforeLabel.raw, unexpectedBetweenBeforeLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndVersionList?.raw, - versionList.raw, - unexpectedAfterVersionList?.raw + unexpectedBetweenColonAndPlatforms?.raw, + platforms.raw, + unexpectedAfterPlatforms?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.backDeployedAttributeSpecList, @@ -2382,7 +2382,7 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl } } - public var unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndPlatforms: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -2392,7 +2392,7 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl } /// The list of OS versions in which the declaration became ABI stable. - public var versionList: AvailabilityVersionRestrictionListSyntax { + public var platforms: AvailabilityVersionRestrictionListSyntax { get { return AvailabilityVersionRestrictionListSyntax(data.child(at: 5, parent: Syntax(self))!) } @@ -2401,13 +2401,13 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl } } - /// Adds the provided `element` to the node's `versionList` + /// Adds the provided `element` to the node's `platforms` /// collection. - /// - param element: The new `Availability` to add to the node's - /// `versionList` collection. - /// - returns: A copy of the receiver with the provided `Availability` - /// appended to its `versionList` collection. - public func addAvailability(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> BackDeployedAttributeSpecListSyntax { + /// - param element: The new `Platform` to add to the node's + /// `platforms` collection. + /// - returns: A copy of the receiver with the provided `Platform` + /// appended to its `platforms` collection. + public func addPlatform(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> BackDeployedAttributeSpecListSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[5] { @@ -2420,7 +2420,7 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl return BackDeployedAttributeSpecListSyntax(newData) } - public var unexpectedAfterVersionList: UnexpectedNodesSyntax? { + public var unexpectedAfterPlatforms: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -2435,9 +2435,9 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl \Self.beforeLabel, \Self.unexpectedBetweenBeforeLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndVersionList, - \Self.versionList, - \Self.unexpectedAfterVersionList + \Self.unexpectedBetweenColonAndPlatforms, + \Self.platforms, + \Self.unexpectedAfterPlatforms ]) } } @@ -9456,9 +9456,9 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { leadingTrivia: Trivia? = nil, _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, leftAngleBracket: TokenSyntax = .leftAngleToken(), - _ unexpectedBetweenLeftAngleBracketAndGenericParameterList: UnexpectedNodesSyntax? = nil, - genericParameterList: GenericParameterListSyntax, - _ unexpectedBetweenGenericParameterListAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftAngleBracketAndParameters: UnexpectedNodesSyntax? = nil, + parameters: GenericParameterListSyntax, + _ unexpectedBetweenParametersAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, _ unexpectedBetweenGenericWhereClauseAndRightAngleBracket: UnexpectedNodesSyntax? = nil, rightAngleBracket: TokenSyntax = .rightAngleToken(), @@ -9471,9 +9471,9 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( unexpectedBeforeLeftAngleBracket, leftAngleBracket, - unexpectedBetweenLeftAngleBracketAndGenericParameterList, - genericParameterList, - unexpectedBetweenGenericParameterListAndGenericWhereClause, + unexpectedBetweenLeftAngleBracketAndParameters, + parameters, + unexpectedBetweenParametersAndGenericWhereClause, genericWhereClause, unexpectedBetweenGenericWhereClauseAndRightAngleBracket, rightAngleBracket, @@ -9482,9 +9482,9 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { let layout: [RawSyntax?] = [ unexpectedBeforeLeftAngleBracket?.raw, leftAngleBracket.raw, - unexpectedBetweenLeftAngleBracketAndGenericParameterList?.raw, - genericParameterList.raw, - unexpectedBetweenGenericParameterListAndGenericWhereClause?.raw, + unexpectedBetweenLeftAngleBracketAndParameters?.raw, + parameters.raw, + unexpectedBetweenParametersAndGenericWhereClause?.raw, genericWhereClause?.raw, unexpectedBetweenGenericWhereClauseAndRightAngleBracket?.raw, rightAngleBracket.raw, @@ -9521,7 +9521,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } } - public var unexpectedBetweenLeftAngleBracketAndGenericParameterList: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftAngleBracketAndParameters: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -9530,7 +9530,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } } - public var genericParameterList: GenericParameterListSyntax { + public var parameters: GenericParameterListSyntax { get { return GenericParameterListSyntax(data.child(at: 3, parent: Syntax(self))!) } @@ -9539,13 +9539,13 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } } - /// Adds the provided `element` to the node's `genericParameterList` + /// Adds the provided `element` to the node's `parameters` /// collection. - /// - param element: The new `GenericParameter` to add to the node's - /// `genericParameterList` collection. - /// - returns: A copy of the receiver with the provided `GenericParameter` - /// appended to its `genericParameterList` collection. - public func addGenericParameter(_ element: GenericParameterSyntax) -> GenericParameterClauseSyntax { + /// - param element: The new `Parameter` to add to the node's + /// `parameters` collection. + /// - returns: A copy of the receiver with the provided `Parameter` + /// appended to its `parameters` collection. + public func addParameter(_ element: GenericParameterSyntax) -> GenericParameterClauseSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[3] { @@ -9558,7 +9558,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { return GenericParameterClauseSyntax(newData) } - public var unexpectedBetweenGenericParameterListAndGenericWhereClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenParametersAndGenericWhereClause: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -9607,9 +9607,9 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { return .layout([ \Self.unexpectedBeforeLeftAngleBracket, \Self.leftAngleBracket, - \Self.unexpectedBetweenLeftAngleBracketAndGenericParameterList, - \Self.genericParameterList, - \Self.unexpectedBetweenGenericParameterListAndGenericWhereClause, + \Self.unexpectedBetweenLeftAngleBracketAndParameters, + \Self.parameters, + \Self.unexpectedBetweenParametersAndGenericWhereClause, \Self.genericWhereClause, \Self.unexpectedBetweenGenericWhereClauseAndRightAngleBracket, \Self.rightAngleBracket, diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index ed6a333bae5..cce85d57666 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -738,22 +738,22 @@ extension GenericParameterClauseSyntax { leadingTrivia: Trivia? = nil, unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, leftAngleBracket: TokenSyntax = .leftAngleToken(), - unexpectedBetweenLeftAngleBracketAndGenericParameterList: UnexpectedNodesSyntax? = nil, - unexpectedBetweenGenericParameterListAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + unexpectedBetweenLeftAngleBracketAndParameters: UnexpectedNodesSyntax? = nil, + unexpectedBetweenParametersAndGenericWhereClause: UnexpectedNodesSyntax? = nil, genericWhereClause: GenericWhereClauseSyntax? = nil, unexpectedBetweenGenericWhereClauseAndRightAngleBracket: UnexpectedNodesSyntax? = nil, rightAngleBracket: TokenSyntax = .rightAngleToken(), unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, - @GenericParameterListBuilder genericParameterListBuilder: () throws -> GenericParameterListSyntax, + @GenericParameterListBuilder parametersBuilder: () throws -> GenericParameterListSyntax, trailingTrivia: Trivia? = nil ) rethrows { try self.init( leadingTrivia: leadingTrivia, unexpectedBeforeLeftAngleBracket, leftAngleBracket: leftAngleBracket, - unexpectedBetweenLeftAngleBracketAndGenericParameterList, - genericParameterList: genericParameterListBuilder(), - unexpectedBetweenGenericParameterListAndGenericWhereClause, + unexpectedBetweenLeftAngleBracketAndParameters, + parameters: parametersBuilder(), + unexpectedBetweenParametersAndGenericWhereClause, genericWhereClause: genericWhereClause, unexpectedBetweenGenericWhereClauseAndRightAngleBracket, rightAngleBracket: rightAngleBracket,