diff --git a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift index 08512cb23ce..0324ea91998 100644 --- a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift @@ -428,6 +428,94 @@ public let DECL_NODES: [Node] = [ ] ), + Node( + name: "EnumCaseParameterClause", + nameForDiagnostics: "parameter clause", + kind: "Syntax", + traits: [ + "Parenthesized" + ], + children: [ + Child( + name: "LeftParen", + kind: .token(choices: [.token(tokenKind: "LeftParenToken")]), + description: "The '(' to open the parameter clause." + ), + Child( + name: "ParameterList", + kind: .collection(kind: "EnumCaseParameterList", collectionElementName: "Parameter"), + nameForDiagnostics: "parameters", + description: "The actual parameters.", + isIndented: true + ), + Child( + name: "RightParen", + kind: .token(choices: [.token(tokenKind: "RightParenToken")]), + description: "The ')' to close the parameter clause." + ), + ] + ), + + Node( + name: "EnumCaseParameterList", + nameForDiagnostics: "parameter list", + kind: "SyntaxCollection", + element: "EnumCaseParameter" + ), + + Node( + name: "EnumCaseParameter", + nameForDiagnostics: "parameter", + kind: "Syntax", + traits: [ + "WithTrailingComma" + ], + parserFunction: "parseEnumCaseParameter", + children: [ + Child( + name: "Modifiers", + kind: .collection(kind: "ModifierList", collectionElementName: "Modifier"), + nameForDiagnostics: "modifiers", + isOptional: true + ), + Child( + name: "FirstName", + kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .token(tokenKind: "WildcardToken")]), + isOptional: true + ), + Child( + name: "SecondName", + kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .token(tokenKind: "WildcardToken")]), + isOptional: true + ), + Child( + name: "Colon", + kind: .token(choices: [.token(tokenKind: "ColonToken")]), + description: "If the parameter has a label, the colon separating the label from the type.", + isOptional: true + ), + Child( + name: "Type", + kind: .node(kind: "Type"), + nameForDiagnostics: "type", + description: "The parameter's type." + ), + Child( + name: "DefaultArgument", + kind: .node(kind: "InitializerClause"), + nameForDiagnostics: "default argument", + description: "If the parameter has a default value, the initializer clause describing the default value.", + isOptional: true + ), + Child( + name: "TrailingComma", + kind: .token(choices: [.token(tokenKind: "CommaToken")]), + description: "If the parameter is followed by another parameter, the comma separating them.", + isOptional: true + ), + ] + ), + Node( name: "EnumCaseDecl", nameForDiagnostics: "enum case", @@ -489,7 +577,7 @@ public let DECL_NODES: [Node] = [ ), Child( name: "AssociatedValue", - kind: .node(kind: "ParameterClause"), + kind: .node(kind: "EnumCaseParameterClause"), nameForDiagnostics: "associated values", description: "The set of associated values of the case.", isOptional: true @@ -699,6 +787,7 @@ public let DECL_NODES: [Node] = [ "WithTrailingComma", "Attributed", ], + parserFunction: "parseFunctionParameter", children: [ Child( name: "Attributes", @@ -714,8 +803,7 @@ public let DECL_NODES: [Node] = [ ), Child( name: "FirstName", - kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .token(tokenKind: "WildcardToken")]), - isOptional: true + kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .token(tokenKind: "WildcardToken")]) ), // One of these two names needs be optional, we choose the second // name to avoid backtracking. @@ -727,14 +815,12 @@ public let DECL_NODES: [Node] = [ ), Child( name: "Colon", - kind: .token(choices: [.token(tokenKind: "ColonToken")]), - isOptional: true + kind: .token(choices: [.token(tokenKind: "ColonToken")]) ), Child( name: "Type", kind: .node(kind: "Type"), - nameForDiagnostics: "type", - isOptional: true + nameForDiagnostics: "type" ), Child( name: "Ellipsis", diff --git a/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift index 9cb05403b41..d1199149586 100644 --- a/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift @@ -301,6 +301,101 @@ public let EXPR_NODES: [Node] = [ ] ), + Node( + name: "ClosureParameter", + nameForDiagnostics: "parameter", + kind: "Syntax", + traits: [ + "WithTrailingComma" + ], + parserFunction: "parseClosureParameter", + children: [ + Child( + name: "Attributes", + kind: .collection(kind: "AttributeList", collectionElementName: "Attribute"), + nameForDiagnostics: "attributes", + isOptional: true + ), + Child( + name: "Modifiers", + kind: .collection(kind: "ModifierList", collectionElementName: "Modifier"), + nameForDiagnostics: "modifiers", + isOptional: true + ), + Child( + name: "FirstName", + kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .token(tokenKind: "WildcardToken")]), + description: "The label of this parameter that will be used when the closure is called." + ), + Child( + name: "SecondName", + kind: .token(choices: [.token(tokenKind: "IdentifierToken"), .token(tokenKind: "WildcardToken")]), + description: "If this is specified, it is the name by which the parameter can be referenced inside the closure body. If it is `nil`, the closure parameter is referenced by the first name.", + isOptional: true + ), + Child( + name: "Colon", + kind: .token(choices: [.token(tokenKind: "ColonToken")]), + description: "The colon separating the parameter's name and type.", + isOptional: true + ), + Child( + name: "Type", + kind: .node(kind: "Type"), + nameForDiagnostics: "type", + description: "The type of the parameter.", + isOptional: true + ), + Child( + name: "Ellipsis", + kind: .token(choices: [.token(tokenKind: "EllipsisToken")]), + description: "If the parameter is variadic, `...` to indicate that.", + isOptional: true + ), + Child( + name: "TrailingComma", + kind: .token(choices: [.token(tokenKind: "CommaToken")]), + description: "If the parameter is followed by another parameter, the comma separating them.", + isOptional: true + ), + ] + ), + + Node( + name: "ClosureParameterList", + nameForDiagnostics: "parameter list", + kind: "SyntaxCollection", + element: "ClosureParameter" + ), + + Node( + name: "ClosureParameterClause", + nameForDiagnostics: "parameter clause", + kind: "Syntax", + traits: [ + "Parenthesized" + ], + children: [ + Child( + name: "LeftParen", + kind: .token(choices: [.token(tokenKind: "LeftParenToken")]), + description: "The '(' to open the parameter clause." + ), + Child( + name: "ParameterList", + kind: .collection(kind: "ClosureParameterList", collectionElementName: "Parameter"), + nameForDiagnostics: "parameters", + description: "The actual parameters.", + isIndented: true + ), + Child( + name: "RightParen", + kind: .token(choices: [.token(tokenKind: "RightParenToken")]), + description: "The ')' to close the parameter clause." + ), + ] + ), + Node( name: "ClosureExpr", nameForDiagnostics: "closure", @@ -389,7 +484,7 @@ public let EXPR_NODES: [Node] = [ ), Child( name: "Input", - kind: .node(kind: "ParameterClause") + kind: .node(kind: "ClosureParameterClause") ), ]), isOptional: true diff --git a/Sources/SwiftBasicFormat/generated/BasicFormat.swift b/Sources/SwiftBasicFormat/generated/BasicFormat.swift index a399eb0db0b..b0a446d8bac 100644 --- a/Sources/SwiftBasicFormat/generated/BasicFormat.swift +++ b/Sources/SwiftBasicFormat/generated/BasicFormat.swift @@ -99,12 +99,16 @@ open class BasicFormat: SyntaxRewriter { return true case \ClosureExprSyntax.statements: return true + case \ClosureParameterClauseSyntax.parameterList: + return true case \CodeBlockSyntax.statements: return true case \DictionaryElementSyntax.valueExpression: return true case \DictionaryExprSyntax.content: return true + case \EnumCaseParameterClauseSyntax.parameterList: + return true case \FunctionCallExprSyntax.argumentList: return true case \FunctionTypeSyntax.arguments: diff --git a/Sources/SwiftParser/CMakeLists.txt b/Sources/SwiftParser/CMakeLists.txt index 04cd4f94900..d10c17b27e5 100644 --- a/Sources/SwiftParser/CMakeLists.txt +++ b/Sources/SwiftParser/CMakeLists.txt @@ -18,6 +18,7 @@ add_swift_host_library(SwiftParser Modifiers.swift Names.swift Nominals.swift + Parameters.swift Parser.swift Patterns.swift TokenSpec.swift diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index e6dde47ee44..3bc4aba97dd 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -892,9 +892,11 @@ extension Parser { let unexpectedPeriod = self.consume(if: .period) let (unexpectedBeforeName, name) = self.expectIdentifier(allowIdentifierLikeKeywords: false, keywordRecovery: true) - let associatedValue: RawParameterClauseSyntax? + let associatedValue: RawEnumCaseParameterClauseSyntax? if self.at(TokenSpec(.leftParen, allowAtStartOfLine: false)) { - associatedValue = self.parseParameterClause(for: .enumCase) + associatedValue = self.parseParameterClause(RawEnumCaseParameterClauseSyntax.self) { parser in + parser.parseEnumCaseParameter() + } } else { associatedValue = nil } @@ -1115,182 +1117,6 @@ extension Parser { } extension Parser { - public enum ParameterSubject { - case closure - case enumCase - case functionParameters - case indices - - var isClosure: Bool { - switch self { - case .closure: return true - case .enumCase: return false - case .functionParameters: return false - case .indices: return false - } - } - } - - mutating func parseParameterModifiers(for subject: ParameterSubject) -> RawModifierListSyntax? { - var elements = [RawDeclModifierSyntax]() - var loopCondition = LoopProgressCondition() - MODIFIER_LOOP: while loopCondition.evaluate(currentToken) { - switch self.at(anyIn: ParameterModifier.self) { - case (._const, let handle)?: - elements.append(RawDeclModifierSyntax(name: self.eat(handle), detail: nil, arena: self.arena)) - case (.isolated, let handle)? where self.withLookahead({ !$0.startsParameterName(isClosure: subject.isClosure, allowMisplacedSpecifierRecovery: false) }): - elements.append(RawDeclModifierSyntax(name: self.eat(handle), detail: nil, arena: self.arena)) - default: - break MODIFIER_LOOP - } - } - if elements.isEmpty { - return nil - } else { - return RawModifierListSyntax(elements: elements, arena: self.arena) - } - } - - @_spi(RawSyntax) - public mutating func parseFunctionParameter(for subject: ParameterSubject) -> RawFunctionParameterSyntax { - // Parse any declaration attributes. The exception here is enum cases - // which only allow types, so we do not consume attributes to allow the - // type attribute grammar a chance to examine them. - let attrs: RawAttributeListSyntax? - if case .enumCase = subject { - attrs = nil - } else { - attrs = self.parseAttributeList() - } - - let modifiers = parseParameterModifiers(for: subject) - - var misplacedSpecifiers: [RawTokenSyntax] = [] - if self.withLookahead({ !$0.startsParameterName(isClosure: subject.isClosure, allowMisplacedSpecifierRecovery: false) }) { - while canHaveParameterSpecifier, - let specifier = self.consume(ifAnyIn: TypeSpecifier.self) - { - misplacedSpecifiers.append(specifier) - } - } - - let unexpectedBeforeFirstName: RawUnexpectedNodesSyntax? - let firstName: RawTokenSyntax? - let unexpectedBeforeSecondName: RawUnexpectedNodesSyntax? - let secondName: RawTokenSyntax? - let unexpectedBeforeColon: RawUnexpectedNodesSyntax? - let colon: RawTokenSyntax? - let shouldParseType: Bool - - if self.withLookahead({ $0.startsParameterName(isClosure: subject.isClosure, allowMisplacedSpecifierRecovery: false) }) { - if self.currentToken.canBeArgumentLabel(allowDollarIdentifier: true) { - (unexpectedBeforeFirstName, firstName) = self.parseArgumentLabel() - } else { - unexpectedBeforeFirstName = nil - firstName = nil - } - - if self.currentToken.canBeArgumentLabel(allowDollarIdentifier: true) { - (unexpectedBeforeSecondName, secondName) = self.parseArgumentLabel() - } else { - unexpectedBeforeSecondName = nil - secondName = nil - } - if subject.isClosure { - unexpectedBeforeColon = nil - colon = self.consume(if: .colon) - shouldParseType = (colon != nil) - } else { - (unexpectedBeforeColon, colon) = self.expect(.colon) - shouldParseType = true - } - } else { - unexpectedBeforeFirstName = nil - firstName = nil - unexpectedBeforeSecondName = nil - secondName = nil - unexpectedBeforeColon = nil - colon = nil - shouldParseType = true - } - - let type: RawTypeSyntax? - if shouldParseType { - type = self.parseType(misplacedSpecifiers: misplacedSpecifiers) - } else { - type = nil - } - - let ellipsis: RawTokenSyntax? - if self.atContextualPunctuator("...") { - ellipsis = self.consumeAnyToken(remapping: .ellipsis) - } else { - ellipsis = nil - } - - let defaultArgument: RawInitializerClauseSyntax? - if self.at(.equal) || self.atContextualPunctuator("==") { - defaultArgument = self.parseDefaultArgument() - } else { - defaultArgument = nil - } - - let trailingComma = self.consume(if: .comma) - return RawFunctionParameterSyntax( - attributes: attrs, - modifiers: modifiers, - RawUnexpectedNodesSyntax(combining: misplacedSpecifiers, unexpectedBeforeFirstName, arena: self.arena), - firstName: firstName, - unexpectedBeforeSecondName, - secondName: secondName, - unexpectedBeforeColon, - colon: colon, - type: type, - ellipsis: ellipsis, - defaultArgument: defaultArgument, - trailingComma: trailingComma, - arena: self.arena - ) - } - - @_spi(RawSyntax) - public mutating func parseParameterClause(for subject: ParameterSubject) -> RawParameterClauseSyntax { - let (unexpectedBeforeLParen, lparen) = self.expect(.leftParen) - var elements = [RawFunctionParameterSyntax]() - // If we are missing the left parenthesis and the next token doesn't appear - // to be an argument label, don't parse any parameters. - let shouldSkipParameterParsing = lparen.isMissing && (!currentToken.canBeArgumentLabel(allowDollarIdentifier: true) || currentToken.isLexerClassifiedKeyword) - if !shouldSkipParameterParsing { - var keepGoing = true - var loopProgress = LoopProgressCondition() - while !self.at(.eof, .rightParen) - && keepGoing - && loopProgress.evaluate(currentToken) - { - let parameter = parseFunctionParameter(for: subject) - keepGoing = parameter.trailingComma != nil - elements.append(parameter) - } - } - let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen) - - let parameters: RawFunctionParameterListSyntax - if elements.isEmpty && (lparen.isMissing || rparen.isMissing) { - parameters = RawFunctionParameterListSyntax(elements: [], arena: self.arena) - } else { - parameters = RawFunctionParameterListSyntax(elements: elements, arena: self.arena) - } - - return RawParameterClauseSyntax( - unexpectedBeforeLParen, - leftParen: lparen, - parameterList: parameters, - unexpectedBeforeRParen, - rightParen: rparen, - arena: self.arena - ) - } - /// If a `throws` keyword appears right in front of the `arrow`, it is returned as `misplacedThrowsKeyword` so it can be synthesized in front of the arrow. mutating func parseFunctionReturnClause(effectSpecifiers: inout S?, allowNamedOpaqueResultType: Bool) -> RawReturnClauseSyntax { let (unexpectedBeforeArrow, arrow) = self.expect(.arrow) @@ -1390,7 +1216,9 @@ extension Parser { @_spi(RawSyntax) public mutating func parseFunctionSignature(allowOutput: Bool = true) -> RawFunctionSignatureSyntax { - let input = self.parseParameterClause(for: .functionParameters) + let input = self.parseParameterClause(RawParameterClauseSyntax.self) { parser in + parser.parseFunctionParameter() + } var effectSpecifiers = self.parseDeclEffectSpecifiers() @@ -1454,7 +1282,9 @@ extension Parser { genericParameterClause = nil } - let indices = self.parseParameterClause(for: .indices) + let indices = self.parseParameterClause(RawParameterClauseSyntax.self) { parser in + parser.parseFunctionParameter() + } var misplacedEffectSpecifiers: RawDeclEffectSpecifiersSyntax? let result = self.parseFunctionReturnClause(effectSpecifiers: &misplacedEffectSpecifiers, allowNamedOpaqueResultType: true) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index afe563e7bb0..d658110e4b1 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -1849,7 +1849,10 @@ extension Parser { if !self.at(.keyword(.in)) { if self.at(.leftParen) { // Parse the closure arguments. - input = .input(self.parseParameterClause(for: .closure)) + let params = self.parseParameterClause(RawClosureParameterClauseSyntax.self) { parser in + parser.parseClosureParameter() + } + input = .input(params) } else { var params = [RawClosureParamSyntax]() var loopProgress = LoopProgressCondition() diff --git a/Sources/SwiftParser/Names.swift b/Sources/SwiftParser/Names.swift index 5b848e8d0c9..04eb1ebd8b7 100644 --- a/Sources/SwiftParser/Names.swift +++ b/Sources/SwiftParser/Names.swift @@ -24,7 +24,9 @@ extension Parser { } mutating func parseArgumentLabel() -> (RawUnexpectedNodesSyntax?, RawTokenSyntax) { - precondition(self.currentToken.canBeArgumentLabel(allowDollarIdentifier: true)) + guard self.currentToken.canBeArgumentLabel(allowDollarIdentifier: true) else { + return (nil, missingToken(.identifier)) + } if let dollarIdent = self.consume(if: .dollarIdentifier) { return ( RawUnexpectedNodesSyntax(elements: [RawSyntax(dollarIdent)], arena: self.arena), diff --git a/Sources/SwiftParser/Parameters.swift b/Sources/SwiftParser/Parameters.swift new file mode 100644 index 00000000000..83867b21b9a --- /dev/null +++ b/Sources/SwiftParser/Parameters.swift @@ -0,0 +1,298 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +@_spi(RawSyntax) import SwiftSyntax + +// MARK: - Traits + +protocol RawParameterTrait: RawSyntaxNodeProtocol { + var trailingComma: RawTokenSyntax? { get } +} + +extension RawFunctionParameterSyntax: RawParameterTrait {} +extension RawClosureParameterSyntax: RawParameterTrait {} +extension RawEnumCaseParameterSyntax: RawParameterTrait {} + +protocol RawParameterListTrait: RawSyntaxNodeProtocol { + associatedtype ParameterSyntax: RawParameterTrait + + init(elements: [ParameterSyntax], arena: __shared SyntaxArena) +} + +extension RawFunctionParameterListSyntax: RawParameterListTrait {} +extension RawClosureParameterListSyntax: RawParameterListTrait {} +extension RawEnumCaseParameterListSyntax: RawParameterListTrait {} + +protocol RawParameterClauseTrait: RawSyntaxNodeProtocol { + associatedtype ParameterList: RawParameterListTrait + + init( + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax?, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax?, + parameterList: ParameterList, + _ unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax?, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax?, + arena: __shared SyntaxArena + ) +} + +extension RawParameterClauseSyntax: RawParameterClauseTrait {} +extension RawClosureParameterClauseSyntax: RawParameterClauseTrait {} +extension RawEnumCaseParameterClauseSyntax: RawParameterClauseTrait {} + +// MARK: Parameter parsing + +extension Parser { + fileprivate struct ParameterNames { + let unexpectedBeforeFirstName: RawUnexpectedNodesSyntax? + let firstName: RawTokenSyntax? + let unexpectedBeforeSecondName: RawUnexpectedNodesSyntax? + let secondName: RawTokenSyntax? + } + + fileprivate mutating func parseParameterNames() -> ParameterNames { + let unexpectedBeforeFirstName: RawUnexpectedNodesSyntax? + let firstName: RawTokenSyntax? + if self.currentToken.canBeArgumentLabel(allowDollarIdentifier: true) { + (unexpectedBeforeFirstName, firstName) = self.parseArgumentLabel() + } else { + (unexpectedBeforeFirstName, firstName) = (nil, nil) + } + + let unexpectedBeforeSecondName: RawUnexpectedNodesSyntax? + let secondName: RawTokenSyntax? + if self.currentToken.canBeArgumentLabel(allowDollarIdentifier: true) { + (unexpectedBeforeSecondName, secondName) = self.parseArgumentLabel() + } else { + (unexpectedBeforeSecondName, secondName) = (nil, nil) + } + + return ParameterNames( + unexpectedBeforeFirstName: unexpectedBeforeFirstName, + firstName: firstName, + unexpectedBeforeSecondName: unexpectedBeforeSecondName, + secondName: secondName + ) + } + + mutating func parseFunctionParameter() -> RawFunctionParameterSyntax { + let attrs = self.parseAttributeList() + + let modifiers = parseParameterModifiers(isClosure: false) + let misplacedSpecifiers = parseMisplacedSpecifiers() + + let names = self.parseParameterNames() + let (unexpectedBeforeColon, colon) = self.expect(.colon) + + let type = self.parseType(misplacedSpecifiers: misplacedSpecifiers) + + let ellipsis = self.consumeIfContextualPunctuator("...", remapping: .ellipsis) + + let defaultArgument: RawInitializerClauseSyntax? + if self.at(.equal) || self.atContextualPunctuator("==") { + defaultArgument = self.parseDefaultArgument() + } else { + defaultArgument = nil + } + + let trailingComma = self.consume(if: .comma) + + return RawFunctionParameterSyntax( + attributes: attrs, + modifiers: modifiers, + RawUnexpectedNodesSyntax(combining: misplacedSpecifiers, names.unexpectedBeforeFirstName, arena: self.arena), + firstName: names.firstName ?? missingToken(.identifier), + names.unexpectedBeforeSecondName, + secondName: names.secondName, + unexpectedBeforeColon, + colon: colon, + type: type, + ellipsis: ellipsis, + defaultArgument: defaultArgument, + trailingComma: trailingComma, + arena: self.arena + ) + } + + mutating func parseClosureParameter() -> RawClosureParameterSyntax { + let attributes = self.parseAttributeList() + + let modifiers = parseParameterModifiers(isClosure: true) + let misplacedSpecifiers = parseMisplacedSpecifiers() + + let names = self.parseParameterNames() + let colon = self.consume(if: .colon) + let type: RawTypeSyntax? + if colon != nil { + type = self.parseType(misplacedSpecifiers: misplacedSpecifiers) + } else { + type = nil + } + + let ellipsis = self.consumeIfContextualPunctuator("...", remapping: .ellipsis) + + let trailingComma = self.consume(if: .comma) + + return RawClosureParameterSyntax( + attributes: attributes, + modifiers: modifiers, + RawUnexpectedNodesSyntax(combining: misplacedSpecifiers, names.unexpectedBeforeFirstName, arena: self.arena), + firstName: names.firstName ?? missingToken(.identifier), + names.unexpectedBeforeSecondName, + secondName: names.secondName, + colon: colon, + type: type, + ellipsis: ellipsis, + trailingComma: trailingComma, + arena: self.arena + ) + } + + mutating func parseEnumCaseParameter() -> RawEnumCaseParameterSyntax { + let modifiers = parseParameterModifiers(isClosure: false) + let misplacedSpecifiers = parseMisplacedSpecifiers() + + let names: ParameterNames + let unexpectedBeforeColon: RawUnexpectedNodesSyntax? + let colon: RawTokenSyntax? + let type: RawTypeSyntax + + if self.withLookahead({ $0.startsParameterName(isClosure: false, allowMisplacedSpecifierRecovery: false) }) { + names = self.parseParameterNames() + + (unexpectedBeforeColon, colon) = self.expect(.colon) + if colon!.isMissing { + // If there was no colon, don't try to parse a type either so we are not + // skipping over unrelated tokens trying to find a type during recvoery. + type = RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena)) + } else { + type = self.parseType(misplacedSpecifiers: misplacedSpecifiers) + } + } else { + names = ParameterNames(unexpectedBeforeFirstName: nil, firstName: nil, unexpectedBeforeSecondName: nil, secondName: nil) + unexpectedBeforeColon = nil + colon = nil + type = self.parseType(misplacedSpecifiers: misplacedSpecifiers) + } + + let defaultArgument: RawInitializerClauseSyntax? + if self.at(.equal) || self.atContextualPunctuator("==") { + defaultArgument = self.parseDefaultArgument() + } else { + defaultArgument = nil + } + + let trailingComma = self.consume(if: .comma) + + return RawEnumCaseParameterSyntax( + modifiers: modifiers, + RawUnexpectedNodesSyntax(combining: misplacedSpecifiers, names.unexpectedBeforeFirstName, arena: self.arena), + firstName: names.firstName, + names.unexpectedBeforeSecondName, + secondName: names.secondName, + unexpectedBeforeColon, + colon: colon, + type: type, + defaultArgument: defaultArgument, + trailingComma: trailingComma, + arena: self.arena + ) + } +} + +// MARK: - Parameter Modifiers + +extension Parser { + mutating func parseParameterModifiers(isClosure: Bool) -> RawModifierListSyntax? { + var elements = [RawDeclModifierSyntax]() + var loopCondition = LoopProgressCondition() + MODIFIER_LOOP: while loopCondition.evaluate(currentToken) { + switch self.at(anyIn: ParameterModifier.self) { + case (._const, let handle)?: + elements.append(RawDeclModifierSyntax(name: self.eat(handle), detail: nil, arena: self.arena)) + case (.isolated, let handle)? where self.withLookahead({ !$0.startsParameterName(isClosure: isClosure, allowMisplacedSpecifierRecovery: false) }): + elements.append(RawDeclModifierSyntax(name: self.eat(handle), detail: nil, arena: self.arena)) + default: + break MODIFIER_LOOP + } + } + if elements.isEmpty { + return nil + } else { + return RawModifierListSyntax(elements: elements, arena: self.arena) + } + } + + mutating func parseMisplacedSpecifiers() -> [RawTokenSyntax] { + var misplacedSpecifiers: [RawTokenSyntax] = [] + if self.withLookahead({ !$0.startsParameterName(isClosure: false, allowMisplacedSpecifierRecovery: false) }) { + while canHaveParameterSpecifier, let specifier = self.consume(ifAnyIn: TypeSpecifier.self) { + misplacedSpecifiers.append(specifier) + } + } + return misplacedSpecifiers + } +} + +// MARK: - Parsing parameter clauses + +extension Parser { + mutating func parseParameterClause< + ParameterClause: RawParameterClauseTrait + >( + _ parameterClauseType: ParameterClause.Type, + parseParameter: (inout Parser) -> ParameterClause.ParameterList.ParameterSyntax + ) -> ParameterClause { + let (unexpectedBeforeLParen, lparen) = self.expect(.leftParen) + var elements = [ParameterClause.ParameterList.ParameterSyntax]() + // If we are missing the left parenthesis and the next token doesn't appear + // to be an argument label, don't parse any parameters. + let shouldSkipParameterParsing = lparen.isMissing && (!currentToken.canBeArgumentLabel(allowDollarIdentifier: true) || currentToken.isLexerClassifiedKeyword) + if !shouldSkipParameterParsing { + var keepGoing = true + var loopProgress = LoopProgressCondition() + while !self.at(.eof, .rightParen) + && keepGoing + && loopProgress.evaluate(currentToken) + { + let parameter = parseParameter(&self) + if parameter.isEmpty { + keepGoing = false + } else { + keepGoing = parameter.trailingComma != nil + elements.append(parameter) + } + } + } + let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen) + + let parameters: ParameterClause.ParameterList + if elements.isEmpty && (lparen.isMissing || rparen.isMissing) { + parameters = ParameterClause.ParameterList(elements: [], arena: self.arena) + } else { + parameters = ParameterClause.ParameterList(elements: elements, arena: self.arena) + } + + return ParameterClause( + unexpectedBeforeLParen, + leftParen: lparen, + nil, + parameterList: parameters, + unexpectedBeforeRParen, + rightParen: rparen, + nil, + arena: self.arena + ) + } +} diff --git a/Sources/SwiftParser/generated/Parser+Entry.swift b/Sources/SwiftParser/generated/Parser+Entry.swift index d50bbd3e0fd..fae2fdabc5a 100644 --- a/Sources/SwiftParser/generated/Parser+Entry.swift +++ b/Sources/SwiftParser/generated/Parser+Entry.swift @@ -65,6 +65,14 @@ extension CatchClauseSyntax: SyntaxParseable { } } +extension ClosureParameterSyntax: SyntaxParseable { + public static func parse(from parser: inout Parser) -> Self { + let node = parser.parseClosureParameter() + let raw = RawSyntax(parser.parseRemainder(into: node)) + return Syntax(raw: raw).cast(Self.self) + } +} + extension DeclSyntax: SyntaxParseable { public static func parse(from parser: inout Parser) -> Self { let node = parser.parseDeclaration() @@ -73,6 +81,14 @@ extension DeclSyntax: SyntaxParseable { } } +extension EnumCaseParameterSyntax: SyntaxParseable { + public static func parse(from parser: inout Parser) -> Self { + let node = parser.parseEnumCaseParameter() + let raw = RawSyntax(parser.parseRemainder(into: node)) + return Syntax(raw: raw).cast(Self.self) + } +} + extension ExprSyntax: SyntaxParseable { public static func parse(from parser: inout Parser) -> Self { let node = parser.parseExpression() @@ -81,6 +97,14 @@ extension ExprSyntax: SyntaxParseable { } } +extension FunctionParameterSyntax: SyntaxParseable { + public static func parse(from parser: inout Parser) -> Self { + let node = parser.parseFunctionParameter() + let raw = RawSyntax(parser.parseRemainder(into: node)) + return Syntax(raw: raw).cast(Self.self) + } +} + extension GenericParameterClauseSyntax: SyntaxParseable { public static func parse(from parser: inout Parser) -> Self { let node = parser.parseGenericParameters() diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index 599164b8543..3b027427420 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -618,7 +618,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { exchangeTokens( unexpected: node.unexpectedBetweenModifiersAndFirstName, unexpectedTokenCondition: { TypeSpecifier(token: $0) != nil }, - correctTokens: [node.type?.as(AttributedTypeSyntax.self)?.specifier], + correctTokens: [node.type.as(AttributedTypeSyntax.self)?.specifier], message: { SpecifierOnParameterName(misplacedSpecifiers: $0) }, moveFixIt: { MoveTokensInFrontOfTypeFixIt(movedTokens: $0) }, removeRedundantFixIt: { RemoveRedundantFixIt(removeTokens: $0) } diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md index b38290bd76e..ef77edd0b94 100644 --- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md @@ -214,6 +214,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- - - - @@ -233,6 +235,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- - - - @@ -289,6 +293,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - @@ -303,6 +308,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - diff --git a/Sources/SwiftSyntax/generated/Misc.swift b/Sources/SwiftSyntax/generated/Misc.swift index 719a9414392..8d549a36a3a 100644 --- a/Sources/SwiftSyntax/generated/Misc.swift +++ b/Sources/SwiftSyntax/generated/Misc.swift @@ -63,6 +63,9 @@ extension Syntax { .node(ClosureExprSyntax.self), .node(ClosureParamListSyntax.self), .node(ClosureParamSyntax.self), + .node(ClosureParameterClauseSyntax.self), + .node(ClosureParameterListSyntax.self), + .node(ClosureParameterSyntax.self), .node(ClosureSignatureSyntax.self), .node(CodeBlockItemListSyntax.self), .node(CodeBlockItemSyntax.self), @@ -109,6 +112,9 @@ extension Syntax { .node(EnumCaseDeclSyntax.self), .node(EnumCaseElementListSyntax.self), .node(EnumCaseElementSyntax.self), + .node(EnumCaseParameterClauseSyntax.self), + .node(EnumCaseParameterListSyntax.self), + .node(EnumCaseParameterSyntax.self), .node(EnumDeclSyntax.self), .node(ExposeAttributeArgumentsSyntax.self), .node(ExprListSyntax.self), @@ -380,6 +386,12 @@ extension SyntaxKind { return ClosureParamListSyntax.self case .closureParam: return ClosureParamSyntax.self + case .closureParameterClause: + return ClosureParameterClauseSyntax.self + case .closureParameterList: + return ClosureParameterListSyntax.self + case .closureParameter: + return ClosureParameterSyntax.self case .closureSignature: return ClosureSignatureSyntax.self case .codeBlockItemList: @@ -472,6 +484,12 @@ extension SyntaxKind { return EnumCaseElementListSyntax.self case .enumCaseElement: return EnumCaseElementSyntax.self + case .enumCaseParameterClause: + return EnumCaseParameterClauseSyntax.self + case .enumCaseParameterList: + return EnumCaseParameterListSyntax.self + case .enumCaseParameter: + return EnumCaseParameterSyntax.self case .enumDecl: return EnumDeclSyntax.self case .exposeAttributeArguments: @@ -909,6 +927,12 @@ extension SyntaxKind { return nil case .closureParam: return "closure parameter" + case .closureParameterClause: + return "parameter clause" + case .closureParameterList: + return "parameter list" + case .closureParameter: + return "parameter" case .closureSignature: return "closure signature" case .codeBlockItemList: @@ -1001,6 +1025,12 @@ extension SyntaxKind { return nil case .enumCaseElement: return nil + case .enumCaseParameterClause: + return "parameter clause" + case .enumCaseParameterList: + return "parameter list" + case .enumCaseParameter: + return "parameter" case .enumDecl: return "enum" case .exposeAttributeArguments: diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 0cb0288b4ea..6132585baae 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -429,6 +429,30 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ClosureParameterClauseSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ClosureParameterClauseSyntax) { + visitAnyPost(node._syntaxNode) + } + + override open func visit(_ node: ClosureParameterListSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ClosureParameterListSyntax) { + visitAnyPost(node._syntaxNode) + } + + override open func visit(_ node: ClosureParameterSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ClosureParameterSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: ClosureSignatureSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -797,6 +821,30 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: EnumCaseParameterClauseSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: EnumCaseParameterClauseSyntax) { + visitAnyPost(node._syntaxNode) + } + + override open func visit(_ node: EnumCaseParameterListSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: EnumCaseParameterListSyntax) { + visitAnyPost(node._syntaxNode) + } + + override open func visit(_ node: EnumCaseParameterSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: EnumCaseParameterSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift index 3cbb358a64b..cb42686c965 100644 --- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift +++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift @@ -2433,6 +2433,221 @@ extension ClosureParamListSyntax: BidirectionalCollection { } } +/// `ClosureParameterListSyntax` represents a collection of one or more +/// `ClosureParameter` nodes. ClosureParameterListSyntax behaves +/// as a regular Swift collection, and has accessors that return new +/// versions of the collection with different children. +public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable { + public typealias Element = ClosureParameterSyntax + + public let _syntaxNode: Syntax + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + data.raw.layoutView! + } + + public init?(_ node: S) { + guard node.raw.kind == .closureParameterList else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a Syntax node from the provided root and data. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .closureParameterList) + self._syntaxNode = Syntax(data) + } + + public init(_ children: [Element]) { + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureParameterList, + from: children.map { + $0.raw + }, arena: arena) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + /// The number of elements, `present` or `missing`, in this collection. + public var count: Int { + return raw.layoutView!.children.count + } + + /// Creates a new `ClosureParameterListSyntax` by replacing the underlying layout with + /// a different set of raw syntax nodes. + /// + /// - Parameter layout: The new list of raw syntax nodes underlying this + /// collection. + /// - Returns: A new `ClosureParameterListSyntax` with the new layout underlying it. + internal func replacingLayout( + _ layout: [RawSyntax?]) -> ClosureParameterListSyntax { + let arena = SyntaxArena() + let newRaw = layoutView.replacingLayout(with: layout, arena: arena) + let newData = data.replacingSelf(newRaw, arena: arena) + return ClosureParameterListSyntax(newData) + } + + /// Creates a new `ClosureParameterListSyntax` by appending the provided syntax element + /// to the children. + /// + /// - Parameter syntax: The element to append. + /// - Returns: A new `ClosureParameterListSyntax` with that element appended to the end. + public func appending(_ syntax: Element) -> ClosureParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.append(syntax.raw) + return replacingLayout(newLayout) + } + + /// Creates a new `ClosureParameterListSyntax` by prepending the provided syntax element + /// to the children. + /// + /// - Parameter syntax: The element to prepend. + /// - Returns: A new `ClosureParameterListSyntax` with that element prepended to the + /// beginning. + public func prepending(_ syntax: Element) -> ClosureParameterListSyntax { + return inserting(syntax, at: 0) + } + + /// Creates a new `ClosureParameterListSyntax` by inserting the provided syntax element + /// at the provided index in the children. + /// + /// - Parameters: + /// - syntax: The element to insert. + /// - index: The index at which to insert the element in the collection. + /// + /// - Returns: A new `ClosureParameterListSyntax` with that element appended to the end. + public func inserting(_ syntax: Element, at index: Int) -> ClosureParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + /// Make sure the index is a valid insertion index (0 to 1 past the end) + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") + newLayout.insert(syntax.raw, at: index) + return replacingLayout(newLayout) + } + + /// Creates a new `ClosureParameterListSyntax` by replacing the syntax element + /// at the provided index. + /// + /// - Parameters: + /// - index: The index at which to replace the element in the collection. + /// - syntax: The element to replace with. + /// + /// - Returns: A new `ClosureParameterListSyntax` with the new element at the provided index. + public func replacing(childAt index: Int, with syntax: Element) -> ClosureParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + /// Make sure the index is a valid index for replacing + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") + newLayout[index] = syntax.raw + return replacingLayout(newLayout) + } + + /// Creates a new `ClosureParameterListSyntax` by removing the syntax element at the + /// provided index. + /// + /// - Parameter index: The index of the element to remove from the collection. + /// - Returns: A new `ClosureParameterListSyntax` with the element at the provided index + /// removed. + public func removing(childAt index: Int) -> ClosureParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.remove(at: index) + return replacingLayout(newLayout) + } + + /// Creates a new `ClosureParameterListSyntax` by removing the first element. + /// + /// - Returns: A new `ClosureParameterListSyntax` with the first element removed. + public func removingFirst() -> ClosureParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.removeFirst() + return replacingLayout(newLayout) + } + + /// Creates a new `ClosureParameterListSyntax` by removing the last element. + /// + /// - Returns: A new `ClosureParameterListSyntax` with the last element removed. + public func removingLast() -> ClosureParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.removeLast() + return replacingLayout(newLayout) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + return nil + } +} + +/// Conformance for `ClosureParameterListSyntax` to the `BidirectionalCollection` protocol. +extension ClosureParameterListSyntax: BidirectionalCollection { + public typealias Index = SyntaxChildrenIndex + + public struct Iterator: IteratorProtocol { + private let parent: Syntax + + private var iterator: RawSyntaxChildren.Iterator + + + init(parent: Syntax, rawChildren: RawSyntaxChildren) { + self.parent = parent + self.iterator = rawChildren.makeIterator() + } + + + public mutating func next() -> Element? { + guard let (raw, info) = self.iterator.next() else { + return nil + } + let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) + let data = SyntaxData(absoluteRaw, parent: parent) + return Element(data) + } + } + + public func makeIterator() -> Iterator { + return Iterator(parent: Syntax(self), rawChildren: rawChildren) + } + + private var rawChildren: RawSyntaxChildren { + // We know children in a syntax collection cannot be missing. So we can + // use the low-level and faster RawSyntaxChildren collection instead of + // NonNilRawSyntaxChildren. + return RawSyntaxChildren(self.data.absoluteRaw) + } + + public var startIndex: SyntaxChildrenIndex { + return rawChildren.startIndex + } + + public var endIndex: SyntaxChildrenIndex { + return rawChildren.endIndex + } + + public func index(after index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { + return rawChildren.index(after: index) + } + + public func index(before index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { + return rawChildren.index(before: index) + } + + public func distance(from start: SyntaxChildrenIndex, to end: SyntaxChildrenIndex) + -> Int { + return rawChildren.distance(from: start, to: end) + } + + public subscript (position: SyntaxChildrenIndex) -> Element { + let (raw, info) = rawChildren[position] + let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) + let data = SyntaxData(absoluteRaw, parent: Syntax(self)) + return Element(data) + } +} + /// `CodeBlockItemListSyntax` represents a collection of one or more /// `CodeBlockItem` nodes. CodeBlockItemListSyntax behaves /// as a regular Swift collection, and has accessors that return new @@ -4574,6 +4789,221 @@ extension EnumCaseElementListSyntax: BidirectionalCollection { } } +/// `EnumCaseParameterListSyntax` represents a collection of one or more +/// `EnumCaseParameter` nodes. EnumCaseParameterListSyntax behaves +/// as a regular Swift collection, and has accessors that return new +/// versions of the collection with different children. +public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable { + public typealias Element = EnumCaseParameterSyntax + + public let _syntaxNode: Syntax + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + data.raw.layoutView! + } + + public init?(_ node: S) { + guard node.raw.kind == .enumCaseParameterList else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a Syntax node from the provided root and data. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .enumCaseParameterList) + self._syntaxNode = Syntax(data) + } + + public init(_ children: [Element]) { + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseParameterList, + from: children.map { + $0.raw + }, arena: arena) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + /// The number of elements, `present` or `missing`, in this collection. + public var count: Int { + return raw.layoutView!.children.count + } + + /// Creates a new `EnumCaseParameterListSyntax` by replacing the underlying layout with + /// a different set of raw syntax nodes. + /// + /// - Parameter layout: The new list of raw syntax nodes underlying this + /// collection. + /// - Returns: A new `EnumCaseParameterListSyntax` with the new layout underlying it. + internal func replacingLayout( + _ layout: [RawSyntax?]) -> EnumCaseParameterListSyntax { + let arena = SyntaxArena() + let newRaw = layoutView.replacingLayout(with: layout, arena: arena) + let newData = data.replacingSelf(newRaw, arena: arena) + return EnumCaseParameterListSyntax(newData) + } + + /// Creates a new `EnumCaseParameterListSyntax` by appending the provided syntax element + /// to the children. + /// + /// - Parameter syntax: The element to append. + /// - Returns: A new `EnumCaseParameterListSyntax` with that element appended to the end. + public func appending(_ syntax: Element) -> EnumCaseParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.append(syntax.raw) + return replacingLayout(newLayout) + } + + /// Creates a new `EnumCaseParameterListSyntax` by prepending the provided syntax element + /// to the children. + /// + /// - Parameter syntax: The element to prepend. + /// - Returns: A new `EnumCaseParameterListSyntax` with that element prepended to the + /// beginning. + public func prepending(_ syntax: Element) -> EnumCaseParameterListSyntax { + return inserting(syntax, at: 0) + } + + /// Creates a new `EnumCaseParameterListSyntax` by inserting the provided syntax element + /// at the provided index in the children. + /// + /// - Parameters: + /// - syntax: The element to insert. + /// - index: The index at which to insert the element in the collection. + /// + /// - Returns: A new `EnumCaseParameterListSyntax` with that element appended to the end. + public func inserting(_ syntax: Element, at index: Int) -> EnumCaseParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + /// Make sure the index is a valid insertion index (0 to 1 past the end) + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") + newLayout.insert(syntax.raw, at: index) + return replacingLayout(newLayout) + } + + /// Creates a new `EnumCaseParameterListSyntax` by replacing the syntax element + /// at the provided index. + /// + /// - Parameters: + /// - index: The index at which to replace the element in the collection. + /// - syntax: The element to replace with. + /// + /// - Returns: A new `EnumCaseParameterListSyntax` with the new element at the provided index. + public func replacing(childAt index: Int, with syntax: Element) -> EnumCaseParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + /// Make sure the index is a valid index for replacing + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") + newLayout[index] = syntax.raw + return replacingLayout(newLayout) + } + + /// Creates a new `EnumCaseParameterListSyntax` by removing the syntax element at the + /// provided index. + /// + /// - Parameter index: The index of the element to remove from the collection. + /// - Returns: A new `EnumCaseParameterListSyntax` with the element at the provided index + /// removed. + public func removing(childAt index: Int) -> EnumCaseParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.remove(at: index) + return replacingLayout(newLayout) + } + + /// Creates a new `EnumCaseParameterListSyntax` by removing the first element. + /// + /// - Returns: A new `EnumCaseParameterListSyntax` with the first element removed. + public func removingFirst() -> EnumCaseParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.removeFirst() + return replacingLayout(newLayout) + } + + /// Creates a new `EnumCaseParameterListSyntax` by removing the last element. + /// + /// - Returns: A new `EnumCaseParameterListSyntax` with the last element removed. + public func removingLast() -> EnumCaseParameterListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.removeLast() + return replacingLayout(newLayout) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + return nil + } +} + +/// Conformance for `EnumCaseParameterListSyntax` to the `BidirectionalCollection` protocol. +extension EnumCaseParameterListSyntax: BidirectionalCollection { + public typealias Index = SyntaxChildrenIndex + + public struct Iterator: IteratorProtocol { + private let parent: Syntax + + private var iterator: RawSyntaxChildren.Iterator + + + init(parent: Syntax, rawChildren: RawSyntaxChildren) { + self.parent = parent + self.iterator = rawChildren.makeIterator() + } + + + public mutating func next() -> Element? { + guard let (raw, info) = self.iterator.next() else { + return nil + } + let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) + let data = SyntaxData(absoluteRaw, parent: parent) + return Element(data) + } + } + + public func makeIterator() -> Iterator { + return Iterator(parent: Syntax(self), rawChildren: rawChildren) + } + + private var rawChildren: RawSyntaxChildren { + // We know children in a syntax collection cannot be missing. So we can + // use the low-level and faster RawSyntaxChildren collection instead of + // NonNilRawSyntaxChildren. + return RawSyntaxChildren(self.data.absoluteRaw) + } + + public var startIndex: SyntaxChildrenIndex { + return rawChildren.startIndex + } + + public var endIndex: SyntaxChildrenIndex { + return rawChildren.endIndex + } + + public func index(after index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { + return rawChildren.index(after: index) + } + + public func index(before index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { + return rawChildren.index(before: index) + } + + public func distance(from start: SyntaxChildrenIndex, to end: SyntaxChildrenIndex) + -> Int { + return rawChildren.distance(from: start, to: end) + } + + public subscript (position: SyntaxChildrenIndex) -> Element { + let (raw, info) = rawChildren[position] + let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) + let data = SyntaxData(absoluteRaw, parent: Syntax(self)) + return Element(data) + } +} + /// A list of expressions connected by operators. This list is contained by a `SequenceExprSyntax`. public struct ExprListSyntax: SyntaxCollection, SyntaxHashable { public typealias Element = ExprSyntax @@ -10022,6 +10452,14 @@ extension ClosureParamListSyntax: CustomReflectable { } } +extension ClosureParameterListSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, unlabeledChildren: self.map { + $0 + }) + } +} + extension CodeBlockItemListSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, unlabeledChildren: self.map { @@ -10102,6 +10540,14 @@ extension EnumCaseElementListSyntax: CustomReflectable { } } +extension EnumCaseParameterListSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, unlabeledChildren: self.map { + $0 + }) + } +} + extension ExprListSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, unlabeledChildren: self.map { diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index 5a4479f31d2..5c4cb5c976e 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -63,6 +63,9 @@ public enum SyntaxEnum { case closureExpr(ClosureExprSyntax) case closureParamList(ClosureParamListSyntax) case closureParam(ClosureParamSyntax) + case closureParameterClause(ClosureParameterClauseSyntax) + case closureParameterList(ClosureParameterListSyntax) + case closureParameter(ClosureParameterSyntax) case closureSignature(ClosureSignatureSyntax) case codeBlockItemList(CodeBlockItemListSyntax) case codeBlockItem(CodeBlockItemSyntax) @@ -109,6 +112,9 @@ public enum SyntaxEnum { case enumCaseDecl(EnumCaseDeclSyntax) case enumCaseElementList(EnumCaseElementListSyntax) case enumCaseElement(EnumCaseElementSyntax) + case enumCaseParameterClause(EnumCaseParameterClauseSyntax) + case enumCaseParameterList(EnumCaseParameterListSyntax) + case enumCaseParameter(EnumCaseParameterSyntax) case enumDecl(EnumDeclSyntax) case exposeAttributeArguments(ExposeAttributeArgumentsSyntax) case exprList(ExprListSyntax) @@ -379,6 +385,12 @@ public extension Syntax { return .closureParamList(ClosureParamListSyntax(self)!) case .closureParam: return .closureParam(ClosureParamSyntax(self)!) + case .closureParameterClause: + return .closureParameterClause(ClosureParameterClauseSyntax(self)!) + case .closureParameterList: + return .closureParameterList(ClosureParameterListSyntax(self)!) + case .closureParameter: + return .closureParameter(ClosureParameterSyntax(self)!) case .closureSignature: return .closureSignature(ClosureSignatureSyntax(self)!) case .codeBlockItemList: @@ -471,6 +483,12 @@ public extension Syntax { return .enumCaseElementList(EnumCaseElementListSyntax(self)!) case .enumCaseElement: return .enumCaseElement(EnumCaseElementSyntax(self)!) + case .enumCaseParameterClause: + return .enumCaseParameterClause(EnumCaseParameterClauseSyntax(self)!) + case .enumCaseParameterList: + return .enumCaseParameterList(EnumCaseParameterListSyntax(self)!) + case .enumCaseParameter: + return .enumCaseParameter(EnumCaseParameterSyntax(self)!) case .enumDecl: return .enumDecl(EnumDeclSyntax(self)!) case .exposeAttributeArguments: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index b987c1412d3..983c8b5b057 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -63,6 +63,9 @@ public enum SyntaxKind { case closureExpr case closureParamList case closureParam + case closureParameterClause + case closureParameterList + case closureParameter case closureSignature case codeBlockItemList case codeBlockItem @@ -109,6 +112,9 @@ public enum SyntaxKind { case enumCaseDecl case enumCaseElementList case enumCaseElement + case enumCaseParameterClause + case enumCaseParameterList + case enumCaseParameter case enumDecl case exposeAttributeArguments case exprList @@ -302,6 +308,8 @@ public enum SyntaxKind { return true case .closureParamList: return true + case .closureParameterList: + return true case .codeBlockItemList: return true case .compositionTypeElementList: @@ -322,6 +330,8 @@ public enum SyntaxKind { return true case .enumCaseElementList: return true + case .enumCaseParameterList: + return true case .exprList: return true case .functionParameterList: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index d6d7ddfd545..ebe853136c2 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -354,6 +354,27 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(ClosureParamSyntax.self) } + /// Visit a `ClosureParameterClauseSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureParameterClauseSyntax) -> ClosureParameterClauseSyntax { + return Syntax(visitChildren(node)).cast(ClosureParameterClauseSyntax.self) + } + + /// Visit a `ClosureParameterListSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureParameterListSyntax) -> ClosureParameterListSyntax { + return Syntax(visitChildren(node)).cast(ClosureParameterListSyntax.self) + } + + /// Visit a `ClosureParameterSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureParameterSyntax) -> ClosureParameterSyntax { + return Syntax(visitChildren(node)).cast(ClosureParameterSyntax.self) + } + /// Visit a `ClosureSignatureSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -676,6 +697,27 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(EnumCaseElementSyntax.self) } + /// Visit a `EnumCaseParameterClauseSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseParameterClauseSyntax) -> EnumCaseParameterClauseSyntax { + return Syntax(visitChildren(node)).cast(EnumCaseParameterClauseSyntax.self) + } + + /// Visit a `EnumCaseParameterListSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseParameterListSyntax) -> EnumCaseParameterListSyntax { + return Syntax(visitChildren(node)).cast(EnumCaseParameterListSyntax.self) + } + + /// Visit a `EnumCaseParameterSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseParameterSyntax) -> EnumCaseParameterSyntax { + return Syntax(visitChildren(node)).cast(EnumCaseParameterSyntax.self) + } + /// Visit a `EnumDeclSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2584,6 +2626,48 @@ open class SyntaxRewriter { return Syntax(visit(node)) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplClosureParameterClauseSyntax(_ data: SyntaxData) -> Syntax { + let node = ClosureParameterClauseSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplClosureParameterListSyntax(_ data: SyntaxData) -> Syntax { + let node = ClosureParameterListSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplClosureParameterSyntax(_ data: SyntaxData) -> Syntax { + let node = ClosureParameterSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + /// Implementation detail of visit(_:). Do not call directly. private func visitImplClosureSignatureSyntax(_ data: SyntaxData) -> Syntax { let node = ClosureSignatureSyntax(data) @@ -3228,6 +3312,48 @@ open class SyntaxRewriter { return Syntax(visit(node)) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplEnumCaseParameterClauseSyntax(_ data: SyntaxData) -> Syntax { + let node = EnumCaseParameterClauseSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplEnumCaseParameterListSyntax(_ data: SyntaxData) -> Syntax { + let node = EnumCaseParameterListSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplEnumCaseParameterSyntax(_ data: SyntaxData) -> Syntax { + let node = EnumCaseParameterSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + /// Implementation detail of visit(_:). Do not call directly. private func visitImplEnumDeclSyntax(_ data: SyntaxData) -> Syntax { let node = EnumDeclSyntax(data) @@ -5716,6 +5842,12 @@ open class SyntaxRewriter { return visitImplClosureParamListSyntax case .closureParam: return visitImplClosureParamSyntax + case .closureParameterClause: + return visitImplClosureParameterClauseSyntax + case .closureParameterList: + return visitImplClosureParameterListSyntax + case .closureParameter: + return visitImplClosureParameterSyntax case .closureSignature: return visitImplClosureSignatureSyntax case .codeBlockItemList: @@ -5808,6 +5940,12 @@ open class SyntaxRewriter { return visitImplEnumCaseElementListSyntax case .enumCaseElement: return visitImplEnumCaseElementSyntax + case .enumCaseParameterClause: + return visitImplEnumCaseParameterClauseSyntax + case .enumCaseParameterList: + return visitImplEnumCaseParameterListSyntax + case .enumCaseParameter: + return visitImplEnumCaseParameterSyntax case .enumDecl: return visitImplEnumDeclSyntax case .exposeAttributeArguments: @@ -6248,6 +6386,12 @@ open class SyntaxRewriter { return visitImplClosureParamListSyntax(data) case .closureParam: return visitImplClosureParamSyntax(data) + case .closureParameterClause: + return visitImplClosureParameterClauseSyntax(data) + case .closureParameterList: + return visitImplClosureParameterListSyntax(data) + case .closureParameter: + return visitImplClosureParameterSyntax(data) case .closureSignature: return visitImplClosureSignatureSyntax(data) case .codeBlockItemList: @@ -6340,6 +6484,12 @@ open class SyntaxRewriter { return visitImplEnumCaseElementListSyntax(data) case .enumCaseElement: return visitImplEnumCaseElementSyntax(data) + case .enumCaseParameterClause: + return visitImplEnumCaseParameterClauseSyntax(data) + case .enumCaseParameterList: + return visitImplEnumCaseParameterListSyntax(data) + case .enumCaseParameter: + return visitImplEnumCaseParameterSyntax(data) case .enumDecl: return visitImplEnumDeclSyntax(data) case .exposeAttributeArguments: diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index fcd34c969af..e10e731d032 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -475,6 +475,10 @@ extension ClosureExprSyntax: BracedSyntax, WithStatementsSyntax {} extension ClosureParamSyntax: WithTrailingCommaSyntax {} +extension ClosureParameterClauseSyntax: ParenthesizedSyntax {} + +extension ClosureParameterSyntax: WithTrailingCommaSyntax {} + extension ClosureSignatureSyntax: AttributedSyntax {} extension CodeBlockSyntax: BracedSyntax, WithStatementsSyntax {} @@ -503,6 +507,10 @@ extension EnumCaseDeclSyntax: AttributedSyntax {} extension EnumCaseElementSyntax: WithTrailingCommaSyntax {} +extension EnumCaseParameterClauseSyntax: ParenthesizedSyntax {} + +extension EnumCaseParameterSyntax: WithTrailingCommaSyntax {} + extension EnumDeclSyntax: DeclGroupSyntax, IdentifiedDeclSyntax, AttributedSyntax {} extension ExpressionSegmentSyntax: ParenthesizedSyntax {} diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift index c3c9c5e14c8..613bdb25f96 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift @@ -254,6 +254,21 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ClosureParamSyntax) -> ResultType + /// Visiting `ClosureParameterClauseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: ClosureParameterClauseSyntax) -> ResultType + + /// Visiting `ClosureParameterListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: ClosureParameterListSyntax) -> ResultType + + /// Visiting `ClosureParameterSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: ClosureParameterSyntax) -> ResultType + /// Visiting `ClosureSignatureSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -484,6 +499,21 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: EnumCaseElementSyntax) -> ResultType + /// Visiting `EnumCaseParameterClauseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: EnumCaseParameterClauseSyntax) -> ResultType + + /// Visiting `EnumCaseParameterListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: EnumCaseParameterListSyntax) -> ResultType + + /// Visiting `EnumCaseParameterSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: EnumCaseParameterSyntax) -> ResultType + /// Visiting `EnumDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -1659,6 +1689,27 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } + /// Visiting `ClosureParameterClauseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: ClosureParameterClauseSyntax) -> ResultType { + visitAny(Syntax(node)) + } + + /// Visiting `ClosureParameterListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: ClosureParameterListSyntax) -> ResultType { + visitAny(Syntax(node)) + } + + /// Visiting `ClosureParameterSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: ClosureParameterSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `ClosureSignatureSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -1981,6 +2032,27 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } + /// Visiting `EnumCaseParameterClauseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: EnumCaseParameterClauseSyntax) -> ResultType { + visitAny(Syntax(node)) + } + + /// Visiting `EnumCaseParameterListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: EnumCaseParameterListSyntax) -> ResultType { + visitAny(Syntax(node)) + } + + /// Visiting `EnumCaseParameterSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: EnumCaseParameterSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `EnumDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -3255,6 +3327,12 @@ extension SyntaxTransformVisitor { return visit(derived) case .closureParam(let derived): return visit(derived) + case .closureParameterClause(let derived): + return visit(derived) + case .closureParameterList(let derived): + return visit(derived) + case .closureParameter(let derived): + return visit(derived) case .closureSignature(let derived): return visit(derived) case .codeBlockItemList(let derived): @@ -3347,6 +3425,12 @@ extension SyntaxTransformVisitor { return visit(derived) case .enumCaseElement(let derived): return visit(derived) + case .enumCaseParameterClause(let derived): + return visit(derived) + case .enumCaseParameterList(let derived): + return visit(derived) + case .enumCaseParameter(let derived): + return visit(derived) case .enumDecl(let derived): return visit(derived) case .exposeAttributeArguments(let derived): diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index 2bb7ede99ee..512c3bfd286 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -598,6 +598,42 @@ open class SyntaxVisitor { open func visitPost(_ node: ClosureParamSyntax) { } + /// Visiting `ClosureParameterClauseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ClosureParameterClauseSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `ClosureParameterClauseSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ClosureParameterClauseSyntax) { + } + + /// Visiting `ClosureParameterListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ClosureParameterListSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `ClosureParameterListSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ClosureParameterListSyntax) { + } + + /// Visiting `ClosureParameterSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ClosureParameterSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `ClosureParameterSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ClosureParameterSyntax) { + } + /// Visiting `ClosureSignatureSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1150,6 +1186,42 @@ open class SyntaxVisitor { open func visitPost(_ node: EnumCaseElementSyntax) { } + /// Visiting `EnumCaseParameterClauseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: EnumCaseParameterClauseSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `EnumCaseParameterClauseSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: EnumCaseParameterClauseSyntax) { + } + + /// Visiting `EnumCaseParameterListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: EnumCaseParameterListSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `EnumCaseParameterListSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: EnumCaseParameterListSyntax) { + } + + /// Visiting `EnumCaseParameterSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: EnumCaseParameterSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `EnumCaseParameterSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: EnumCaseParameterSyntax) { + } + /// Visiting `EnumDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -3695,6 +3767,39 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplClosureParameterClauseSyntax(_ data: SyntaxData) { + let node = ClosureParameterClauseSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplClosureParameterListSyntax(_ data: SyntaxData) { + let node = ClosureParameterListSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplClosureParameterSyntax(_ data: SyntaxData) { + let node = ClosureParameterSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + /// Implementation detail of doVisit(_:_:). Do not call directly. private func visitImplClosureSignatureSyntax(_ data: SyntaxData) { let node = ClosureSignatureSyntax(data) @@ -4201,6 +4306,39 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplEnumCaseParameterClauseSyntax(_ data: SyntaxData) { + let node = EnumCaseParameterClauseSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplEnumCaseParameterListSyntax(_ data: SyntaxData) { + let node = EnumCaseParameterListSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplEnumCaseParameterSyntax(_ data: SyntaxData) { + let node = EnumCaseParameterSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + /// Implementation detail of doVisit(_:_:). Do not call directly. private func visitImplEnumDeclSyntax(_ data: SyntaxData) { let node = EnumDeclSyntax(data) @@ -6150,6 +6288,12 @@ open class SyntaxVisitor { visitImplClosureParamListSyntax(data) case .closureParam: visitImplClosureParamSyntax(data) + case .closureParameterClause: + visitImplClosureParameterClauseSyntax(data) + case .closureParameterList: + visitImplClosureParameterListSyntax(data) + case .closureParameter: + visitImplClosureParameterSyntax(data) case .closureSignature: visitImplClosureSignatureSyntax(data) case .codeBlockItemList: @@ -6242,6 +6386,12 @@ open class SyntaxVisitor { visitImplEnumCaseElementListSyntax(data) case .enumCaseElement: visitImplEnumCaseElementSyntax(data) + case .enumCaseParameterClause: + visitImplEnumCaseParameterClauseSyntax(data) + case .enumCaseParameterList: + visitImplEnumCaseParameterListSyntax(data) + case .enumCaseParameter: + visitImplEnumCaseParameterSyntax(data) case .enumDecl: visitImplEnumDeclSyntax(data) case .exposeAttributeArguments: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift index 39c96776cae..808bedd2682 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift @@ -3882,15 +3882,289 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawClosureParameterClauseSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .closureParameterClause + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? = nil, + parameterList: RawClosureParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .closureParameterClause, uninitializedCount: 7, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeLeftParen?.raw + layout[1] = leftParen.raw + layout[2] = unexpectedBetweenLeftParenAndParameterList?.raw + layout[3] = parameterList.raw + layout[4] = unexpectedBetweenParameterListAndRightParen?.raw + layout[5] = rightParen.raw + layout[6] = unexpectedAfterRightParen?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var leftParen: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var parameterList: RawClosureParameterListSyntax { + layoutView.children[3].map(RawClosureParameterListSyntax.init(raw:))! + } + + public var unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var rightParen: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawClosureParameterListSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .closureParameterList + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init(elements: [RawClosureParameterSyntax], arena: __shared SyntaxArena) { + let raw = RawSyntax.makeLayout( + kind: .closureParameterList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } + for elem in elements { + ptr.initialize(to: elem.raw) + ptr += 1 + } + } + self.init(unchecked: raw) + } + + public var elements: [RawClosureParameterSyntax] { + layoutView.children.map { + RawClosureParameterSyntax(raw: $0!) + } + } +} + +@_spi(RawSyntax) +public struct RawClosureParameterSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .closureParameter + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? = nil, + firstName: RawTokenSyntax, + _ unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? = nil, + secondName: RawTokenSyntax?, + _ unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax?, + _ unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? = nil, + type: RawTypeSyntax?, + _ unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? = nil, + ellipsis: RawTokenSyntax?, + _ unexpectedBetweenEllipsisAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .closureParameter, uninitializedCount: 17, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers?.raw + layout[4] = unexpectedBetweenModifiersAndFirstName?.raw + layout[5] = firstName.raw + layout[6] = unexpectedBetweenFirstNameAndSecondName?.raw + layout[7] = secondName?.raw + layout[8] = unexpectedBetweenSecondNameAndColon?.raw + layout[9] = colon?.raw + layout[10] = unexpectedBetweenColonAndType?.raw + layout[11] = type?.raw + layout[12] = unexpectedBetweenTypeAndEllipsis?.raw + layout[13] = ellipsis?.raw + layout[14] = unexpectedBetweenEllipsisAndTrailingComma?.raw + layout[15] = trailingComma?.raw + layout[16] = unexpectedAfterTrailingComma?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + } + + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + } + + public var unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var firstName: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var secondName: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var colon: RawTokenSyntax? { + layoutView.children[9].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var type: RawTypeSyntax? { + layoutView.children[11].map(RawTypeSyntax.init(raw:)) + } + + public var unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var ellipsis: RawTokenSyntax? { + layoutView.children[13].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenEllipsisAndTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var trailingComma: RawTokenSyntax? { + layoutView.children[15].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { @frozen // FIXME: Not actually stable, works around a miscompile public enum Input: RawSyntaxNodeProtocol { case `simpleInput`(RawClosureParamListSyntax) - case `input`(RawParameterClauseSyntax) + case `input`(RawClosureParameterClauseSyntax) public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawClosureParamListSyntax.isKindOf(raw) || RawParameterClauseSyntax.isKindOf(raw) + return RawClosureParamListSyntax.isKindOf(raw) || RawClosureParameterClauseSyntax.isKindOf(raw) } public var raw: RawSyntax { @@ -3907,7 +4181,7 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { self = .simpleInput(node) return } - if let node = RawParameterClauseSyntax(other) { + if let node = RawClosureParameterClauseSyntax(other) { self = .input(node) return } @@ -7495,7 +7769,7 @@ public struct RawEnumCaseElementSyntax: RawSyntaxNodeProtocol { _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, identifier: RawTokenSyntax, _ unexpectedBetweenIdentifierAndAssociatedValue: RawUnexpectedNodesSyntax? = nil, - associatedValue: RawParameterClauseSyntax?, + associatedValue: RawEnumCaseParameterClauseSyntax?, _ unexpectedBetweenAssociatedValueAndRawValue: RawUnexpectedNodesSyntax? = nil, rawValue: RawInitializerClauseSyntax?, _ unexpectedBetweenRawValueAndTrailingComma: RawUnexpectedNodesSyntax? = nil, @@ -7531,8 +7805,8 @@ public struct RawEnumCaseElementSyntax: RawSyntaxNodeProtocol { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var associatedValue: RawParameterClauseSyntax? { - layoutView.children[3].map(RawParameterClauseSyntax.init(raw:)) + public var associatedValue: RawEnumCaseParameterClauseSyntax? { + layoutView.children[3].map(RawEnumCaseParameterClauseSyntax.init(raw:)) } public var unexpectedBetweenAssociatedValueAndRawValue: RawUnexpectedNodesSyntax? { @@ -7556,6 +7830,268 @@ public struct RawEnumCaseElementSyntax: RawSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawEnumCaseParameterClauseSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .enumCaseParameterClause + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? = nil, + parameterList: RawEnumCaseParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .enumCaseParameterClause, uninitializedCount: 7, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeLeftParen?.raw + layout[1] = leftParen.raw + layout[2] = unexpectedBetweenLeftParenAndParameterList?.raw + layout[3] = parameterList.raw + layout[4] = unexpectedBetweenParameterListAndRightParen?.raw + layout[5] = rightParen.raw + layout[6] = unexpectedAfterRightParen?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var leftParen: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var parameterList: RawEnumCaseParameterListSyntax { + layoutView.children[3].map(RawEnumCaseParameterListSyntax.init(raw:))! + } + + public var unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var rightParen: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawEnumCaseParameterListSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .enumCaseParameterList + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init(elements: [RawEnumCaseParameterSyntax], arena: __shared SyntaxArena) { + let raw = RawSyntax.makeLayout( + kind: .enumCaseParameterList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } + for elem in elements { + ptr.initialize(to: elem.raw) + ptr += 1 + } + } + self.init(unchecked: raw) + } + + public var elements: [RawEnumCaseParameterSyntax] { + layoutView.children.map { + RawEnumCaseParameterSyntax(raw: $0!) + } + } +} + +@_spi(RawSyntax) +public struct RawEnumCaseParameterSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .enumCaseParameter + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? = nil, + firstName: RawTokenSyntax?, + _ unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? = nil, + secondName: RawTokenSyntax?, + _ unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax?, + _ unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? = nil, + type: RawTypeSyntax, + _ unexpectedBetweenTypeAndDefaultArgument: RawUnexpectedNodesSyntax? = nil, + defaultArgument: RawInitializerClauseSyntax?, + _ unexpectedBetweenDefaultArgumentAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .enumCaseParameter, uninitializedCount: 15, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeModifiers?.raw + layout[1] = modifiers?.raw + layout[2] = unexpectedBetweenModifiersAndFirstName?.raw + layout[3] = firstName?.raw + layout[4] = unexpectedBetweenFirstNameAndSecondName?.raw + layout[5] = secondName?.raw + layout[6] = unexpectedBetweenSecondNameAndColon?.raw + layout[7] = colon?.raw + layout[8] = unexpectedBetweenColonAndType?.raw + layout[9] = type.raw + layout[10] = unexpectedBetweenTypeAndDefaultArgument?.raw + layout[11] = defaultArgument?.raw + layout[12] = unexpectedBetweenDefaultArgumentAndTrailingComma?.raw + layout[13] = trailingComma?.raw + layout[14] = unexpectedAfterTrailingComma?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeModifiers: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var modifiers: RawModifierListSyntax? { + layoutView.children[1].map(RawModifierListSyntax.init(raw:)) + } + + public var unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var firstName: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var secondName: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var colon: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var type: RawTypeSyntax { + layoutView.children[9].map(RawTypeSyntax.init(raw:))! + } + + public var unexpectedBetweenTypeAndDefaultArgument: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var defaultArgument: RawInitializerClauseSyntax? { + layoutView.children[11].map(RawInitializerClauseSyntax.init(raw:)) + } + + public var unexpectedBetweenDefaultArgumentAndTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var trailingComma: RawTokenSyntax? { + layoutView.children[13].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) @@ -8988,13 +9524,13 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, modifiers: RawModifierListSyntax?, _ unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? = nil, - firstName: RawTokenSyntax?, + firstName: RawTokenSyntax, _ unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? = nil, secondName: RawTokenSyntax?, _ unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax?, + colon: RawTokenSyntax, _ unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? = nil, - type: RawTypeSyntax?, + type: RawTypeSyntax, _ unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? = nil, ellipsis: RawTokenSyntax?, _ unexpectedBetweenEllipsisAndDefaultArgument: RawUnexpectedNodesSyntax? = nil, @@ -9012,13 +9548,13 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { layout[2] = unexpectedBetweenAttributesAndModifiers?.raw layout[3] = modifiers?.raw layout[4] = unexpectedBetweenModifiersAndFirstName?.raw - layout[5] = firstName?.raw + layout[5] = firstName.raw layout[6] = unexpectedBetweenFirstNameAndSecondName?.raw layout[7] = secondName?.raw layout[8] = unexpectedBetweenSecondNameAndColon?.raw - layout[9] = colon?.raw + layout[9] = colon.raw layout[10] = unexpectedBetweenColonAndType?.raw - layout[11] = type?.raw + layout[11] = type.raw layout[12] = unexpectedBetweenTypeAndEllipsis?.raw layout[13] = ellipsis?.raw layout[14] = unexpectedBetweenEllipsisAndDefaultArgument?.raw @@ -9050,8 +9586,8 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var firstName: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) + public var firstName: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } public var unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? { @@ -9066,16 +9602,16 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var colon: RawTokenSyntax? { - layoutView.children[9].map(RawTokenSyntax.init(raw:)) + public var colon: RawTokenSyntax { + layoutView.children[9].map(RawTokenSyntax.init(raw:))! } public var unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var type: RawTypeSyntax? { - layoutView.children[11].map(RawTypeSyntax.init(raw:)) + public var type: RawTypeSyntax { + layoutView.children[11].map(RawTypeSyntax.init(raw:))! } public var unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index c6acf9c5120..cf2195e71e9 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -640,6 +640,38 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + case .closureParameterClause: + assert(layout.count == 7) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawClosureParameterListSyntax.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 .closureParameterList: + for (index, element) in layout.enumerated() { + assertNoError(kind, index, verify(element, as: RawClosureParameterSyntax.self)) + } + case .closureParameter: + assert(layout.count == 17) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax?.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawModifierListSyntax?.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier), .tokenKind(.wildcard)])) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.identifier), .tokenKind(.wildcard)])) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.colon)])) + assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 11, verify(layout[11], as: RawTypeSyntax?.self)) + assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 13, verify(layout[13], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.ellipsis)])) + assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 15, verify(layout[15], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) + assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) case .closureSignature: assert(layout.count == 13) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1034,12 +1066,42 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawParameterClauseSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawEnumCaseParameterClauseSyntax?.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 5, verify(layout[5], as: RawInitializerClauseSyntax?.self)) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + case .enumCaseParameterClause: + assert(layout.count == 7) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawEnumCaseParameterListSyntax.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 .enumCaseParameterList: + for (index, element) in layout.enumerated() { + assertNoError(kind, index, verify(element, as: RawEnumCaseParameterSyntax.self)) + } + case .enumCaseParameter: + assert(layout.count == 15) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawModifierListSyntax?.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.identifier), .tokenKind(.wildcard)])) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.identifier), .tokenKind(.wildcard)])) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.colon)])) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 9, verify(layout[9], as: RawTypeSyntax.self)) + assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 11, verify(layout[11], as: RawInitializerClauseSyntax?.self)) + assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 13, verify(layout[13], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)])) + assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) case .enumDecl: assert(layout.count == 17) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1209,13 +1271,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 3, verify(layout[3], as: RawModifierListSyntax?.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.identifier), .tokenKind(.wildcard)])) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier), .tokenKind(.wildcard)])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.identifier), .tokenKind(.wildcard)])) assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.colon)])) + assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.colon)])) assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 11, verify(layout[11], as: RawTypeSyntax?.self)) + assertNoError(kind, 11, verify(layout[11], as: RawTypeSyntax.self)) assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 13, verify(layout[13], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.ellipsis)])) assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift index 763b01838d5..0cb72a6bea8 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift @@ -3910,19 +3910,988 @@ extension ClosureParamSyntax: CustomReflectable { } } +// MARK: - ClosureParameterClauseSyntax + + +public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .closureParameterClause else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `ClosureParameterClauseSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .closureParameterClause) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, + parameterList: ClosureParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeLeftParen, + leftParen, + unexpectedBetweenLeftParenAndParameterList, + parameterList, + unexpectedBetweenParameterListAndRightParen, + rightParen, + unexpectedAfterRightParen + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndParameterList?.raw, + parameterList.raw, + unexpectedBetweenParameterListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.closureParameterClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The '(' to open the parameter clause. + public var leftParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = ClosureParameterClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The actual parameters. + public var parameterList: ClosureParameterListSyntax { + get { + return ClosureParameterListSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = ClosureParameterClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `Parameter` to the node's `parameterList` + /// collection. + /// - param element: The new `Parameter` to add to the node's + /// `parameterList` collection. + /// - returns: A copy of the receiver with the provided `Parameter` + /// appended to its `parameterList` collection. + public func addParameter(_ element: ClosureParameterSyntax) -> ClosureParameterClauseSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.closureParameterList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return ClosureParameterClauseSyntax(newData) + } + + public var unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The ')' to close the parameter clause. + public var rightParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = ClosureParameterClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndParameterList, + \Self.parameterList, + \Self.unexpectedBetweenParameterListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + case 3: + return "parameters" + case 4: + return nil + case 5: + return nil + case 6: + return nil + default: + fatalError("Invalid index") + } + } +} + +extension ClosureParameterClauseSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndParameterList": unexpectedBetweenLeftParenAndParameterList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "parameterList": Syntax(parameterList).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenParameterListAndRightParen": unexpectedBetweenParameterListAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + ]) + } +} + +// MARK: - ClosureParameterSyntax + + +public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .closureParameter else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `ClosureParameterSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .closureParameter) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T? = nil, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeAttributes, + attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers, + unexpectedBetweenModifiersAndFirstName, + firstName, + unexpectedBetweenFirstNameAndSecondName, + secondName, + unexpectedBetweenSecondNameAndColon, + colon, + unexpectedBetweenColonAndType, + type, + unexpectedBetweenTypeAndEllipsis, + ellipsis, + unexpectedBetweenEllipsisAndTrailingComma, + trailingComma, + unexpectedAfterTrailingComma + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeAttributes?.raw, + attributes?.raw, + unexpectedBetweenAttributesAndModifiers?.raw, + modifiers?.raw, + unexpectedBetweenModifiersAndFirstName?.raw, + firstName.raw, + unexpectedBetweenFirstNameAndSecondName?.raw, + secondName?.raw, + unexpectedBetweenSecondNameAndColon?.raw, + colon?.raw, + unexpectedBetweenColonAndType?.raw, + type?.raw, + unexpectedBetweenTypeAndEllipsis?.raw, + ellipsis?.raw, + unexpectedBetweenEllipsisAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.closureParameter, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + /// This initializer exists solely because Swift 5.6 does not support + /// `Optional.none` as a default value of a generic parameter. + /// The above initializer thus defaults to `nil` instead, but that means it + /// is not actually callable when either not passing the defaulted parameter, + /// or passing `nil`. + /// + /// Hack around that limitation using this initializer, which takes a + /// `Missing*` syntax node instead. `Missing*` is used over the base type as + /// the base type would allow implicit conversion from a string literal, + /// which the above initializer doesn't support. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: MissingTypeSyntax? = nil, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndFirstName, + firstName: firstName, + unexpectedBetweenFirstNameAndSecondName, + secondName: secondName, + unexpectedBetweenSecondNameAndColon, + colon: colon, + unexpectedBetweenColonAndType, + type: Optional.none, + unexpectedBetweenTypeAndEllipsis, + ellipsis: ellipsis, + unexpectedBetweenEllipsisAndTrailingComma, + trailingComma: trailingComma, + unexpectedAfterTrailingComma, + trailingTrivia: trailingTrivia + ) + } + + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var attributes: AttributeListSyntax? { + get { + return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `Attribute` to the node's `attributes` + /// collection. + /// - param element: The new `Attribute` to add to the node's + /// `attributes` collection. + /// - returns: A copy of the receiver with the provided `Attribute` + /// appended to its `attributes` collection. + public func addAttribute(_ element: Syntax) -> ClosureParameterSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[1] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return ClosureParameterSyntax(newData) + } + + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var modifiers: ModifierListSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(ModifierListSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `Modifier` to the node's `modifiers` + /// collection. + /// - param element: The new `Modifier` to add to the node's + /// `modifiers` collection. + /// - returns: A copy of the receiver with the provided `Modifier` + /// appended to its `modifiers` collection. + public func addModifier(_ element: DeclModifierSyntax) -> ClosureParameterSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return ClosureParameterSyntax(newData) + } + + public var unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The label of this parameter that will be used when the closure is called. + public var firstName: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + /// If this is specified, it is the name by which the parameter can be referenced inside the closure body. If it is `nil`, the closure parameter is referenced by the first name. + public var secondName: TokenSyntax? { + get { + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The colon separating the parameter's name and type. + public var colon: TokenSyntax? { + get { + return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenColonAndType: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The type of the parameter. + public var type: TypeSyntax? { + get { + return data.child(at: 11, parent: Syntax(self)).map(TypeSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? { + get { + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + } + } + + /// If the parameter is variadic, `...` to indicate that. + public var ellipsis: TokenSyntax? { + get { + return data.child(at: 13, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenEllipsisAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) + } + } + + /// If the parameter is followed by another parameter, the comma separating them. + public var trailingComma: TokenSyntax? { + get { + return data.child(at: 15, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 15, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 16, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureParameterSyntax(data.replacingChild(at: 16, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndModifiers, + \Self.modifiers, + \Self.unexpectedBetweenModifiersAndFirstName, + \Self.firstName, + \Self.unexpectedBetweenFirstNameAndSecondName, + \Self.secondName, + \Self.unexpectedBetweenSecondNameAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndType, + \Self.type, + \Self.unexpectedBetweenTypeAndEllipsis, + \Self.ellipsis, + \Self.unexpectedBetweenEllipsisAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return "attributes" + case 2: + return nil + case 3: + return "modifiers" + case 4: + return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil + case 11: + return "type" + case 12: + return nil + case 13: + return nil + case 14: + return nil + case 15: + return nil + case 16: + return nil + default: + fatalError("Invalid index") + } + } +} + +extension ClosureParameterSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeAttributes": unexpectedBeforeAttributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "attributes": attributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenAttributesAndModifiers": unexpectedBetweenAttributesAndModifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "modifiers": modifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenModifiersAndFirstName": unexpectedBetweenModifiersAndFirstName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "firstName": Syntax(firstName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenFirstNameAndSecondName": unexpectedBetweenFirstNameAndSecondName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "secondName": secondName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenSecondNameAndColon": unexpectedBetweenSecondNameAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenColonAndType": unexpectedBetweenColonAndType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "type": type.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenTypeAndEllipsis": unexpectedBetweenTypeAndEllipsis.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "ellipsis": ellipsis.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenEllipsisAndTrailingComma": unexpectedBetweenEllipsisAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + ]) + } +} + // MARK: - ClosureSignatureSyntax -public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { - public enum Input: SyntaxChildChoices { - case `simpleInput`(ClosureParamListSyntax) - case `input`(ParameterClauseSyntax) +public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { + public enum Input: SyntaxChildChoices { + case `simpleInput`(ClosureParamListSyntax) + case `input`(ClosureParameterClauseSyntax) + + public var _syntaxNode: Syntax { + switch self { + case .simpleInput(let node): + return node._syntaxNode + case .input(let node): + return node._syntaxNode + } + } + + init(_ data: SyntaxData) { + self.init(Syntax(data))! + } + + public init(_ node: ClosureParamListSyntax) { + self = .simpleInput(node) + } + + public init(_ node: ClosureParameterClauseSyntax) { + self = .input(node) + } + + public init?(_ node: S) { + if let node = node.as(ClosureParamListSyntax.self) { + self = .simpleInput(node) + return + } + if let node = node.as(ClosureParameterClauseSyntax.self) { + self = .input(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([.node(ClosureParamListSyntax.self), .node(ClosureParameterClauseSyntax.self)]) + } + } + + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .closureSignature else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `ClosureSignatureSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .closureSignature) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? = nil, + capture: ClosureCaptureSignatureSyntax? = nil, + _ unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? = nil, + input: Input? = nil, + _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, + output: ReturnClauseSyntax? = nil, + _ unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? = nil, + inTok: TokenSyntax = .keyword(.in), + _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeAttributes, + attributes, + unexpectedBetweenAttributesAndCapture, + capture, + unexpectedBetweenCaptureAndInput, + input, + unexpectedBetweenInputAndEffectSpecifiers, + effectSpecifiers, + unexpectedBetweenEffectSpecifiersAndOutput, + output, + unexpectedBetweenOutputAndInTok, + inTok, + unexpectedAfterInTok + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeAttributes?.raw, + attributes?.raw, + unexpectedBetweenAttributesAndCapture?.raw, + capture?.raw, + unexpectedBetweenCaptureAndInput?.raw, + input?.raw, + unexpectedBetweenInputAndEffectSpecifiers?.raw, + effectSpecifiers?.raw, + unexpectedBetweenEffectSpecifiersAndOutput?.raw, + output?.raw, + unexpectedBetweenOutputAndInTok?.raw, + inTok.raw, + unexpectedAfterInTok?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.closureSignature, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var attributes: AttributeListSyntax? { + get { + return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `Attribute` to the node's `attributes` + /// collection. + /// - param element: The new `Attribute` to add to the node's + /// `attributes` collection. + /// - returns: A copy of the receiver with the provided `Attribute` + /// appended to its `attributes` collection. + public func addAttribute(_ element: Syntax) -> ClosureSignatureSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[1] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return ClosureSignatureSyntax(newData) + } + + public var unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var capture: ClosureCaptureSignatureSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(ClosureCaptureSignatureSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var input: Input? { + get { + return data.child(at: 5, parent: Syntax(self)).map(Input.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var effectSpecifiers: TypeEffectSpecifiersSyntax? { + get { + return data.child(at: 7, parent: Syntax(self)).map(TypeEffectSpecifiersSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var output: ReturnClauseSyntax? { + get { + return data.child(at: 9, parent: Syntax(self)).map(ReturnClauseSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + } + } + + public var inTok: TokenSyntax { + get { + return TokenSyntax(data.child(at: 11, parent: Syntax(self))!) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 11, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterInTok: UnexpectedNodesSyntax? { + get { + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndCapture, + \Self.capture, + \Self.unexpectedBetweenCaptureAndInput, + \Self.input, + \Self.unexpectedBetweenInputAndEffectSpecifiers, + \Self.effectSpecifiers, + \Self.unexpectedBetweenEffectSpecifiersAndOutput, + \Self.output, + \Self.unexpectedBetweenOutputAndInTok, + \Self.inTok, + \Self.unexpectedAfterInTok + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return "attributes" + case 2: + return nil + case 3: + return nil + case 4: + return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil + case 11: + return nil + case 12: + return nil + default: + fatalError("Invalid index") + } + } +} + +extension ClosureSignatureSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeAttributes": unexpectedBeforeAttributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "attributes": attributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenAttributesAndCapture": unexpectedBetweenAttributesAndCapture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "capture": capture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenCaptureAndInput": unexpectedBetweenCaptureAndInput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "input": input.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenInputAndEffectSpecifiers": unexpectedBetweenInputAndEffectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "effectSpecifiers": effectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenEffectSpecifiersAndOutput": unexpectedBetweenEffectSpecifiersAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenOutputAndInTok": unexpectedBetweenOutputAndInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "inTok": Syntax(inTok).asProtocol(SyntaxProtocol.self), + "unexpectedAfterInTok": unexpectedAfterInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + ]) + } +} + +// MARK: - CodeBlockItemSyntax + +/// A CodeBlockItem is any Syntax node that appears on its own line inside a CodeBlock. +public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { + public enum Item: SyntaxChildChoices { + case `decl`(DeclSyntax) + case `stmt`(StmtSyntax) + case `expr`(ExprSyntax) public var _syntaxNode: Syntax { switch self { - case .simpleInput(let node): + case .decl(let node): return node._syntaxNode - case .input(let node): + case .stmt(let node): + return node._syntaxNode + case .expr(let node): return node._syntaxNode } } @@ -3931,100 +4900,236 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { self.init(Syntax(data))! } - public init(_ node: ClosureParamListSyntax) { - self = .simpleInput(node) + public init(_ node: Node) { + self = .decl(DeclSyntax(node)) } - public init(_ node: ParameterClauseSyntax) { - self = .input(node) + public init(_ node: Node) { + self = .stmt(StmtSyntax(node)) + } + + public init(_ node: Node) { + self = .expr(ExprSyntax(node)) } public init?(_ node: S) { - if let node = node.as(ClosureParamListSyntax.self) { - self = .simpleInput(node) + if let node = node.as(DeclSyntax.self) { + self = .decl(node) return } - if let node = node.as(ParameterClauseSyntax.self) { - self = .input(node) + if let node = node.as(StmtSyntax.self) { + self = .stmt(node) + return + } + if let node = node.as(ExprSyntax.self) { + self = .expr(node) return } return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([.node(ClosureParamListSyntax.self), .node(ParameterClauseSyntax.self)]) + } + + public static var structure: SyntaxNodeStructure { + return .choices([.node(DeclSyntax.self), .node(StmtSyntax.self), .node(ExprSyntax.self)]) + } + } + + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .codeBlockItem else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `CodeBlockItemSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .codeBlockItem) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeItem: UnexpectedNodesSyntax? = nil, + item: Item, + _ unexpectedBetweenItemAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax? = nil, + _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeItem, + item, + unexpectedBetweenItemAndSemicolon, + semicolon, + unexpectedAfterSemicolon + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeItem?.raw, + item.raw, + unexpectedBetweenItemAndSemicolon?.raw, + semicolon?.raw, + unexpectedAfterSemicolon?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.codeBlockItem, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeItem: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = CodeBlockItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The underlying node inside the code block. + public var item: Item { + get { + return Item(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = CodeBlockItemSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenItemAndSemicolon: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = CodeBlockItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + /// If present, the trailing semicolon at the end of the item. + public var semicolon: TokenSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = CodeBlockItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = CodeBlockItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeItem, + \Self.item, + \Self.unexpectedBetweenItemAndSemicolon, + \Self.semicolon, + \Self.unexpectedAfterSemicolon + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + case 3: + return nil + case 4: + return nil + default: + fatalError("Invalid index") } } - +} + +extension CodeBlockItemSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeItem": unexpectedBeforeItem.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "item": Syntax(item).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenItemAndSemicolon": unexpectedBetweenItemAndSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "semicolon": semicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterSemicolon": unexpectedAfterSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + ]) + } +} + +// MARK: - CodeBlockSyntax + + +public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureSignature else { + guard node.raw.kind == .codeBlock else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureSignatureSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `CodeBlockSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .closureSignature) + precondition(data.raw.kind == .codeBlock) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? = nil, - capture: ClosureCaptureSignatureSyntax? = nil, - _ unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? = nil, - input: Input? = nil, - _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax? = nil, - _ unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? = nil, - inTok: TokenSyntax = .keyword(.in), - _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndCapture, - capture, - unexpectedBetweenCaptureAndInput, - input, - unexpectedBetweenInputAndEffectSpecifiers, - effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndOutput, - output, - unexpectedBetweenOutputAndInTok, - inTok, - unexpectedAfterInTok + unexpectedBeforeLeftBrace, + leftBrace, + unexpectedBetweenLeftBraceAndStatements, + statements, + unexpectedBetweenStatementsAndRightBrace, + rightBrace, + unexpectedAfterRightBrace ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes?.raw, - unexpectedBetweenAttributesAndCapture?.raw, - capture?.raw, - unexpectedBetweenCaptureAndInput?.raw, - input?.raw, - unexpectedBetweenInputAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndOutput?.raw, - output?.raw, - unexpectedBetweenOutputAndInTok?.raw, - inTok.raw, - unexpectedAfterInTok?.raw + unexpectedBeforeLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndStatements?.raw, + statements.raw, + unexpectedBetweenStatementsAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureSignature, + kind: SyntaxKind.codeBlock, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -4035,157 +5140,247 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = CodeBlockSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var attributes: AttributeListSyntax? { + public var leftBrace: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) - } - } - - /// Adds the provided `Attribute` to the node's `attributes` - /// collection. - /// - param element: The new `Attribute` to add to the node's - /// `attributes` collection. - /// - returns: A copy of the receiver with the provided `Attribute` - /// appended to its `attributes` collection. - public func addAttribute(_ element: Syntax) -> ClosureSignatureSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[1] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + self = CodeBlockSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 1, with: collection, arena: arena) - return ClosureSignatureSyntax(newData) } - public var unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndStatements: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = CodeBlockSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var capture: ClosureCaptureSignatureSyntax? { + public var statements: CodeBlockItemListSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(ClosureCaptureSignatureSyntax.init) + return CodeBlockItemListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = CodeBlockSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? { + /// Adds the provided `Statement` to the node's `statements` + /// collection. + /// - param element: The new `Statement` to add to the node's + /// `statements` collection. + /// - returns: A copy of the receiver with the provided `Statement` + /// appended to its `statements` collection. + public func addStatement(_ element: CodeBlockItemSyntax) -> CodeBlockSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return CodeBlockSyntax(newData) + } + + public var unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = CodeBlockSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var input: Input? { + public var rightBrace: TokenSyntax { get { - return data.child(at: 5, parent: Syntax(self)).map(Input.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = CodeBlockSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? { + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = CodeBlockSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var effectSpecifiers: TypeEffectSpecifiersSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TypeEffectSpecifiersSyntax.init) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndStatements, + \Self.statements, + \Self.unexpectedBetweenStatementsAndRightBrace, + \Self.rightBrace, + \Self.unexpectedAfterRightBrace + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + case 3: + return "statements" + case 4: + return nil + case 5: + return nil + case 6: + return nil + default: + fatalError("Invalid index") } - set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } +} + +extension CodeBlockSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeLeftBrace": unexpectedBeforeLeftBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "leftBrace": Syntax(leftBrace).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftBraceAndStatements": unexpectedBetweenLeftBraceAndStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenStatementsAndRightBrace": unexpectedBetweenStatementsAndRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "rightBrace": Syntax(rightBrace).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightBrace": unexpectedAfterRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + ]) + } +} + +// MARK: - CompositionTypeElementSyntax + + +public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .compositionTypeElement else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `CompositionTypeElementSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + precondition(data.raw.kind == .compositionTypeElement) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndAmpersand: UnexpectedNodesSyntax? = nil, + ampersand: TokenSyntax? = nil, + _ unexpectedAfterAmpersand: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeType, + type, + unexpectedBetweenTypeAndAmpersand, + ampersand, + unexpectedAfterAmpersand + ))) {(arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeType?.raw, + type.raw, + unexpectedBetweenTypeAndAmpersand?.raw, + ampersand?.raw, + unexpectedAfterAmpersand?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.compositionTypeElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return SyntaxData.forRoot(raw) } + self.init(data) } - public var unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? { + public var unexpectedBeforeType: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = CompositionTypeElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var output: ReturnClauseSyntax? { + public var type: TypeSyntax { get { - return data.child(at: 9, parent: Syntax(self)).map(ReturnClauseSyntax.init) + return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + self = CompositionTypeElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAndAmpersand: UnexpectedNodesSyntax? { get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = CompositionTypeElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var inTok: TokenSyntax { + public var ampersand: TokenSyntax? { get { - return TokenSyntax(data.child(at: 11, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 11, with: value.raw, arena: SyntaxArena())) + self = CompositionTypeElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterInTok: UnexpectedNodesSyntax? { + public var unexpectedAfterAmpersand: UnexpectedNodesSyntax? { get { - return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + self = CompositionTypeElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndCapture, - \Self.capture, - \Self.unexpectedBetweenCaptureAndInput, - \Self.input, - \Self.unexpectedBetweenInputAndEffectSpecifiers, - \Self.effectSpecifiers, - \Self.unexpectedBetweenEffectSpecifiersAndOutput, - \Self.output, - \Self.unexpectedBetweenOutputAndInTok, - \Self.inTok, - \Self.unexpectedAfterInTok + \Self.unexpectedBeforeType, + \Self.type, + \Self.unexpectedBetweenTypeAndAmpersand, + \Self.ampersand, + \Self.unexpectedAfterAmpersand ]) } @@ -4194,71 +5389,50 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "attributes" + return nil case 2: return nil case 3: return nil case 4: return nil - case 5: - return nil - case 6: - return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil - case 11: - return nil - case 12: - return nil default: fatalError("Invalid index") } } } -extension ClosureSignatureSyntax: CustomReflectable { +extension CompositionTypeElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAttributes": unexpectedBeforeAttributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "attributes": attributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenAttributesAndCapture": unexpectedBetweenAttributesAndCapture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "capture": capture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenCaptureAndInput": unexpectedBetweenCaptureAndInput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "input": input.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenInputAndEffectSpecifiers": unexpectedBetweenInputAndEffectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "effectSpecifiers": effectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenEffectSpecifiersAndOutput": unexpectedBetweenEffectSpecifiersAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenOutputAndInTok": unexpectedBetweenOutputAndInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "inTok": Syntax(inTok).asProtocol(SyntaxProtocol.self), - "unexpectedAfterInTok": unexpectedAfterInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeType": unexpectedBeforeType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "type": Syntax(type).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenTypeAndAmpersand": unexpectedBetweenTypeAndAmpersand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "ampersand": ampersand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterAmpersand": unexpectedAfterAmpersand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - CodeBlockItemSyntax +// MARK: - ConditionElementSyntax -/// A CodeBlockItem is any Syntax node that appears on its own line inside a CodeBlock. -public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { - public enum Item: SyntaxChildChoices { - case `decl`(DeclSyntax) - case `stmt`(StmtSyntax) - case `expr`(ExprSyntax) + +public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { + public enum Condition: SyntaxChildChoices { + case `expression`(ExprSyntax) + case `availability`(AvailabilityConditionSyntax) + case `matchingPattern`(MatchingPatternConditionSyntax) + case `optionalBinding`(OptionalBindingConditionSyntax) public var _syntaxNode: Syntax { switch self { - case .decl(let node): + case .expression(let node): return node._syntaxNode - case .stmt(let node): + case .availability(let node): return node._syntaxNode - case .expr(let node): + case .matchingPattern(let node): + return node._syntaxNode + case .optionalBinding(let node): return node._syntaxNode } } @@ -4267,84 +5441,97 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { self.init(Syntax(data))! } - public init(_ node: Node) { - self = .decl(DeclSyntax(node)) + public init(_ node: Node) { + self = .expression(ExprSyntax(node)) } - public init(_ node: Node) { - self = .stmt(StmtSyntax(node)) + public init(_ node: AvailabilityConditionSyntax) { + self = .availability(node) } - public init(_ node: Node) { - self = .expr(ExprSyntax(node)) + public init(_ node: MatchingPatternConditionSyntax) { + self = .matchingPattern(node) + } + + public init(_ node: OptionalBindingConditionSyntax) { + self = .optionalBinding(node) } public init?(_ node: S) { - if let node = node.as(DeclSyntax.self) { - self = .decl(node) + if let node = node.as(ExprSyntax.self) { + self = .expression(node) return } - if let node = node.as(StmtSyntax.self) { - self = .stmt(node) + if let node = node.as(AvailabilityConditionSyntax.self) { + self = .availability(node) return } - if let node = node.as(ExprSyntax.self) { - self = .expr(node) + if let node = node.as(MatchingPatternConditionSyntax.self) { + self = .matchingPattern(node) + return + } + if let node = node.as(OptionalBindingConditionSyntax.self) { + self = .optionalBinding(node) return } return nil } public static var structure: SyntaxNodeStructure { - return .choices([.node(DeclSyntax.self), .node(StmtSyntax.self), .node(ExprSyntax.self)]) + return .choices([ + .node(ExprSyntax.self), + .node(AvailabilityConditionSyntax.self), + .node(MatchingPatternConditionSyntax.self), + .node(OptionalBindingConditionSyntax.self) + ]) } } public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .codeBlockItem else { + guard node.raw.kind == .conditionElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `CodeBlockItemSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ConditionElementSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .codeBlockItem) + precondition(data.raw.kind == .conditionElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeItem: UnexpectedNodesSyntax? = nil, - item: Item, - _ unexpectedBetweenItemAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax? = nil, - _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, + condition: Condition, + _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeItem, - item, - unexpectedBetweenItemAndSemicolon, - semicolon, - unexpectedAfterSemicolon + unexpectedBeforeCondition, + condition, + unexpectedBetweenConditionAndTrailingComma, + trailingComma, + unexpectedAfterTrailingComma ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeItem?.raw, - item.raw, - unexpectedBetweenItemAndSemicolon?.raw, - semicolon?.raw, - unexpectedAfterSemicolon?.raw + unexpectedBeforeCondition?.raw, + condition.raw, + unexpectedBetweenConditionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.codeBlockItem, + kind: SyntaxKind.conditionElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -4355,60 +5542,58 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeItem: UnexpectedNodesSyntax? { + public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CodeBlockItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The underlying node inside the code block. - public var item: Item { + public var condition: Condition { get { - return Item(data.child(at: 1, parent: Syntax(self))!) + return Condition(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = CodeBlockItemSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenItemAndSemicolon: UnexpectedNodesSyntax? { + public var unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CodeBlockItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// If present, the trailing semicolon at the end of the item. - public var semicolon: TokenSyntax? { + public var trailingComma: TokenSyntax? { get { return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = CodeBlockItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CodeBlockItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeItem, - \Self.item, - \Self.unexpectedBetweenItemAndSemicolon, - \Self.semicolon, - \Self.unexpectedAfterSemicolon + \Self.unexpectedBeforeCondition, + \Self.condition, + \Self.unexpectedBetweenConditionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma ]) } @@ -4430,73 +5615,73 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { } } -extension CodeBlockItemSyntax: CustomReflectable { +extension ConditionElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeItem": unexpectedBeforeItem.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "item": Syntax(item).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenItemAndSemicolon": unexpectedBetweenItemAndSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "semicolon": semicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterSemicolon": unexpectedAfterSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeCondition": unexpectedBeforeCondition.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "condition": Syntax(condition).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenConditionAndTrailingComma": unexpectedBetweenConditionAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - CodeBlockSyntax +// MARK: - ConformanceRequirementSyntax -public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { +public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .codeBlock else { + guard node.raw.kind == .conformanceRequirement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `CodeBlockSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ConformanceRequirementSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .codeBlock) + precondition(data.raw.kind == .conformanceRequirement) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? = nil, + leftTypeIdentifier: L, + _ unexpectedBetweenLeftTypeIdentifierAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndRightTypeIdentifier: UnexpectedNodesSyntax? = nil, + rightTypeIdentifier: R, + _ unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftBrace, - leftBrace, - unexpectedBetweenLeftBraceAndStatements, - statements, - unexpectedBetweenStatementsAndRightBrace, - rightBrace, - unexpectedAfterRightBrace + unexpectedBeforeLeftTypeIdentifier, + leftTypeIdentifier, + unexpectedBetweenLeftTypeIdentifierAndColon, + colon, + unexpectedBetweenColonAndRightTypeIdentifier, + rightTypeIdentifier, + unexpectedAfterRightTypeIdentifier ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw + unexpectedBeforeLeftTypeIdentifier?.raw, + leftTypeIdentifier.raw, + unexpectedBetweenLeftTypeIdentifierAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndRightTypeIdentifier?.raw, + rightTypeIdentifier.raw, + unexpectedAfterRightTypeIdentifier?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.codeBlock, + kind: SyntaxKind.conformanceRequirement, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -4507,97 +5692,78 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CodeBlockSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ConformanceRequirementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftBrace: TokenSyntax { + public var leftTypeIdentifier: TypeSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = CodeBlockSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ConformanceRequirementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftBraceAndStatements: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftTypeIdentifierAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CodeBlockSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ConformanceRequirementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var statements: CodeBlockItemListSyntax { + public var colon: TokenSyntax { get { - return CodeBlockItemListSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = CodeBlockSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// Adds the provided `Statement` to the node's `statements` - /// collection. - /// - param element: The new `Statement` to add to the node's - /// `statements` collection. - /// - returns: A copy of the receiver with the provided `Statement` - /// appended to its `statements` collection. - public func addStatement(_ element: CodeBlockItemSyntax) -> CodeBlockSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[3] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + self = ConformanceRequirementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return CodeBlockSyntax(newData) } - public var unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndRightTypeIdentifier: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CodeBlockSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ConformanceRequirementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var rightBrace: TokenSyntax { + public var rightTypeIdentifier: TypeSyntax { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return TypeSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = CodeBlockSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = ConformanceRequirementSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + public var unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CodeBlockSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ConformanceRequirementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftBrace, - \Self.leftBrace, - \Self.unexpectedBetweenLeftBraceAndStatements, - \Self.statements, - \Self.unexpectedBetweenStatementsAndRightBrace, - \Self.rightBrace, - \Self.unexpectedAfterRightBrace + \Self.unexpectedBeforeLeftTypeIdentifier, + \Self.leftTypeIdentifier, + \Self.unexpectedBetweenLeftTypeIdentifierAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndRightTypeIdentifier, + \Self.rightTypeIdentifier, + \Self.unexpectedAfterRightTypeIdentifier ]) } @@ -4610,7 +5776,7 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "statements" + return nil case 4: return nil case 5: @@ -4623,69 +5789,87 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { } } -extension CodeBlockSyntax: CustomReflectable { +extension ConformanceRequirementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeftBrace": unexpectedBeforeLeftBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "leftBrace": Syntax(leftBrace).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftBraceAndStatements": unexpectedBetweenLeftBraceAndStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenStatementsAndRightBrace": unexpectedBetweenStatementsAndRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "rightBrace": Syntax(rightBrace).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightBrace": unexpectedAfterRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeLeftTypeIdentifier": unexpectedBeforeLeftTypeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "leftTypeIdentifier": Syntax(leftTypeIdentifier).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftTypeIdentifierAndColon": unexpectedBetweenLeftTypeIdentifierAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndRightTypeIdentifier": unexpectedBetweenColonAndRightTypeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "rightTypeIdentifier": Syntax(rightTypeIdentifier).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightTypeIdentifier": unexpectedAfterRightTypeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - CompositionTypeElementSyntax - +// MARK: - ConventionAttributeArgumentsSyntax -public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { +/// The arguments for the '@convention(...)'. +public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .compositionTypeElement else { + guard node.raw.kind == .conventionAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `CompositionTypeElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ConventionAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .compositionTypeElement) + precondition(data.raw.kind == .conventionAttributeArguments) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedBetweenTypeAndAmpersand: UnexpectedNodesSyntax? = nil, - ampersand: TokenSyntax? = nil, - _ unexpectedAfterAmpersand: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? = nil, + conventionLabel: TokenSyntax = .identifier("IdentifierToken"), + _ unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? = nil, + cTypeLabel: TokenSyntax? = nil, + _ unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? = nil, + cTypeString: StringLiteralExprSyntax? = nil, + _ unexpectedAfterCTypeString: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeType, - type, - unexpectedBetweenTypeAndAmpersand, - ampersand, - unexpectedAfterAmpersand + unexpectedBeforeConventionLabel, + conventionLabel, + unexpectedBetweenConventionLabelAndComma, + comma, + unexpectedBetweenCommaAndCTypeLabel, + cTypeLabel, + unexpectedBetweenCTypeLabelAndColon, + colon, + unexpectedBetweenColonAndCTypeString, + cTypeString, + unexpectedAfterCTypeString ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedBetweenTypeAndAmpersand?.raw, - ampersand?.raw, - unexpectedAfterAmpersand?.raw + unexpectedBeforeConventionLabel?.raw, + conventionLabel.raw, + unexpectedBetweenConventionLabelAndComma?.raw, + comma?.raw, + unexpectedBetweenCommaAndCTypeLabel?.raw, + cTypeLabel?.raw, + unexpectedBetweenCTypeLabelAndColon?.raw, + colon?.raw, + unexpectedBetweenColonAndCTypeString?.raw, + cTypeString?.raw, + unexpectedAfterCTypeString?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.compositionTypeElement, + kind: SyntaxKind.conventionAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -4693,61 +5877,122 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { ) return SyntaxData.forRoot(raw) } - self.init(data) + self.init(data) + } + + public var unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The convention label. + public var conventionLabel: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var comma: TokenSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var cTypeLabel: TokenSyntax? { + get { + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + } } - public var unexpectedBeforeType: UnexpectedNodesSyntax? { + public var unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? { get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CompositionTypeElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var type: TypeSyntax { + public var colon: TokenSyntax? { get { - return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = CompositionTypeElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenTypeAndAmpersand: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CompositionTypeElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } - public var ampersand: TokenSyntax? { + public var cTypeString: StringLiteralExprSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 9, parent: Syntax(self)).map(StringLiteralExprSyntax.init) } set(value) { - self = CompositionTypeElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterAmpersand: UnexpectedNodesSyntax? { + public var unexpectedAfterCTypeString: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CompositionTypeElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeType, - \Self.type, - \Self.unexpectedBetweenTypeAndAmpersand, - \Self.ampersand, - \Self.unexpectedAfterAmpersand + \Self.unexpectedBeforeConventionLabel, + \Self.conventionLabel, + \Self.unexpectedBetweenConventionLabelAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndCTypeLabel, + \Self.cTypeLabel, + \Self.unexpectedBetweenCTypeLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndCTypeString, + \Self.cTypeString, + \Self.unexpectedAfterCTypeString ]) } @@ -4763,142 +6008,97 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil default: fatalError("Invalid index") } } } -extension CompositionTypeElementSyntax: CustomReflectable { +extension ConventionAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeType": unexpectedBeforeType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "type": Syntax(type).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenTypeAndAmpersand": unexpectedBetweenTypeAndAmpersand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "ampersand": ampersand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterAmpersand": unexpectedAfterAmpersand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeConventionLabel": unexpectedBeforeConventionLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "conventionLabel": Syntax(conventionLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenConventionLabelAndComma": unexpectedBetweenConventionLabelAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenCommaAndCTypeLabel": unexpectedBetweenCommaAndCTypeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "cTypeLabel": cTypeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenCTypeLabelAndColon": unexpectedBetweenCTypeLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenColonAndCTypeString": unexpectedBetweenColonAndCTypeString.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "cTypeString": cTypeString.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterCTypeString": unexpectedAfterCTypeString.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - ConditionElementSyntax - +// MARK: - ConventionWitnessMethodAttributeArgumentsSyntax -public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { - public enum Condition: SyntaxChildChoices { - case `expression`(ExprSyntax) - case `availability`(AvailabilityConditionSyntax) - case `matchingPattern`(MatchingPatternConditionSyntax) - case `optionalBinding`(OptionalBindingConditionSyntax) - - public var _syntaxNode: Syntax { - switch self { - case .expression(let node): - return node._syntaxNode - case .availability(let node): - return node._syntaxNode - case .matchingPattern(let node): - return node._syntaxNode - case .optionalBinding(let node): - return node._syntaxNode - } - } - - init(_ data: SyntaxData) { - self.init(Syntax(data))! - } - - public init(_ node: Node) { - self = .expression(ExprSyntax(node)) - } - - public init(_ node: AvailabilityConditionSyntax) { - self = .availability(node) - } - - public init(_ node: MatchingPatternConditionSyntax) { - self = .matchingPattern(node) - } - - public init(_ node: OptionalBindingConditionSyntax) { - self = .optionalBinding(node) - } - - public init?(_ node: S) { - if let node = node.as(ExprSyntax.self) { - self = .expression(node) - return - } - if let node = node.as(AvailabilityConditionSyntax.self) { - self = .availability(node) - return - } - if let node = node.as(MatchingPatternConditionSyntax.self) { - self = .matchingPattern(node) - return - } - if let node = node.as(OptionalBindingConditionSyntax.self) { - self = .optionalBinding(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(ExprSyntax.self), - .node(AvailabilityConditionSyntax.self), - .node(MatchingPatternConditionSyntax.self), - .node(OptionalBindingConditionSyntax.self) - ]) - } - } - +/// The arguments for the '@convention(witness_method: ...)'. +public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conditionElement else { + guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConditionElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ConventionWitnessMethodAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .conditionElement) + precondition(data.raw.kind == .conventionWitnessMethodAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, - condition: Condition, - _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, + witnessMethodLabel: TokenSyntax = .keyword(.witness_method), + _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, + protocolName: TokenSyntax = .identifier("IdentifierToken"), + _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCondition, - condition, - unexpectedBetweenConditionAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma + unexpectedBeforeWitnessMethodLabel, + witnessMethodLabel, + unexpectedBetweenWitnessMethodLabelAndColon, + colon, + unexpectedBetweenColonAndProtocolName, + protocolName, + unexpectedAfterProtocolName ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeCondition?.raw, - condition.raw, - unexpectedBetweenConditionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw + unexpectedBeforeWitnessMethodLabel?.raw, + witnessMethodLabel.raw, + unexpectedBetweenWitnessMethodLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndProtocolName?.raw, + protocolName.raw, + unexpectedAfterProtocolName?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conditionElement, + kind: SyntaxKind.conventionWitnessMethodAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -4909,58 +6109,78 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { + public var unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var condition: Condition { + public var witnessMethodLabel: TokenSyntax { get { - return Condition(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var protocolName: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterProtocolName: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeCondition, - \Self.condition, - \Self.unexpectedBetweenConditionAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma + \Self.unexpectedBeforeWitnessMethodLabel, + \Self.witnessMethodLabel, + \Self.unexpectedBetweenWitnessMethodLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndProtocolName, + \Self.protocolName, + \Self.unexpectedAfterProtocolName ]) } @@ -4976,79 +6196,79 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension ConditionElementSyntax: CustomReflectable { +extension ConventionWitnessMethodAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeCondition": unexpectedBeforeCondition.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "condition": Syntax(condition).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenConditionAndTrailingComma": unexpectedBetweenConditionAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeWitnessMethodLabel": unexpectedBeforeWitnessMethodLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "witnessMethodLabel": Syntax(witnessMethodLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenWitnessMethodLabelAndColon": unexpectedBetweenWitnessMethodLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndProtocolName": unexpectedBetweenColonAndProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "protocolName": Syntax(protocolName).asProtocol(SyntaxProtocol.self), + "unexpectedAfterProtocolName": unexpectedAfterProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - ConformanceRequirementSyntax +// MARK: - DeclEffectSpecifiersSyntax -public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conformanceRequirement else { + guard node.raw.kind == .declEffectSpecifiers else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConformanceRequirementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DeclEffectSpecifiersSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .conformanceRequirement) + precondition(data.raw.kind == .declEffectSpecifiers) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? = nil, - leftTypeIdentifier: L, - _ unexpectedBetweenLeftTypeIdentifierAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndRightTypeIdentifier: UnexpectedNodesSyntax? = nil, - rightTypeIdentifier: R, - _ unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, + asyncSpecifier: TokenSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftTypeIdentifier, - leftTypeIdentifier, - unexpectedBetweenLeftTypeIdentifierAndColon, - colon, - unexpectedBetweenColonAndRightTypeIdentifier, - rightTypeIdentifier, - unexpectedAfterRightTypeIdentifier + unexpectedBeforeAsyncSpecifier, + asyncSpecifier, + unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, + throwsSpecifier, + unexpectedAfterThrowsSpecifier ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftTypeIdentifier?.raw, - leftTypeIdentifier.raw, - unexpectedBetweenLeftTypeIdentifierAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndRightTypeIdentifier?.raw, - rightTypeIdentifier.raw, - unexpectedAfterRightTypeIdentifier?.raw + unexpectedBeforeAsyncSpecifier?.raw, + asyncSpecifier?.raw, + unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, + throwsSpecifier?.raw, + unexpectedAfterThrowsSpecifier?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conformanceRequirement, + kind: SyntaxKind.declEffectSpecifiers, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -5059,78 +6279,58 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConformanceRequirementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftTypeIdentifier: TypeSyntax { + public var asyncSpecifier: TokenSyntax? { get { - return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ConformanceRequirementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftTypeIdentifierAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConformanceRequirementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var throwsSpecifier: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ConformanceRequirementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndRightTypeIdentifier: UnexpectedNodesSyntax? { + public var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConformanceRequirementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var rightTypeIdentifier: TypeSyntax { - get { - return TypeSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = ConformanceRequirementSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ConformanceRequirementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftTypeIdentifier, - \Self.leftTypeIdentifier, - \Self.unexpectedBetweenLeftTypeIdentifierAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndRightTypeIdentifier, - \Self.rightTypeIdentifier, - \Self.unexpectedAfterRightTypeIdentifier + \Self.unexpectedBeforeAsyncSpecifier, + \Self.asyncSpecifier, + \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, + \Self.throwsSpecifier, + \Self.unexpectedAfterThrowsSpecifier ]) } @@ -5146,97 +6346,79 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension ConformanceRequirementSyntax: CustomReflectable { +extension DeclEffectSpecifiersSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeftTypeIdentifier": unexpectedBeforeLeftTypeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "leftTypeIdentifier": Syntax(leftTypeIdentifier).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftTypeIdentifierAndColon": unexpectedBetweenLeftTypeIdentifierAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndRightTypeIdentifier": unexpectedBetweenColonAndRightTypeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "rightTypeIdentifier": Syntax(rightTypeIdentifier).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightTypeIdentifier": unexpectedAfterRightTypeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeAsyncSpecifier": unexpectedBeforeAsyncSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "asyncSpecifier": asyncSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier": unexpectedBetweenAsyncSpecifierAndThrowsSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "throwsSpecifier": throwsSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterThrowsSpecifier": unexpectedAfterThrowsSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - ConventionAttributeArgumentsSyntax +// MARK: - DeclModifierDetailSyntax -/// The arguments for the '@convention(...)'. -public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { + +public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionAttributeArguments else { + guard node.raw.kind == .declModifierDetail else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConventionAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DeclModifierDetailSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .conventionAttributeArguments) + precondition(data.raw.kind == .declModifierDetail) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? = nil, - conventionLabel: TokenSyntax = .identifier("IdentifierToken"), - _ unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? = nil, - cTypeLabel: TokenSyntax? = nil, - _ unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? = nil, - cTypeString: StringLiteralExprSyntax? = nil, - _ unexpectedAfterCTypeString: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, + detail: TokenSyntax, + _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeConventionLabel, - conventionLabel, - unexpectedBetweenConventionLabelAndComma, - comma, - unexpectedBetweenCommaAndCTypeLabel, - cTypeLabel, - unexpectedBetweenCTypeLabelAndColon, - colon, - unexpectedBetweenColonAndCTypeString, - cTypeString, - unexpectedAfterCTypeString + unexpectedBeforeLeftParen, + leftParen, + unexpectedBetweenLeftParenAndDetail, + detail, + unexpectedBetweenDetailAndRightParen, + rightParen, + unexpectedAfterRightParen ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeConventionLabel?.raw, - conventionLabel.raw, - unexpectedBetweenConventionLabelAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndCTypeLabel?.raw, - cTypeLabel?.raw, - unexpectedBetweenCTypeLabelAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndCTypeString?.raw, - cTypeString?.raw, - unexpectedAfterCTypeString?.raw + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndDetail?.raw, + detail.raw, + unexpectedBetweenDetailAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionAttributeArguments, + kind: SyntaxKind.declModifierDetail, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -5247,119 +6429,78 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable self.init(data) } - public var unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The convention label. - public var conventionLabel: TokenSyntax { + public var leftParen: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - public var comma: TokenSyntax? { - get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var cTypeLabel: TokenSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax? { + public var detail: TokenSyntax { get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? { + public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var cTypeString: StringLiteralExprSyntax? { + public var rightParen: TokenSyntax { get { - return data.child(at: 9, parent: Syntax(self)).map(StringLiteralExprSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterCTypeString: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeConventionLabel, - \Self.conventionLabel, - \Self.unexpectedBetweenConventionLabelAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndCTypeLabel, - \Self.cTypeLabel, - \Self.unexpectedBetweenCTypeLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndCTypeString, - \Self.cTypeString, - \Self.unexpectedAfterCTypeString + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDetail, + \Self.detail, + \Self.unexpectedBetweenDetailAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen ]) } @@ -5379,93 +6520,75 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable return nil case 6: return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension ConventionAttributeArgumentsSyntax: CustomReflectable { +extension DeclModifierDetailSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeConventionLabel": unexpectedBeforeConventionLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "conventionLabel": Syntax(conventionLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenConventionLabelAndComma": unexpectedBetweenConventionLabelAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenCommaAndCTypeLabel": unexpectedBetweenCommaAndCTypeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "cTypeLabel": cTypeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenCTypeLabelAndColon": unexpectedBetweenCTypeLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenColonAndCTypeString": unexpectedBetweenColonAndCTypeString.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "cTypeString": cTypeString.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterCTypeString": unexpectedAfterCTypeString.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndDetail": unexpectedBetweenLeftParenAndDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "detail": Syntax(detail).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDetailAndRightParen": unexpectedBetweenDetailAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - ConventionWitnessMethodAttributeArgumentsSyntax +// MARK: - DeclModifierSyntax -/// The arguments for the '@convention(witness_method: ...)'. -public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { + +public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { + guard node.raw.kind == .declModifier else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConventionWitnessMethodAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DeclModifierSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .conventionWitnessMethodAttributeArguments) + precondition(data.raw.kind == .declModifier) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, - witnessMethodLabel: TokenSyntax = .keyword(.witness_method), - _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, - protocolName: TokenSyntax = .identifier("IdentifierToken"), - _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? = nil, + detail: DeclModifierDetailSyntax? = nil, + _ unexpectedAfterDetail: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWitnessMethodLabel, - witnessMethodLabel, - unexpectedBetweenWitnessMethodLabelAndColon, - colon, - unexpectedBetweenColonAndProtocolName, - protocolName, - unexpectedAfterProtocolName + unexpectedBeforeName, + name, + unexpectedBetweenNameAndDetail, + detail, + unexpectedAfterDetail ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWitnessMethodLabel?.raw, - witnessMethodLabel.raw, - unexpectedBetweenWitnessMethodLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndProtocolName?.raw, - protocolName.raw, - unexpectedAfterProtocolName?.raw + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndDetail?.raw, + detail?.raw, + unexpectedAfterDetail?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionWitnessMethodAttributeArguments, + kind: SyntaxKind.declModifier, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -5476,78 +6599,58 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S self.init(data) } - public var unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var witnessMethodLabel: TokenSyntax { + public var name: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var detail: DeclModifierDetailSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(DeclModifierDetailSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? { + public var unexpectedAfterDetail: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var protocolName: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterProtocolName: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWitnessMethodLabel, - \Self.witnessMethodLabel, - \Self.unexpectedBetweenWitnessMethodLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndProtocolName, - \Self.protocolName, - \Self.unexpectedAfterProtocolName + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndDetail, + \Self.detail, + \Self.unexpectedAfterDetail ]) } @@ -5563,79 +6666,73 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension ConventionWitnessMethodAttributeArgumentsSyntax: CustomReflectable { +extension DeclModifierSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeWitnessMethodLabel": unexpectedBeforeWitnessMethodLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "witnessMethodLabel": Syntax(witnessMethodLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenWitnessMethodLabelAndColon": unexpectedBetweenWitnessMethodLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndProtocolName": unexpectedBetweenColonAndProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "protocolName": Syntax(protocolName).asProtocol(SyntaxProtocol.self), - "unexpectedAfterProtocolName": unexpectedAfterProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenNameAndDetail": unexpectedBetweenNameAndDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "detail": detail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterDetail": unexpectedAfterDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DeclEffectSpecifiersSyntax +// MARK: - DeclNameArgumentSyntax -public struct DeclEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declEffectSpecifiers else { + guard node.raw.kind == .declNameArgument else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclEffectSpecifiersSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DeclNameArgumentSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .declEffectSpecifiers) + precondition(data.raw.kind == .declNameArgument) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, - asyncSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAsyncSpecifier, - asyncSpecifier, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - throwsSpecifier, - unexpectedAfterThrowsSpecifier + unexpectedBeforeName, + name, + unexpectedBetweenNameAndColon, + colon, + unexpectedAfterColon ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAsyncSpecifier?.raw, - asyncSpecifier?.raw, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, - throwsSpecifier?.raw, - unexpectedAfterThrowsSpecifier?.raw + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declEffectSpecifiers, + kind: SyntaxKind.declNameArgument, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -5646,58 +6743,58 @@ public struct DeclEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var asyncSpecifier: TokenSyntax? { + public var name: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var throwsSpecifier: TokenSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedAfterColon: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclEffectSpecifiersSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAsyncSpecifier, - \Self.asyncSpecifier, - \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - \Self.throwsSpecifier, - \Self.unexpectedAfterThrowsSpecifier + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndColon, + \Self.colon, + \Self.unexpectedAfterColon ]) } @@ -5719,36 +6816,36 @@ public struct DeclEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { } } -extension DeclEffectSpecifiersSyntax: CustomReflectable { +extension DeclNameArgumentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAsyncSpecifier": unexpectedBeforeAsyncSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "asyncSpecifier": asyncSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier": unexpectedBetweenAsyncSpecifierAndThrowsSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "throwsSpecifier": throwsSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterThrowsSpecifier": unexpectedAfterThrowsSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenNameAndColon": unexpectedBetweenNameAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedAfterColon": unexpectedAfterColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DeclModifierDetailSyntax +// MARK: - DeclNameArgumentsSyntax -public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifierDetail else { + guard node.raw.kind == .declNameArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclModifierDetailSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DeclNameArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .declModifierDetail) + precondition(data.raw.kind == .declNameArguments) self._syntaxNode = Syntax(data) } @@ -5756,9 +6853,9 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { leadingTrivia: Trivia? = nil, _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, - detail: TokenSyntax, - _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentListSyntax, + _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax = .rightParenToken(), _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -5769,23 +6866,23 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( unexpectedBeforeLeftParen, leftParen, - unexpectedBetweenLeftParenAndDetail, - detail, - unexpectedBetweenDetailAndRightParen, + unexpectedBetweenLeftParenAndArguments, + arguments, + unexpectedBetweenArgumentsAndRightParen, rightParen, unexpectedAfterRightParen ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, - unexpectedBetweenLeftParenAndDetail?.raw, - detail.raw, - unexpectedBetweenDetailAndRightParen?.raw, + unexpectedBetweenLeftParenAndArguments?.raw, + arguments.raw, + unexpectedBetweenArgumentsAndRightParen?.raw, rightParen.raw, unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifierDetail, + kind: SyntaxKind.declNameArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -5801,7 +6898,7 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } @@ -5810,34 +6907,53 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DeclNameArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var detail: TokenSyntax { + public var arguments: DeclNameArgumentListSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return DeclNameArgumentListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DeclNameArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { + /// Adds the provided `Argument` to the node's `arguments` + /// collection. + /// - param element: The new `Argument` to add to the node's + /// `arguments` collection. + /// - returns: A copy of the receiver with the provided `Argument` + /// appended to its `arguments` collection. + public func addArgument(_ element: DeclNameArgumentSyntax) -> DeclNameArgumentsSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.declNameArgumentList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return DeclNameArgumentsSyntax(newData) + } + + public var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } @@ -5846,7 +6962,7 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = DeclNameArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } @@ -5855,7 +6971,7 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DeclNameArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } @@ -5863,9 +6979,9 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { return .layout([ \Self.unexpectedBeforeLeftParen, \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndDetail, - \Self.detail, - \Self.unexpectedBetweenDetailAndRightParen, + \Self.unexpectedBetweenLeftParenAndArguments, + \Self.arguments, + \Self.unexpectedBetweenArgumentsAndRightParen, \Self.rightParen, \Self.unexpectedAfterRightParen ]) @@ -5893,69 +7009,69 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { } } -extension DeclModifierDetailSyntax: CustomReflectable { +extension DeclNameArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndDetail": unexpectedBetweenLeftParenAndDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "detail": Syntax(detail).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDetailAndRightParen": unexpectedBetweenDetailAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenLeftParenAndArguments": unexpectedBetweenLeftParenAndArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "arguments": Syntax(arguments).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenArgumentsAndRightParen": unexpectedBetweenArgumentsAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DeclModifierSyntax +// MARK: - DeclNameSyntax -public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifier else { + guard node.raw.kind == .declName else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclModifierSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DeclNameSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .declModifier) + precondition(data.raw.kind == .declName) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? = nil, - detail: DeclModifierDetailSyntax? = nil, - _ unexpectedAfterDetail: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? = nil, + declBaseName: TokenSyntax, + _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndDetail, - detail, - unexpectedAfterDetail + unexpectedBeforeDeclBaseName, + declBaseName, + unexpectedBetweenDeclBaseNameAndDeclNameArguments, + declNameArguments, + unexpectedAfterDeclNameArguments ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndDetail?.raw, - detail?.raw, - unexpectedAfterDetail?.raw + unexpectedBeforeDeclBaseName?.raw, + declBaseName.raw, + unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedAfterDeclNameArguments?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifier, + kind: SyntaxKind.declName, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -5966,58 +7082,60 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + /// The base name of the protocol's requirement. + public var declBaseName: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var detail: DeclModifierDetailSyntax? { + /// The argument labels of the protocol's requirement if it is a function requirement. + public var declNameArguments: DeclNameArgumentsSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(DeclModifierDetailSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDetail: UnexpectedNodesSyntax? { + public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndDetail, - \Self.detail, - \Self.unexpectedAfterDetail + \Self.unexpectedBeforeDeclBaseName, + \Self.declBaseName, + \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedAfterDeclNameArguments ]) } @@ -6026,11 +7144,11 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "base name" case 2: return nil case 3: - return nil + return "arguments" case 4: return nil default: @@ -6039,67 +7157,97 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { } } -extension DeclModifierSyntax: CustomReflectable { +extension DeclNameSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenNameAndDetail": unexpectedBetweenNameAndDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "detail": detail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterDetail": unexpectedAfterDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeDeclBaseName": unexpectedBeforeDeclBaseName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "declBaseName": Syntax(declBaseName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDeclBaseNameAndDeclNameArguments": unexpectedBetweenDeclBaseNameAndDeclNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "declNameArguments": declNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterDeclNameArguments": unexpectedAfterDeclNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DeclNameArgumentSyntax - +// MARK: - DerivativeRegistrationAttributeArgumentsSyntax -public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable { +/// The arguments for the '@derivative(of:)' and '@transpose(of:)' attributes: the 'of:' label, the original declaration name, and an optional differentiability parameter list. +public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declNameArgument else { + guard node.raw.kind == .derivativeRegistrationAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclNameArgumentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DerivativeRegistrationAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .declNameArgument) + precondition(data.raw.kind == .derivativeRegistrationAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, + ofLabel: TokenSyntax = .keyword(.of), + _ unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? = nil, + originalDeclName: QualifiedDeclNameSyntax, + _ unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax? = nil, + _ unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? = nil, + accessorKind: TokenSyntax? = nil, + _ unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamsClauseSyntax? = nil, + _ unexpectedAfterDiffParams: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndColon, + unexpectedBeforeOfLabel, + ofLabel, + unexpectedBetweenOfLabelAndColon, colon, - unexpectedAfterColon + unexpectedBetweenColonAndOriginalDeclName, + originalDeclName, + unexpectedBetweenOriginalDeclNameAndPeriod, + period, + unexpectedBetweenPeriodAndAccessorKind, + accessorKind, + unexpectedBetweenAccessorKindAndComma, + comma, + unexpectedBetweenCommaAndDiffParams, + diffParams, + unexpectedAfterDiffParams ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndColon?.raw, + unexpectedBeforeOfLabel?.raw, + ofLabel.raw, + unexpectedBetweenOfLabelAndColon?.raw, colon.raw, - unexpectedAfterColon?.raw + unexpectedBetweenColonAndOriginalDeclName?.raw, + originalDeclName.raw, + unexpectedBetweenOriginalDeclNameAndPeriod?.raw, + period?.raw, + unexpectedBetweenPeriodAndAccessorKind?.raw, + accessorKind?.raw, + unexpectedBetweenAccessorKindAndComma?.raw, + comma?.raw, + unexpectedBetweenCommaAndDiffParams?.raw, + diffParams?.raw, + unexpectedAfterDiffParams?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declNameArgument, + kind: SyntaxKind.derivativeRegistrationAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -6110,247 +7258,163 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeOfLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameArgumentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + /// The "of" label. + public var ofLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclNameArgumentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameArgumentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } + /// The colon separating the "of" label and the original declaration name. public var colon: TokenSyntax { get { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DeclNameArgumentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameArgumentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndColon, - \Self.colon, - \Self.unexpectedAfterColon - ]) - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - case 3: - return nil - case 4: - return nil - default: - fatalError("Invalid index") + /// The referenced original declaration name. + public var originalDeclName: QualifiedDeclNameSyntax { + get { + return QualifiedDeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) } - } -} - -extension DeclNameArgumentSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenNameAndColon": unexpectedBetweenNameAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedAfterColon": unexpectedAfterColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any - ]) - } -} - -// MARK: - DeclNameArgumentsSyntax - - -public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .declNameArguments else { - return nil + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `DeclNameArgumentsSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .declNameArguments) - self._syntaxNode = Syntax(data) } - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, - arguments: DeclNameArgumentListSyntax, - _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = 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 - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declNameArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) - return SyntaxData.forRoot(raw) + public var unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } - self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + /// The period separating the original declaration name and the accessor name. + public var period: TokenSyntax? { get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DeclNameArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { + public var unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? { + /// The accessor name. + public var accessorKind: TokenSyntax? { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DeclNameArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) } } - public var arguments: DeclNameArgumentListSyntax { + public var unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? { get { - return DeclNameArgumentListSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } - /// Adds the provided `Argument` to the node's `arguments` - /// collection. - /// - param element: The new `Argument` to add to the node's - /// `arguments` collection. - /// - returns: A copy of the receiver with the provided `Argument` - /// appended to its `arguments` collection. - public func addArgument(_ element: DeclNameArgumentSyntax) -> DeclNameArgumentsSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[3] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.declNameArgumentList, - from: [element.raw], arena: arena) + public var comma: TokenSyntax? { + get { + return data.child(at: 11, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return DeclNameArgumentsSyntax(newData) } - public var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) } } - public var rightParen: TokenSyntax { + public var diffParams: DifferentiabilityParamsClauseSyntax? { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 13, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) } set(value) { - self = DeclNameArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterDiffParams: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndArguments, - \Self.arguments, - \Self.unexpectedBetweenArgumentsAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen + \Self.unexpectedBeforeOfLabel, + \Self.ofLabel, + \Self.unexpectedBetweenOfLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndOriginalDeclName, + \Self.originalDeclName, + \Self.unexpectedBetweenOriginalDeclNameAndPeriod, + \Self.period, + \Self.unexpectedBetweenPeriodAndAccessorKind, + \Self.accessorKind, + \Self.unexpectedBetweenAccessorKindAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndDiffParams, + \Self.diffParams, + \Self.unexpectedAfterDiffParams ]) } @@ -6370,75 +7434,99 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil + case 11: + return nil + case 12: + return nil + case 13: + return nil + case 14: + return nil default: fatalError("Invalid index") } } } -extension DeclNameArgumentsSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndArguments": unexpectedBetweenLeftParenAndArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "arguments": Syntax(arguments).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenArgumentsAndRightParen": unexpectedBetweenArgumentsAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any +extension DerivativeRegistrationAttributeArgumentsSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeOfLabel": unexpectedBeforeOfLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "ofLabel": Syntax(ofLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenOfLabelAndColon": unexpectedBetweenOfLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndOriginalDeclName": unexpectedBetweenColonAndOriginalDeclName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "originalDeclName": Syntax(originalDeclName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenOriginalDeclNameAndPeriod": unexpectedBetweenOriginalDeclNameAndPeriod.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenPeriodAndAccessorKind": unexpectedBetweenPeriodAndAccessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "accessorKind": accessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenAccessorKindAndComma": unexpectedBetweenAccessorKindAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenCommaAndDiffParams": unexpectedBetweenCommaAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "diffParams": diffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterDiffParams": unexpectedAfterDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DeclNameSyntax +// MARK: - DesignatedTypeElementSyntax -public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { +public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declName else { + guard node.raw.kind == .designatedTypeElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclNameSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DesignatedTypeElementSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .declName) + precondition(data.raw.kind == .designatedTypeElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? = nil, - declBaseName: TokenSyntax, - _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, + leadingComma: TokenSyntax = .commaToken(), + _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDeclBaseName, - declBaseName, - unexpectedBetweenDeclBaseNameAndDeclNameArguments, - declNameArguments, - unexpectedAfterDeclNameArguments + unexpectedBeforeLeadingComma, + leadingComma, + unexpectedBetweenLeadingCommaAndName, + name, + unexpectedAfterName ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDeclBaseName?.raw, - declBaseName.raw, - unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, - declNameArguments?.raw, - unexpectedAfterDeclNameArguments?.raw + unexpectedBeforeLeadingComma?.raw, + leadingComma.raw, + unexpectedBetweenLeadingCommaAndName?.raw, + name.raw, + unexpectedAfterName?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declName, + kind: SyntaxKind.designatedTypeElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -6449,60 +7537,58 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The base name of the protocol's requirement. - public var declBaseName: TokenSyntax { + public var leadingComma: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The argument labels of the protocol's requirement if it is a function requirement. - public var declNameArguments: DeclNameArgumentsSyntax? { + public var name: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDeclBaseName, - \Self.declBaseName, - \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, - \Self.declNameArguments, - \Self.unexpectedAfterDeclNameArguments + \Self.unexpectedBeforeLeadingComma, + \Self.leadingComma, + \Self.unexpectedBetweenLeadingCommaAndName, + \Self.name, + \Self.unexpectedAfterName ]) } @@ -6511,11 +7597,11 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "base name" + return nil case 2: return nil case 3: - return "arguments" + return nil case 4: return nil default: @@ -6524,264 +7610,181 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { } } -extension DeclNameSyntax: CustomReflectable { +extension DesignatedTypeElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeDeclBaseName": unexpectedBeforeDeclBaseName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "declBaseName": Syntax(declBaseName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDeclBaseNameAndDeclNameArguments": unexpectedBetweenDeclBaseNameAndDeclNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "declNameArguments": declNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterDeclNameArguments": unexpectedAfterDeclNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeLeadingComma": unexpectedBeforeLeadingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "leadingComma": Syntax(leadingComma).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeadingCommaAndName": unexpectedBetweenLeadingCommaAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedAfterName": unexpectedAfterName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DerivativeRegistrationAttributeArgumentsSyntax +// MARK: - DictionaryElementSyntax -/// The arguments for the '@derivative(of:)' and '@transpose(of:)' attributes: the 'of:' label, the original declaration name, and an optional differentiability parameter list. -public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { + +public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .derivativeRegistrationAttributeArguments else { + guard node.raw.kind == .dictionaryElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DerivativeRegistrationAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DictionaryElementSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .derivativeRegistrationAttributeArguments) + precondition(data.raw.kind == .dictionaryElement) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, - ofLabel: TokenSyntax = .keyword(.of), - _ unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeKeyExpression: UnexpectedNodesSyntax? = nil, + keyExpression: K, + _ unexpectedBetweenKeyExpressionAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? = nil, - originalDeclName: QualifiedDeclNameSyntax, - _ unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? = nil, - period: TokenSyntax? = nil, - _ unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? = nil, - accessorKind: TokenSyntax? = nil, - _ unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? = nil, - diffParams: DifferentiabilityParamsClauseSyntax? = nil, - _ unexpectedAfterDiffParams: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndValueExpression: UnexpectedNodesSyntax? = nil, + valueExpression: V, + _ unexpectedBetweenValueExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeOfLabel, - ofLabel, - unexpectedBetweenOfLabelAndColon, + unexpectedBeforeKeyExpression, + keyExpression, + unexpectedBetweenKeyExpressionAndColon, colon, - unexpectedBetweenColonAndOriginalDeclName, - originalDeclName, - unexpectedBetweenOriginalDeclNameAndPeriod, - period, - unexpectedBetweenPeriodAndAccessorKind, - accessorKind, - unexpectedBetweenAccessorKindAndComma, - comma, - unexpectedBetweenCommaAndDiffParams, - diffParams, - unexpectedAfterDiffParams + unexpectedBetweenColonAndValueExpression, + valueExpression, + unexpectedBetweenValueExpressionAndTrailingComma, + trailingComma, + unexpectedAfterTrailingComma ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeOfLabel?.raw, - ofLabel.raw, - unexpectedBetweenOfLabelAndColon?.raw, + unexpectedBeforeKeyExpression?.raw, + keyExpression.raw, + unexpectedBetweenKeyExpressionAndColon?.raw, colon.raw, - unexpectedBetweenColonAndOriginalDeclName?.raw, - originalDeclName.raw, - unexpectedBetweenOriginalDeclNameAndPeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndAccessorKind?.raw, - accessorKind?.raw, - unexpectedBetweenAccessorKindAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndDiffParams?.raw, - diffParams?.raw, - unexpectedAfterDiffParams?.raw - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.derivativeRegistrationAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeOfLabel: UnexpectedNodesSyntax? { - get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The "of" label. - public var ofLabel: TokenSyntax { - get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? { - get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The colon separating the "of" label and the original declaration name. - public var colon: TokenSyntax { - get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The referenced original declaration name. - public var originalDeclName: QualifiedDeclNameSyntax { - get { - return QualifiedDeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + unexpectedBetweenColonAndValueExpression?.raw, + valueExpression.raw, + unexpectedBetweenValueExpressionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.dictionaryElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return SyntaxData.forRoot(raw) } + self.init(data) } - public var unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? { + public var unexpectedBeforeKeyExpression: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The period separating the original declaration name and the accessor name. - public var period: TokenSyntax? { + public var keyExpression: ExprSyntax { get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + return ExprSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? { + public var unexpectedBetweenKeyExpressionAndColon: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The accessor name. - public var accessorKind: TokenSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndValueExpression: UnexpectedNodesSyntax? { get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var comma: TokenSyntax? { + public var valueExpression: ExprSyntax { get { - return data.child(at: 11, parent: Syntax(self)).map(TokenSyntax.init) + return ExprSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenValueExpressionAndTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var diffParams: DifferentiabilityParamsClauseSyntax? { + public var trailingComma: TokenSyntax? { get { - return data.child(at: 13, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDiffParams: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) + self = DictionaryElementSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeOfLabel, - \Self.ofLabel, - \Self.unexpectedBetweenOfLabelAndColon, + \Self.unexpectedBeforeKeyExpression, + \Self.keyExpression, + \Self.unexpectedBetweenKeyExpressionAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndOriginalDeclName, - \Self.originalDeclName, - \Self.unexpectedBetweenOriginalDeclNameAndPeriod, - \Self.period, - \Self.unexpectedBetweenPeriodAndAccessorKind, - \Self.accessorKind, - \Self.unexpectedBetweenAccessorKindAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndDiffParams, - \Self.diffParams, - \Self.unexpectedAfterDiffParams + \Self.unexpectedBetweenColonAndValueExpression, + \Self.valueExpression, + \Self.unexpectedBetweenValueExpressionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma ]) } @@ -6790,7 +7793,7 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy case 0: return nil case 1: - return nil + return "key" case 2: return nil case 3: @@ -6798,102 +7801,84 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy case 4: return nil case 5: - return nil + return "value" case 6: return nil case 7: return nil case 8: return nil - case 9: - return nil - case 10: - return nil - case 11: - return nil - case 12: - return nil - case 13: - return nil - case 14: - return nil default: fatalError("Invalid index") } } } -extension DerivativeRegistrationAttributeArgumentsSyntax: CustomReflectable { +extension DictionaryElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeOfLabel": unexpectedBeforeOfLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "ofLabel": Syntax(ofLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOfLabelAndColon": unexpectedBetweenOfLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBeforeKeyExpression": unexpectedBeforeKeyExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "keyExpression": Syntax(keyExpression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenKeyExpressionAndColon": unexpectedBetweenKeyExpressionAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndOriginalDeclName": unexpectedBetweenColonAndOriginalDeclName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "originalDeclName": Syntax(originalDeclName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOriginalDeclNameAndPeriod": unexpectedBetweenOriginalDeclNameAndPeriod.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenPeriodAndAccessorKind": unexpectedBetweenPeriodAndAccessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "accessorKind": accessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenAccessorKindAndComma": unexpectedBetweenAccessorKindAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenCommaAndDiffParams": unexpectedBetweenCommaAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "diffParams": diffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterDiffParams": unexpectedAfterDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBetweenColonAndValueExpression": unexpectedBetweenColonAndValueExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "valueExpression": Syntax(valueExpression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenValueExpressionAndTrailingComma": unexpectedBetweenValueExpressionAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DesignatedTypeElementSyntax - +// MARK: - DifferentiabilityParamSyntax -public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { +/// A differentiability parameter: either the "self" identifier, a function parameter name, or a function parameter index. +public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .designatedTypeElement else { + guard node.raw.kind == .differentiabilityParam else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DesignatedTypeElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DifferentiabilityParamSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .designatedTypeElement) + precondition(data.raw.kind == .differentiabilityParam) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, - leadingComma: TokenSyntax = .commaToken(), - _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, + parameter: TokenSyntax, + _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeadingComma, - leadingComma, - unexpectedBetweenLeadingCommaAndName, - name, - unexpectedAfterName + unexpectedBeforeParameter, + parameter, + unexpectedBetweenParameterAndTrailingComma, + trailingComma, + unexpectedAfterTrailingComma ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeadingComma?.raw, - leadingComma.raw, - unexpectedBetweenLeadingCommaAndName?.raw, - name.raw, - unexpectedAfterName?.raw + unexpectedBeforeParameter?.raw, + parameter.raw, + unexpectedBetweenParameterAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.designatedTypeElement, + kind: SyntaxKind.differentiabilityParam, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -6904,58 +7889,58 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? { + public var unexpectedBeforeParameter: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leadingComma: TokenSyntax { + public var parameter: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + public var trailingComma: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterName: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeadingComma, - \Self.leadingComma, - \Self.unexpectedBetweenLeadingCommaAndName, - \Self.name, - \Self.unexpectedAfterName + \Self.unexpectedBeforeParameter, + \Self.parameter, + \Self.unexpectedBetweenParameterAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma ]) } @@ -6971,85 +7956,121 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - default: - fatalError("Invalid index") + default: + fatalError("Invalid index") + } + } +} + +extension DifferentiabilityParamSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeParameter": unexpectedBeforeParameter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "parameter": Syntax(parameter).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenParameterAndTrailingComma": unexpectedBetweenParameterAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + ]) + } +} + +// MARK: - DifferentiabilityParamsClauseSyntax + +/// A clause containing differentiability parameters. +public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashable { + public enum Parameters: SyntaxChildChoices { + case `parameter`(DifferentiabilityParamSyntax) + case `parameterList`(DifferentiabilityParamsSyntax) + + public var _syntaxNode: Syntax { + switch self { + case .parameter(let node): + return node._syntaxNode + case .parameterList(let node): + return node._syntaxNode + } + } + + init(_ data: SyntaxData) { + self.init(Syntax(data))! + } + + public init(_ node: DifferentiabilityParamSyntax) { + self = .parameter(node) + } + + public init(_ node: DifferentiabilityParamsSyntax) { + self = .parameterList(node) + } + + public init?(_ node: S) { + if let node = node.as(DifferentiabilityParamSyntax.self) { + self = .parameter(node) + return + } + if let node = node.as(DifferentiabilityParamsSyntax.self) { + self = .parameterList(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([.node(DifferentiabilityParamSyntax.self), .node(DifferentiabilityParamsSyntax.self)]) } } -} - -extension DesignatedTypeElementSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeLeadingComma": unexpectedBeforeLeadingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "leadingComma": Syntax(leadingComma).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeadingCommaAndName": unexpectedBetweenLeadingCommaAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedAfterName": unexpectedAfterName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any - ]) - } -} - -// MARK: - DictionaryElementSyntax - - -public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dictionaryElement else { + guard node.raw.kind == .differentiabilityParamsClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DictionaryElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DifferentiabilityParamsClauseSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .dictionaryElement) + precondition(data.raw.kind == .differentiabilityParamsClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeKeyExpression: UnexpectedNodesSyntax? = nil, - keyExpression: K, - _ unexpectedBetweenKeyExpressionAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, + wrtLabel: TokenSyntax = .keyword(.wrt), + _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValueExpression: UnexpectedNodesSyntax? = nil, - valueExpression: V, - _ unexpectedBetweenValueExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, + parameters: Parameters, + _ unexpectedAfterParameters: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeKeyExpression, - keyExpression, - unexpectedBetweenKeyExpressionAndColon, + unexpectedBeforeWrtLabel, + wrtLabel, + unexpectedBetweenWrtLabelAndColon, colon, - unexpectedBetweenColonAndValueExpression, - valueExpression, - unexpectedBetweenValueExpressionAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma + unexpectedBetweenColonAndParameters, + parameters, + unexpectedAfterParameters ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeKeyExpression?.raw, - keyExpression.raw, - unexpectedBetweenKeyExpressionAndColon?.raw, + unexpectedBeforeWrtLabel?.raw, + wrtLabel.raw, + unexpectedBetweenWrtLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndValueExpression?.raw, - valueExpression.raw, - unexpectedBetweenValueExpressionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw + unexpectedBetweenColonAndParameters?.raw, + parameters.raw, + unexpectedAfterParameters?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dictionaryElement, + kind: SyntaxKind.differentiabilityParamsClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -7060,98 +8081,80 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeKeyExpression: UnexpectedNodesSyntax? { + public var unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var keyExpression: ExprSyntax { + /// The "wrt" label. + public var wrtLabel: TokenSyntax { get { - return ExprSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenKeyExpressionAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } + /// The colon separating "wrt" and the parameter list. public var colon: TokenSyntax { get { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndValueExpression: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var valueExpression: ExprSyntax { + public var parameters: Parameters { get { - return ExprSyntax(data.child(at: 5, parent: Syntax(self))!) + return Parameters(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenValueExpressionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterParameters: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public var trailingComma: TokenSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DictionaryElementSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeKeyExpression, - \Self.keyExpression, - \Self.unexpectedBetweenKeyExpressionAndColon, + \Self.unexpectedBeforeWrtLabel, + \Self.wrtLabel, + \Self.unexpectedBetweenWrtLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndValueExpression, - \Self.valueExpression, - \Self.unexpectedBetweenValueExpressionAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma + \Self.unexpectedBetweenColonAndParameters, + \Self.parameters, + \Self.unexpectedAfterParameters ]) } @@ -7160,7 +8163,7 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "key" + return nil case 2: return nil case 3: @@ -7168,84 +8171,84 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return "value" + return "parameters" case 6: return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension DictionaryElementSyntax: CustomReflectable { +extension DifferentiabilityParamsClauseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeKeyExpression": unexpectedBeforeKeyExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "keyExpression": Syntax(keyExpression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenKeyExpressionAndColon": unexpectedBetweenKeyExpressionAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBeforeWrtLabel": unexpectedBeforeWrtLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "wrtLabel": Syntax(wrtLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenWrtLabelAndColon": unexpectedBetweenWrtLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndValueExpression": unexpectedBetweenColonAndValueExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "valueExpression": Syntax(valueExpression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenValueExpressionAndTrailingComma": unexpectedBetweenValueExpressionAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBetweenColonAndParameters": unexpectedBetweenColonAndParameters.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "parameters": Syntax(parameters).asProtocol(SyntaxProtocol.self), + "unexpectedAfterParameters": unexpectedAfterParameters.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DifferentiabilityParamSyntax +// MARK: - DifferentiabilityParamsSyntax -/// A differentiability parameter: either the "self" identifier, a function parameter name, or a function parameter index. -public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { +/// The differentiability parameters. +public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParam else { + guard node.raw.kind == .differentiabilityParams else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DifferentiabilityParamsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .differentiabilityParam) + precondition(data.raw.kind == .differentiabilityParams) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, - parameter: TokenSyntax, - _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamListSyntax, + _ unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeParameter, - parameter, - unexpectedBetweenParameterAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma + unexpectedBeforeLeftParen, + leftParen, + unexpectedBetweenLeftParenAndDiffParams, + diffParams, + unexpectedBetweenDiffParamsAndRightParen, + rightParen, + unexpectedAfterRightParen ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeParameter?.raw, - parameter.raw, - unexpectedBetweenParameterAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndDiffParams?.raw, + diffParams.raw, + unexpectedBetweenDiffParamsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParam, + kind: SyntaxKind.differentiabilityParams, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -7256,58 +8259,98 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeParameter: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var parameter: TokenSyntax { + public var leftParen: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The parameters for differentiation. + public var diffParams: DifferentiabilityParamListSyntax { + get { + return DifferentiabilityParamListSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `DifferentiabilityParam` to the node's `diffParams` + /// collection. + /// - param element: The new `DifferentiabilityParam` to add to the node's + /// `diffParams` collection. + /// - returns: A copy of the receiver with the provided `DifferentiabilityParam` + /// appended to its `diffParams` collection. + public func addDifferentiabilityParam(_ element: DifferentiabilityParamSyntax) -> DifferentiabilityParamsSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + public var rightParen: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeParameter, - \Self.parameter, - \Self.unexpectedBetweenParameterAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDiffParams, + \Self.diffParams, + \Self.unexpectedBetweenDiffParamsAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen ]) } @@ -7323,121 +8366,97 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamSyntax: CustomReflectable { +extension DifferentiabilityParamsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeParameter": unexpectedBeforeParameter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "parameter": Syntax(parameter).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenParameterAndTrailingComma": unexpectedBetweenParameterAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndDiffParams": unexpectedBetweenLeftParenAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "diffParams": Syntax(diffParams).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDiffParamsAndRightParen": unexpectedBetweenDiffParamsAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DifferentiabilityParamsClauseSyntax +// MARK: - DifferentiableAttributeArgumentsSyntax -/// A clause containing differentiability parameters. -public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashable { - public enum Parameters: SyntaxChildChoices { - case `parameter`(DifferentiabilityParamSyntax) - case `parameterList`(DifferentiabilityParamsSyntax) - - public var _syntaxNode: Syntax { - switch self { - case .parameter(let node): - return node._syntaxNode - case .parameterList(let node): - return node._syntaxNode - } - } - - init(_ data: SyntaxData) { - self.init(Syntax(data))! - } - - public init(_ node: DifferentiabilityParamSyntax) { - self = .parameter(node) - } - - public init(_ node: DifferentiabilityParamsSyntax) { - self = .parameterList(node) - } - - public init?(_ node: S) { - if let node = node.as(DifferentiabilityParamSyntax.self) { - self = .parameter(node) - return - } - if let node = node.as(DifferentiabilityParamsSyntax.self) { - self = .parameterList(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([.node(DifferentiabilityParamSyntax.self), .node(DifferentiabilityParamsSyntax.self)]) - } - } - +/// The arguments for the `@differentiable` attribute: an optional differentiability kind, an optional differentiability parameter clause, and an optional 'where' clause. +public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParamsClause else { + guard node.raw.kind == .differentiableAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamsClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DifferentiableAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .differentiabilityParamsClause) + precondition(data.raw.kind == .differentiableAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, - wrtLabel: TokenSyntax = .keyword(.wrt), - _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, - parameters: Parameters, - _ unexpectedAfterParameters: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDiffKind: UnexpectedNodesSyntax? = nil, + diffKind: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? = nil, + diffKindComma: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamsClauseSyntax? = nil, + _ unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? = nil, + diffParamsComma: TokenSyntax? = nil, + _ unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedAfterWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWrtLabel, - wrtLabel, - unexpectedBetweenWrtLabelAndColon, - colon, - unexpectedBetweenColonAndParameters, - parameters, - unexpectedAfterParameters + unexpectedBeforeDiffKind, + diffKind, + unexpectedBetweenDiffKindAndDiffKindComma, + diffKindComma, + unexpectedBetweenDiffKindCommaAndDiffParams, + diffParams, + unexpectedBetweenDiffParamsAndDiffParamsComma, + diffParamsComma, + unexpectedBetweenDiffParamsCommaAndWhereClause, + whereClause, + unexpectedAfterWhereClause ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWrtLabel?.raw, - wrtLabel.raw, - unexpectedBetweenWrtLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndParameters?.raw, - parameters.raw, - unexpectedAfterParameters?.raw + unexpectedBeforeDiffKind?.raw, + diffKind?.raw, + unexpectedBetweenDiffKindAndDiffKindComma?.raw, + diffKindComma?.raw, + unexpectedBetweenDiffKindCommaAndDiffParams?.raw, + diffParams?.raw, + unexpectedBetweenDiffParamsAndDiffParamsComma?.raw, + diffParamsComma?.raw, + unexpectedBetweenDiffParamsCommaAndWhereClause?.raw, + whereClause?.raw, + unexpectedAfterWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParamsClause, + kind: SyntaxKind.differentiableAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -7448,80 +8467,120 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl self.init(data) } - public var unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeDiffKind: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The "wrt" label. - public var wrtLabel: TokenSyntax { + public var diffKind: TokenSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The colon separating "wrt" and the parameter list. - public var colon: TokenSyntax { + /// The comma following the differentiability kind, if it exists. + public var diffKindComma: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var parameters: Parameters { + public var diffParams: DifferentiabilityParamsClauseSyntax? { get { - return Parameters(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterParameters: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The comma following the differentiability parameters clause, if it exists. + public var diffParamsComma: TokenSyntax? { + get { + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var whereClause: GenericWhereClauseSyntax? { + get { + return data.child(at: 9, parent: Syntax(self)).map(GenericWhereClauseSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWrtLabel, - \Self.wrtLabel, - \Self.unexpectedBetweenWrtLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndParameters, - \Self.parameters, - \Self.unexpectedAfterParameters + \Self.unexpectedBeforeDiffKind, + \Self.diffKind, + \Self.unexpectedBetweenDiffKindAndDiffKindComma, + \Self.diffKindComma, + \Self.unexpectedBetweenDiffKindCommaAndDiffParams, + \Self.diffParams, + \Self.unexpectedBetweenDiffParamsAndDiffParamsComma, + \Self.diffParamsComma, + \Self.unexpectedBetweenDiffParamsCommaAndWhereClause, + \Self.whereClause, + \Self.unexpectedAfterWhereClause ]) } @@ -7538,84 +8597,144 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl case 4: return nil case 5: - return "parameters" + return nil case 6: return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamsClauseSyntax: CustomReflectable { +extension DifferentiableAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeWrtLabel": unexpectedBeforeWrtLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "wrtLabel": Syntax(wrtLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenWrtLabelAndColon": unexpectedBetweenWrtLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndParameters": unexpectedBetweenColonAndParameters.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "parameters": Syntax(parameters).asProtocol(SyntaxProtocol.self), - "unexpectedAfterParameters": unexpectedAfterParameters.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeDiffKind": unexpectedBeforeDiffKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "diffKind": diffKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenDiffKindAndDiffKindComma": unexpectedBetweenDiffKindAndDiffKindComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "diffKindComma": diffKindComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenDiffKindCommaAndDiffParams": unexpectedBetweenDiffKindCommaAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "diffParams": diffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenDiffParamsAndDiffParamsComma": unexpectedBetweenDiffParamsAndDiffParamsComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "diffParamsComma": diffParamsComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenDiffParamsCommaAndWhereClause": unexpectedBetweenDiffParamsCommaAndWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "whereClause": whereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterWhereClause": unexpectedAfterWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DifferentiabilityParamsSyntax +// MARK: - DocumentationAttributeArgumentSyntax -/// The differentiability parameters. -public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { + +public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable { + public enum Value: SyntaxChildChoices { + case `token`(TokenSyntax) + case `string`(StringLiteralExprSyntax) + + public var _syntaxNode: Syntax { + switch self { + case .token(let node): + return node._syntaxNode + case .string(let node): + return node._syntaxNode + } + } + + init(_ data: SyntaxData) { + self.init(Syntax(data))! + } + + public init(_ node: TokenSyntax) { + self = .token(node) + } + + public init(_ node: StringLiteralExprSyntax) { + self = .string(node) + } + + public init?(_ node: S) { + if let node = node.as(TokenSyntax.self) { + self = .token(node) + return + } + if let node = node.as(StringLiteralExprSyntax.self) { + self = .string(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([.node(TokenSyntax.self), .node(StringLiteralExprSyntax.self)]) + } + } + public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParams else { + guard node.raw.kind == .documentationAttributeArgument else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DocumentationAttributeArgumentSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .differentiabilityParams) + precondition(data.raw.kind == .documentationAttributeArgument) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? = nil, - diffParams: DifferentiabilityParamListSyntax, - _ unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: Value, + _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndDiffParams, - diffParams, - unexpectedBetweenDiffParamsAndRightParen, - rightParen, - unexpectedAfterRightParen + unexpectedBeforeLabel, + label, + unexpectedBetweenLabelAndColon, + colon, + unexpectedBetweenColonAndValue, + value, + unexpectedBetweenValueAndTrailingComma, + trailingComma, + unexpectedAfterTrailingComma ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndDiffParams?.raw, - diffParams.raw, - unexpectedBetweenDiffParamsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndValue?.raw, + value.raw, + unexpectedBetweenValueAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParams, + kind: SyntaxKind.documentationAttributeArgument, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -7626,98 +8745,99 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { + public var label: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The parameters for differentiation. - public var diffParams: DifferentiabilityParamListSyntax { + public var colon: TokenSyntax { get { - return DifferentiabilityParamListSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - /// Adds the provided `DifferentiabilityParam` to the node's `diffParams` - /// collection. - /// - param element: The new `DifferentiabilityParam` to add to the node's - /// `diffParams` collection. - /// - returns: A copy of the receiver with the provided `DifferentiabilityParam` - /// appended to its `diffParams` collection. - public func addDifferentiabilityParam(_ element: DifferentiabilityParamSyntax) -> DifferentiabilityParamsSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[3] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, - from: [element.raw], arena: arena) + public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? { + public var value: Value { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return Value(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var rightParen: TokenSyntax { + public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + /// A trailing comma if this argument is followed by another one + public var trailingComma: TokenSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndDiffParams, - \Self.diffParams, - \Self.unexpectedBetweenDiffParamsAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen + \Self.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedBetweenValueAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma ]) } @@ -7726,7 +8846,7 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: @@ -7737,93 +8857,87 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamsSyntax: CustomReflectable { +extension DocumentationAttributeArgumentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndDiffParams": unexpectedBetweenLeftParenAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "diffParams": Syntax(diffParams).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDiffParamsAndRightParen": unexpectedBetweenDiffParamsAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeLabel": unexpectedBeforeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "label": Syntax(label).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLabelAndColon": unexpectedBetweenLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndValue": unexpectedBetweenColonAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "value": Syntax(value).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenValueAndTrailingComma": unexpectedBetweenValueAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DifferentiableAttributeArgumentsSyntax +// MARK: - DynamicReplacementArgumentsSyntax -/// The arguments for the `@differentiable` attribute: an optional differentiability kind, an optional differentiability parameter clause, and an optional 'where' clause. -public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +/// The arguments for the '@_dynamicReplacement' attribute +public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiableAttributeArguments else { + guard node.raw.kind == .dynamicReplacementArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiableAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DynamicReplacementArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .differentiableAttributeArguments) + precondition(data.raw.kind == .dynamicReplacementArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDiffKind: UnexpectedNodesSyntax? = nil, - diffKind: TokenSyntax? = nil, - _ unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? = nil, - diffKindComma: TokenSyntax? = nil, - _ unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? = nil, - diffParams: DifferentiabilityParamsClauseSyntax? = nil, - _ unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? = nil, - diffParamsComma: TokenSyntax? = nil, - _ unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedAfterWhereClause: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, + forLabel: TokenSyntax = .keyword(.for), + _ unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, + declname: DeclNameSyntax, + _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDiffKind, - diffKind, - unexpectedBetweenDiffKindAndDiffKindComma, - diffKindComma, - unexpectedBetweenDiffKindCommaAndDiffParams, - diffParams, - unexpectedBetweenDiffParamsAndDiffParamsComma, - diffParamsComma, - unexpectedBetweenDiffParamsCommaAndWhereClause, - whereClause, - unexpectedAfterWhereClause + unexpectedBeforeForLabel, + forLabel, + unexpectedBetweenForLabelAndColon, + colon, + unexpectedBetweenColonAndDeclname, + declname, + unexpectedAfterDeclname ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDiffKind?.raw, - diffKind?.raw, - unexpectedBetweenDiffKindAndDiffKindComma?.raw, - diffKindComma?.raw, - unexpectedBetweenDiffKindCommaAndDiffParams?.raw, - diffParams?.raw, - unexpectedBetweenDiffParamsAndDiffParamsComma?.raw, - diffParamsComma?.raw, - unexpectedBetweenDiffParamsCommaAndWhereClause?.raw, - whereClause?.raw, - unexpectedAfterWhereClause?.raw + unexpectedBeforeForLabel?.raw, + forLabel.raw, + unexpectedBetweenForLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndDeclname?.raw, + declname.raw, + unexpectedAfterDeclname?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiableAttributeArguments, + kind: SyntaxKind.dynamicReplacementArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -7834,120 +8948,78 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash self.init(data) } - public var unexpectedBeforeDiffKind: UnexpectedNodesSyntax? { + public var unexpectedBeforeForLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var diffKind: TokenSyntax? { + public var forLabel: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The comma following the differentiability kind, if it exists. - public var diffKindComma: TokenSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var diffParams: DifferentiabilityParamsClauseSyntax? { + public var declname: DeclNameSyntax { get { - return data.child(at: 5, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) + return DeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? { + public var unexpectedAfterDeclname: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The comma following the differentiability parameters clause, if it exists. - public var diffParamsComma: TokenSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } - } - - public var whereClause: GenericWhereClauseSyntax? { - get { - return data.child(at: 9, parent: Syntax(self)).map(GenericWhereClauseSyntax.init) - } - set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDiffKind, - \Self.diffKind, - \Self.unexpectedBetweenDiffKindAndDiffKindComma, - \Self.diffKindComma, - \Self.unexpectedBetweenDiffKindCommaAndDiffParams, - \Self.diffParams, - \Self.unexpectedBetweenDiffParamsAndDiffParamsComma, - \Self.diffParamsComma, - \Self.unexpectedBetweenDiffParamsCommaAndWhereClause, - \Self.whereClause, - \Self.unexpectedAfterWhereClause + \Self.unexpectedBeforeForLabel, + \Self.forLabel, + \Self.unexpectedBetweenForLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndDeclname, + \Self.declname, + \Self.unexpectedAfterDeclname ]) } @@ -7967,141 +9039,87 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash return nil case 6: return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension DifferentiableAttributeArgumentsSyntax: CustomReflectable { +extension DynamicReplacementArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeDiffKind": unexpectedBeforeDiffKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "diffKind": diffKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenDiffKindAndDiffKindComma": unexpectedBetweenDiffKindAndDiffKindComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "diffKindComma": diffKindComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenDiffKindCommaAndDiffParams": unexpectedBetweenDiffKindCommaAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "diffParams": diffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenDiffParamsAndDiffParamsComma": unexpectedBetweenDiffParamsAndDiffParamsComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "diffParamsComma": diffParamsComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenDiffParamsCommaAndWhereClause": unexpectedBetweenDiffParamsCommaAndWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "whereClause": whereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedAfterWhereClause": unexpectedAfterWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeForLabel": unexpectedBeforeForLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "forLabel": Syntax(forLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenForLabelAndColon": unexpectedBetweenForLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndDeclname": unexpectedBetweenColonAndDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "declname": Syntax(declname).asProtocol(SyntaxProtocol.self), + "unexpectedAfterDeclname": unexpectedAfterDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DocumentationAttributeArgumentSyntax - +// MARK: - EnumCaseElementSyntax -public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable { - public enum Value: SyntaxChildChoices { - case `token`(TokenSyntax) - case `string`(StringLiteralExprSyntax) - - public var _syntaxNode: Syntax { - switch self { - case .token(let node): - return node._syntaxNode - case .string(let node): - return node._syntaxNode - } - } - - init(_ data: SyntaxData) { - self.init(Syntax(data))! - } - - public init(_ node: TokenSyntax) { - self = .token(node) - } - - public init(_ node: StringLiteralExprSyntax) { - self = .string(node) - } - - public init?(_ node: S) { - if let node = node.as(TokenSyntax.self) { - self = .token(node) - return - } - if let node = node.as(StringLiteralExprSyntax.self) { - self = .string(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([.node(TokenSyntax.self), .node(StringLiteralExprSyntax.self)]) - } - } - +/// An element of an enum case, containing the name of the case and, optionally, either associated values or an assignment to a raw value. +public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .documentationAttributeArgument else { + guard node.raw.kind == .enumCaseElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DocumentationAttributeArgumentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `EnumCaseElementSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .documentationAttributeArgument) + precondition(data.raw.kind == .enumCaseElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: Value, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax = .identifier("IdentifierToken"), + _ unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? = nil, + associatedValue: EnumCaseParameterClauseSyntax? = nil, + _ unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? = nil, + rawValue: InitializerClauseSyntax? = nil, + _ unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax? = nil, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedBetweenValueAndTrailingComma, + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( + unexpectedBeforeIdentifier, + identifier, + unexpectedBetweenIdentifierAndAssociatedValue, + associatedValue, + unexpectedBetweenAssociatedValueAndRawValue, + rawValue, + unexpectedBetweenRawValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, + unexpectedBeforeIdentifier?.raw, + identifier.raw, + unexpectedBetweenIdentifierAndAssociatedValue?.raw, + associatedValue?.raw, + unexpectedBetweenAssociatedValueAndRawValue?.raw, + rawValue?.raw, + unexpectedBetweenRawValueAndTrailingComma?.raw, trailingComma?.raw, unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.documentationAttributeArgument, + kind: SyntaxKind.enumCaseElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -8112,76 +9130,79 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var label: TokenSyntax { + /// The name of this case. + public var identifier: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + /// The set of associated values of the case. + public var associatedValue: EnumCaseParameterClauseSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(EnumCaseParameterClauseSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var value: Value { + /// The raw value of this enum element, if present. + public var rawValue: InitializerClauseSyntax? { get { - return Value(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(InitializerClauseSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - /// A trailing comma if this argument is followed by another one + /// The trailing comma of this element, if the case has multiple elements. public var trailingComma: TokenSyntax? { get { return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } @@ -8190,19 +9211,19 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedBetweenValueAndTrailingComma, + \Self.unexpectedBeforeIdentifier, + \Self.identifier, + \Self.unexpectedBetweenIdentifierAndAssociatedValue, + \Self.associatedValue, + \Self.unexpectedBetweenAssociatedValueAndRawValue, + \Self.rawValue, + \Self.unexpectedBetweenRawValueAndTrailingComma, \Self.trailingComma, \Self.unexpectedAfterTrailingComma ]) @@ -8213,11 +9234,11 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: - return nil + return "associated values" case 4: return nil case 5: @@ -8234,77 +9255,77 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab } } -extension DocumentationAttributeArgumentSyntax: CustomReflectable { +extension EnumCaseElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLabel": unexpectedBeforeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "label": Syntax(label).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLabelAndColon": unexpectedBetweenLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndValue": unexpectedBetweenColonAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "value": Syntax(value).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenValueAndTrailingComma": unexpectedBetweenValueAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBeforeIdentifier": unexpectedBeforeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "identifier": Syntax(identifier).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenIdentifierAndAssociatedValue": unexpectedBetweenIdentifierAndAssociatedValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "associatedValue": associatedValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenAssociatedValueAndRawValue": unexpectedBetweenAssociatedValueAndRawValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "rawValue": rawValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenRawValueAndTrailingComma": unexpectedBetweenRawValueAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - DynamicReplacementArgumentsSyntax +// MARK: - EnumCaseParameterClauseSyntax -/// The arguments for the '@_dynamicReplacement' attribute -public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable { + +public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dynamicReplacementArguments else { + guard node.raw.kind == .enumCaseParameterClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DynamicReplacementArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `EnumCaseParameterClauseSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .dynamicReplacementArguments) + precondition(data.raw.kind == .enumCaseParameterClause) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, - forLabel: TokenSyntax = .keyword(.for), - _ unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, - declname: DeclNameSyntax, - _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, + parameterList: EnumCaseParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeForLabel, - forLabel, - unexpectedBetweenForLabelAndColon, - colon, - unexpectedBetweenColonAndDeclname, - declname, - unexpectedAfterDeclname + unexpectedBeforeLeftParen, + leftParen, + unexpectedBetweenLeftParenAndParameterList, + parameterList, + unexpectedBetweenParameterListAndRightParen, + rightParen, + unexpectedAfterRightParen ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeForLabel?.raw, - forLabel.raw, - unexpectedBetweenForLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndDeclname?.raw, - declname.raw, - unexpectedAfterDeclname?.raw + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndParameterList?.raw, + parameterList.raw, + unexpectedBetweenParameterListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dynamicReplacementArguments, + kind: SyntaxKind.enumCaseParameterClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -8315,78 +9336,100 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable self.init(data) } - public var unexpectedBeforeForLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var forLabel: TokenSyntax { + /// The '(' to open the parameter clause. + public var leftParen: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = EnumCaseParameterClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + /// The actual parameters. + public var parameterList: EnumCaseParameterListSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return EnumCaseParameterListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = EnumCaseParameterClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { + /// Adds the provided `Parameter` to the node's `parameterList` + /// collection. + /// - param element: The new `Parameter` to add to the node's + /// `parameterList` collection. + /// - returns: A copy of the receiver with the provided `Parameter` + /// appended to its `parameterList` collection. + public func addParameter(_ element: EnumCaseParameterSyntax) -> EnumCaseParameterClauseSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseParameterList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return EnumCaseParameterClauseSyntax(newData) + } + + public var unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var declname: DeclNameSyntax { + /// The ')' to close the parameter clause. + public var rightParen: TokenSyntax { get { - return DeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = EnumCaseParameterClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDeclname: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeForLabel, - \Self.forLabel, - \Self.unexpectedBetweenForLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndDeclname, - \Self.declname, - \Self.unexpectedAfterDeclname + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndParameterList, + \Self.parameterList, + \Self.unexpectedBetweenParameterListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen ]) } @@ -8399,7 +9442,7 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 2: return nil case 3: - return nil + return "parameters" case 4: return nil case 5: @@ -8412,50 +9455,56 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } -extension DynamicReplacementArgumentsSyntax: CustomReflectable { +extension EnumCaseParameterClauseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeForLabel": unexpectedBeforeForLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "forLabel": Syntax(forLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenForLabelAndColon": unexpectedBetweenForLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndDeclname": unexpectedBetweenColonAndDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "declname": Syntax(declname).asProtocol(SyntaxProtocol.self), - "unexpectedAfterDeclname": unexpectedAfterDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any + "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndParameterList": unexpectedBetweenLeftParenAndParameterList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "parameterList": Syntax(parameterList).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenParameterListAndRightParen": unexpectedBetweenParameterListAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) } } -// MARK: - EnumCaseElementSyntax +// MARK: - EnumCaseParameterSyntax -/// An element of an enum case, containing the name of the case and, optionally, either associated values or an assignment to a raw value. -public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { + +public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumCaseElement else { + guard node.raw.kind == .enumCaseParameter else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `EnumCaseElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `EnumCaseParameterSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - precondition(data.raw.kind == .enumCaseElement) + precondition(data.raw.kind == .enumCaseParameter) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax = .identifier("IdentifierToken"), - _ unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? = nil, - associatedValue: ParameterClauseSyntax? = nil, - _ unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? = nil, - rawValue: InitializerClauseSyntax? = nil, - _ unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax? = nil, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndDefaultArgument: UnexpectedNodesSyntax? = nil, + defaultArgument: InitializerClauseSyntax? = nil, + _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax? = nil, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -8464,29 +9513,41 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeIdentifier, - identifier, - unexpectedBetweenIdentifierAndAssociatedValue, - associatedValue, - unexpectedBetweenAssociatedValueAndRawValue, - rawValue, - unexpectedBetweenRawValueAndTrailingComma, + unexpectedBeforeModifiers, + modifiers, + unexpectedBetweenModifiersAndFirstName, + firstName, + unexpectedBetweenFirstNameAndSecondName, + secondName, + unexpectedBetweenSecondNameAndColon, + colon, + unexpectedBetweenColonAndType, + type, + unexpectedBetweenTypeAndDefaultArgument, + defaultArgument, + unexpectedBetweenDefaultArgumentAndTrailingComma, trailingComma, unexpectedAfterTrailingComma ))) {(arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndAssociatedValue?.raw, - associatedValue?.raw, - unexpectedBetweenAssociatedValueAndRawValue?.raw, - rawValue?.raw, - unexpectedBetweenRawValueAndTrailingComma?.raw, + unexpectedBeforeModifiers?.raw, + modifiers?.raw, + unexpectedBetweenModifiersAndFirstName?.raw, + firstName?.raw, + unexpectedBetweenFirstNameAndSecondName?.raw, + secondName?.raw, + unexpectedBetweenSecondNameAndColon?.raw, + colon?.raw, + unexpectedBetweenColonAndType?.raw, + type.raw, + unexpectedBetweenTypeAndDefaultArgument?.raw, + defaultArgument?.raw, + unexpectedBetweenDefaultArgumentAndTrailingComma?.raw, trailingComma?.raw, unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseElement, + kind: SyntaxKind.enumCaseParameter, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -8497,100 +9558,179 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeModifiers: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The name of this case. - public var identifier: TokenSyntax { + public var modifiers: ModifierListSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(ModifierListSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? { + /// Adds the provided `Modifier` to the node's `modifiers` + /// collection. + /// - param element: The new `Modifier` to add to the node's + /// `modifiers` collection. + /// - returns: A copy of the receiver with the provided `Modifier` + /// appended to its `modifiers` collection. + public func addModifier(_ element: DeclModifierSyntax) -> EnumCaseParameterSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[1] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return EnumCaseParameterSyntax(newData) + } + + public var unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The set of associated values of the case. - public var associatedValue: ParameterClauseSyntax? { + public var firstName: TokenSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(ParameterClauseSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - /// The raw value of this enum element, if present. - public var rawValue: InitializerClauseSyntax? { + public var secondName: TokenSyntax? { get { - return data.child(at: 5, parent: Syntax(self)).map(InitializerClauseSyntax.init) + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - /// The trailing comma of this element, if the case has multiple elements. - public var trailingComma: TokenSyntax? { + /// If the parameter has a label, the colon separating the label from the type. + public var colon: TokenSyntax? { get { return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndType: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseParameterSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The parameter's type. + public var type: TypeSyntax { + get { + return TypeSyntax(data.child(at: 9, parent: Syntax(self))!) + } + set(value) { + self = EnumCaseParameterSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenTypeAndDefaultArgument: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = EnumCaseParameterSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + } + } + + /// If the parameter has a default value, the initializer clause describing the default value. + public var defaultArgument: InitializerClauseSyntax? { + get { + return data.child(at: 11, parent: Syntax(self)).map(InitializerClauseSyntax.init) + } + set(value) { + self = EnumCaseParameterSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = EnumCaseParameterSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + } + } + + /// If the parameter is followed by another parameter, the comma separating them. + public var trailingComma: TokenSyntax? { + get { + return data.child(at: 13, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = EnumCaseParameterSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = EnumCaseParameterSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIdentifier, - \Self.identifier, - \Self.unexpectedBetweenIdentifierAndAssociatedValue, - \Self.associatedValue, - \Self.unexpectedBetweenAssociatedValueAndRawValue, - \Self.rawValue, - \Self.unexpectedBetweenRawValueAndTrailingComma, + \Self.unexpectedBeforeModifiers, + \Self.modifiers, + \Self.unexpectedBetweenModifiersAndFirstName, + \Self.firstName, + \Self.unexpectedBetweenFirstNameAndSecondName, + \Self.secondName, + \Self.unexpectedBetweenSecondNameAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndType, + \Self.type, + \Self.unexpectedBetweenTypeAndDefaultArgument, + \Self.defaultArgument, + \Self.unexpectedBetweenDefaultArgumentAndTrailingComma, \Self.trailingComma, \Self.unexpectedAfterTrailingComma ]) @@ -8601,11 +9741,11 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "modifiers" case 2: return nil case 3: - return "associated values" + return nil case 4: return nil case 5: @@ -8616,22 +9756,40 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { return nil case 8: return nil + case 9: + return "type" + case 10: + return nil + case 11: + return "default argument" + case 12: + return nil + case 13: + return nil + case 14: + return nil default: fatalError("Invalid index") } } } -extension EnumCaseElementSyntax: CustomReflectable { +extension EnumCaseParameterSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeIdentifier": unexpectedBeforeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "identifier": Syntax(identifier).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenIdentifierAndAssociatedValue": unexpectedBetweenIdentifierAndAssociatedValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "associatedValue": associatedValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenAssociatedValueAndRawValue": unexpectedBetweenAssociatedValueAndRawValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "rawValue": rawValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "unexpectedBetweenRawValueAndTrailingComma": unexpectedBetweenRawValueAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBeforeModifiers": unexpectedBeforeModifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "modifiers": modifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenModifiersAndFirstName": unexpectedBetweenModifiersAndFirstName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "firstName": firstName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenFirstNameAndSecondName": unexpectedBetweenFirstNameAndSecondName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "secondName": secondName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenSecondNameAndColon": unexpectedBetweenSecondNameAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenColonAndType": unexpectedBetweenColonAndType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "type": Syntax(type).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenTypeAndDefaultArgument": unexpectedBetweenTypeAndDefaultArgument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "defaultArgument": defaultArgument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "unexpectedBetweenDefaultArgumentAndTrailingComma": unexpectedBetweenDefaultArgumentAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any ]) @@ -9101,13 +10259,13 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, modifiers: ModifierListSyntax? = nil, _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, - firstName: TokenSyntax? = nil, + firstName: TokenSyntax, _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, secondName: TokenSyntax? = nil, _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, + colon: TokenSyntax = .colonToken(), _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: T? = nil, + type: T, _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, ellipsis: TokenSyntax? = nil, _ unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? = nil, @@ -9147,13 +10305,13 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAttributesAndModifiers?.raw, modifiers?.raw, unexpectedBetweenModifiersAndFirstName?.raw, - firstName?.raw, + firstName.raw, unexpectedBetweenFirstNameAndSecondName?.raw, secondName?.raw, unexpectedBetweenSecondNameAndColon?.raw, - colon?.raw, + colon.raw, unexpectedBetweenColonAndType?.raw, - type?.raw, + type.raw, unexpectedBetweenTypeAndEllipsis?.raw, ellipsis?.raw, unexpectedBetweenEllipsisAndDefaultArgument?.raw, @@ -9174,65 +10332,6 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { self.init(data) } - /// This initializer exists solely because Swift 5.6 does not support - /// `Optional.none` as a default value of a generic parameter. - /// The above initializer thus defaults to `nil` instead, but that means it - /// is not actually callable when either not passing the defaulted parameter, - /// or passing `nil`. - /// - /// Hack around that limitation using this initializer, which takes a - /// `Missing*` syntax node instead. `Missing*` is used over the base type as - /// the base type would allow implicit conversion from a string literal, - /// which the above initializer doesn't support. - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, - firstName: TokenSyntax? = nil, - _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, - secondName: TokenSyntax? = nil, - _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: MissingTypeSyntax? = nil, - _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, - ellipsis: TokenSyntax? = nil, - _ unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? = nil, - defaultArgument: InitializerClauseSyntax? = nil, - _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - - ) { - self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndFirstName, - firstName: firstName, - unexpectedBetweenFirstNameAndSecondName, - secondName: secondName, - unexpectedBetweenSecondNameAndColon, - colon: colon, - unexpectedBetweenColonAndType, - type: Optional.none, - unexpectedBetweenTypeAndEllipsis, - ellipsis: ellipsis, - unexpectedBetweenEllipsisAndDefaultArgument, - defaultArgument: defaultArgument, - unexpectedBetweenDefaultArgumentAndTrailingComma, - trailingComma: trailingComma, - unexpectedAfterTrailingComma, - trailingTrivia: trailingTrivia - ) - } - public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) @@ -9316,12 +10415,12 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { } } - public var firstName: TokenSyntax? { + public var firstName: TokenSyntax { get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } @@ -9352,12 +10451,12 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { } } - public var colon: TokenSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 9, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) } } @@ -9370,12 +10469,12 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { } } - public var type: TypeSyntax? { + public var type: TypeSyntax { get { - return data.child(at: 11, parent: Syntax(self)).map(TypeSyntax.init) + return TypeSyntax(data.child(at: 11, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 11, with: value.raw, arena: SyntaxArena())) } } @@ -9520,13 +10619,13 @@ extension FunctionParameterSyntax: CustomReflectable { "unexpectedBetweenAttributesAndModifiers": unexpectedBetweenAttributesAndModifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "modifiers": modifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "unexpectedBetweenModifiersAndFirstName": unexpectedBetweenModifiersAndFirstName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "firstName": firstName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "firstName": Syntax(firstName).asProtocol(SyntaxProtocol.self), "unexpectedBetweenFirstNameAndSecondName": unexpectedBetweenFirstNameAndSecondName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "secondName": secondName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "unexpectedBetweenSecondNameAndColon": unexpectedBetweenSecondNameAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), "unexpectedBetweenColonAndType": unexpectedBetweenColonAndType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , - "type": type.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , + "type": Syntax(type).asProtocol(SyntaxProtocol.self), "unexpectedBetweenTypeAndEllipsis": unexpectedBetweenTypeAndEllipsis.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "ellipsis": ellipsis.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , "unexpectedBetweenEllipsisAndDefaultArgument": unexpectedBetweenEllipsisAndDefaultArgument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any , diff --git a/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift b/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift index d1af82e6088..68c69ddd816 100644 --- a/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift +++ b/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift @@ -163,29 +163,6 @@ extension FunctionCallExprSyntax { } } -// MARK: - FunctionParameter - -// TODO: We should split FunctionParameter into separate nodes -// -// This would allow them to be both `SyntaxParseable` and -// `SyntaxExpressibleByStringInterpolation`, allowing this initializer to be -// removed. In general we shouldn't allow the builder to take arbitrary -// strings, only literals. -extension FunctionParameterSyntax { - public init( - _ source: PartialSyntaxNodeString, - for subject: Parser.ParameterSubject - ) { - self = performParse( - source: source.sourceText, - parse: { - let raw = RawSyntax($0.parseFunctionParameter(for: subject)) - return Syntax(raw: raw).cast(FunctionParameterSyntax.self) - } - ) - } -} - // MARK: - IntegerLiteralExpr extension IntegerLiteralExprSyntax: ExpressibleByIntegerLiteral { diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift index 549c78df4fb..999740263a7 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift @@ -91,6 +91,13 @@ extension ClosureParamListSyntax: ExpressibleByArrayLiteral { } } +/// `ClosureParameterList` represents a collection of `ClosureParameterSyntax` +extension ClosureParameterListSyntax: ExpressibleByArrayLiteral { + public init(arrayLiteral elements: Element...) { + self.init(elements) + } +} + /// `CodeBlockItemList` represents a collection of `CodeBlockItemSyntax` extension CodeBlockItemListSyntax: ExpressibleByArrayLiteral { public init(arrayLiteral elements: Element...) { @@ -161,6 +168,13 @@ extension EnumCaseElementListSyntax: ExpressibleByArrayLiteral { } } +/// `EnumCaseParameterList` represents a collection of `EnumCaseParameterSyntax` +extension EnumCaseParameterListSyntax: ExpressibleByArrayLiteral { + public init(arrayLiteral elements: Element...) { + self.init(elements) + } +} + /// A list of expressions connected by operators. This list is contained by a `SequenceExprSyntax`. extension ExprListSyntax: ExpressibleByArrayLiteral { public init(_ elements: [ExprSyntaxProtocol]) { diff --git a/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift b/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift index 6d1aee42ba1..9711f368334 100644 --- a/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift +++ b/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift @@ -921,6 +921,89 @@ public extension ClosureParamListSyntax { } } +@resultBuilder +public struct ClosureParameterListBuilder { + /// The type of individual statement expressions in the transformed function, + /// which defaults to Component if buildExpression() is not provided. + public typealias Expression = ClosureParameterSyntax + + /// The type of a partial result, which will be carried through all of the + /// build methods. + public typealias Component = [Expression] + + /// The type of the final returned result, which defaults to Component if + /// buildFinalResult() is not provided. + public typealias FinalResult = ClosureParameterListSyntax + + /// Required by every result builder to build combined results from + /// statement blocks. + public static func buildBlock(_ components: Self.Component...) -> Self.Component { + return components.flatMap { + $0 + } + } + + /// If declared, provides contextual type information for statement + /// expressions to translate them into partial results. + public static func buildExpression(_ expression: Self.Expression) -> Self.Component { + return [expression] + } + + /// Add all the elements of `expression` to this result builder, effectively flattening them. + public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { + return expression.map { + $0 + } + } + + /// Enables support for `if` statements that do not have an `else`. + public static func buildOptional(_ component: Self.Component?) -> Self.Component { + return component ?? [] + } + + /// With buildEither(second:), enables support for 'if-else' and 'switch' + /// statements by folding conditional results into a single result. + public static func buildEither(first component: Self.Component) -> Self.Component { + return component + } + + /// With buildEither(first:), enables support for 'if-else' and 'switch' + /// statements by folding conditional results into a single result. + public static func buildEither(second component: Self.Component) -> Self.Component { + return component + } + + /// Enables support for 'for..in' loops by combining the + /// results of all iterations into a single result. + public static func buildArray(_ components: [Self.Component]) -> Self.Component { + return components.flatMap { + $0 + } + } + + /// If declared, this will be called on the partial result of an 'if' + /// #available' block to allow the result builder to erase type + /// information. + public static func buildLimitedAvailability(_ component: Self.Component) -> Self.Component { + return component + } + + /// If declared, this will be called on the partial result from the outermost + /// block statement to produce the final returned result. + public static func buildFinalResult(_ component: Component) -> FinalResult { + let lastIndex = component.count - 1 + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source + }) + } +} + +public extension ClosureParameterListSyntax { + init(@ClosureParameterListBuilder itemsBuilder: () throws -> ClosureParameterListSyntax) rethrows { + self = try itemsBuilder() + } +} + @resultBuilder public struct CodeBlockItemListBuilder { /// The type of individual statement expressions in the transformed function, @@ -1736,6 +1819,89 @@ public extension EnumCaseElementListSyntax { } } +@resultBuilder +public struct EnumCaseParameterListBuilder { + /// The type of individual statement expressions in the transformed function, + /// which defaults to Component if buildExpression() is not provided. + public typealias Expression = EnumCaseParameterSyntax + + /// The type of a partial result, which will be carried through all of the + /// build methods. + public typealias Component = [Expression] + + /// The type of the final returned result, which defaults to Component if + /// buildFinalResult() is not provided. + public typealias FinalResult = EnumCaseParameterListSyntax + + /// Required by every result builder to build combined results from + /// statement blocks. + public static func buildBlock(_ components: Self.Component...) -> Self.Component { + return components.flatMap { + $0 + } + } + + /// If declared, provides contextual type information for statement + /// expressions to translate them into partial results. + public static func buildExpression(_ expression: Self.Expression) -> Self.Component { + return [expression] + } + + /// Add all the elements of `expression` to this result builder, effectively flattening them. + public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { + return expression.map { + $0 + } + } + + /// Enables support for `if` statements that do not have an `else`. + public static func buildOptional(_ component: Self.Component?) -> Self.Component { + return component ?? [] + } + + /// With buildEither(second:), enables support for 'if-else' and 'switch' + /// statements by folding conditional results into a single result. + public static func buildEither(first component: Self.Component) -> Self.Component { + return component + } + + /// With buildEither(first:), enables support for 'if-else' and 'switch' + /// statements by folding conditional results into a single result. + public static func buildEither(second component: Self.Component) -> Self.Component { + return component + } + + /// Enables support for 'for..in' loops by combining the + /// results of all iterations into a single result. + public static func buildArray(_ components: [Self.Component]) -> Self.Component { + return components.flatMap { + $0 + } + } + + /// If declared, this will be called on the partial result of an 'if' + /// #available' block to allow the result builder to erase type + /// information. + public static func buildLimitedAvailability(_ component: Self.Component) -> Self.Component { + return component + } + + /// If declared, this will be called on the partial result from the outermost + /// block statement to produce the final returned result. + public static func buildFinalResult(_ component: Component) -> FinalResult { + let lastIndex = component.count - 1 + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source + }) + } +} + +public extension EnumCaseParameterListSyntax { + init(@EnumCaseParameterListBuilder itemsBuilder: () throws -> EnumCaseParameterListSyntax) rethrows { + self = try itemsBuilder() + } +} + @resultBuilder public struct ExprListBuilder { /// The type of individual statement expressions in the transformed function, diff --git a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift index e0d0abf10ae..c33ef072662 100644 --- a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift +++ b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift @@ -32,10 +32,16 @@ extension AttributeSyntax: SyntaxExpressibleByStringInterpolation {} extension CatchClauseSyntax: SyntaxExpressibleByStringInterpolation {} +extension ClosureParameterSyntax: SyntaxExpressibleByStringInterpolation {} + extension DeclSyntax: SyntaxExpressibleByStringInterpolation {} +extension EnumCaseParameterSyntax: SyntaxExpressibleByStringInterpolation {} + extension ExprSyntax: SyntaxExpressibleByStringInterpolation {} +extension FunctionParameterSyntax: SyntaxExpressibleByStringInterpolation {} + extension GenericParameterClauseSyntax: SyntaxExpressibleByStringInterpolation {} extension MemberDeclBlockSyntax: SyntaxExpressibleByStringInterpolation {} diff --git a/Sources/SwiftSyntaxMacros/FunctionParameterUtils.swift b/Sources/SwiftSyntaxMacros/FunctionParameterUtils.swift index 9ad940b3ff0..dcbc888e4c2 100644 --- a/Sources/SwiftSyntaxMacros/FunctionParameterUtils.swift +++ b/Sources/SwiftSyntaxMacros/FunctionParameterUtils.swift @@ -19,14 +19,10 @@ extension FunctionParameterSyntax { return secondName } - if let firstName = firstName { - if firstName.text == "_" { - return nil - } - - return firstName + if firstName.text == "_" { + return nil } - return nil + return firstName } } diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index 66c544fc884..3e2bedbfb4c 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -55,11 +55,12 @@ final class DeclarationTests: XCTestCase { diagnostics: [ DiagnosticSpec(locationMarker: "1️⃣", message: "keyword 'where' cannot be used as an identifier here", fixIts: ["if this name is unavoidable, use backticks to escape it"]), DiagnosticSpec(locationMarker: "2️⃣", message: "expected '(' to start parameter clause", fixIts: ["insert '('"]), + DiagnosticSpec(locationMarker: "3️⃣", message: "expected ':' and type in parameter"), DiagnosticSpec(locationMarker: "3️⃣", message: "expected ')' to end parameter clause", fixIts: ["insert ')'"]), ], fixedSource: """ func `where`( - r) + r: <#type#>) """ ) diff --git a/Tests/SwiftParserTest/ExpressionTests.swift b/Tests/SwiftParserTest/ExpressionTests.swift index 6b822a57649..3d6c5987c67 100644 --- a/Tests/SwiftParserTest/ExpressionTests.swift +++ b/Tests/SwiftParserTest/ExpressionTests.swift @@ -1921,4 +1921,34 @@ final class StatementExpressionTests: XCTestCase { ] ) } + + func testClosureParameterWithModifier() { + assertParse( + """ + _ = { (_const x: Int) in } + """ + ) + } + + func testClosureWithExternalParameterName() { + assertParse( + """ + _ = { (_ x: MyType) in } + """ + ) + + // Using anything but '_' for the first parameter name is valid in SwiftSyntax + // but should be diagnosed in the compiler. + assertParse( + """ + _ = { (x y: MyType) in } + """ + ) + } + + func testClosureParameterWithAttribute() { + assertParse("_ = { (@_noImplicitCopy _ x: Int) -> () in }") + + assertParse("_ = { (@Wrapper x) in }") + } } diff --git a/Tests/SwiftParserTest/StatementTests.swift b/Tests/SwiftParserTest/StatementTests.swift index 454f49c0e21..52a2df5819e 100644 --- a/Tests/SwiftParserTest/StatementTests.swift +++ b/Tests/SwiftParserTest/StatementTests.swift @@ -692,7 +692,7 @@ final class StatementTests: XCTestCase { subscript(1️⃣{@2️⃣self _modify3️⃣ """, diagnostics: [ - DiagnosticSpec(locationMarker: "1️⃣", message: "expected type and ')' to end parameter clause"), + DiagnosticSpec(locationMarker: "1️⃣", message: "expected ')' to end parameter clause"), DiagnosticSpec(locationMarker: "1️⃣", message: "expected '->' and return type in subscript"), DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in attribute"), DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected 'self' keyword in accessor"), diff --git a/Tests/SwiftParserTest/translated/EnumTests.swift b/Tests/SwiftParserTest/translated/EnumTests.swift index d1b3d28a830..365bcff77df 100644 --- a/Tests/SwiftParserTest/translated/EnumTests.swift +++ b/Tests/SwiftParserTest/translated/EnumTests.swift @@ -289,13 +289,12 @@ final class EnumTests: XCTestCase { diagnostics: [ DiagnosticSpec(locationMarker: "1️⃣", message: "expected identifier in enum case"), DiagnosticSpec(locationMarker: "2️⃣", message: "expected ':' and type in parameter"), - DiagnosticSpec(locationMarker: "3️⃣", message: "expected type in parameter"), DiagnosticSpec(locationMarker: "3️⃣", message: "unexpected code '0' in parameter clause"), DiagnosticSpec(locationMarker: "4️⃣", message: "unexpected code ':' in enum"), ], fixedSource: """ enum SwitchEnvy { - case <#identifier#>(_, var x: <#type#>, <#type#>0): + case <#identifier#>(_, var x: <#type#>, 0): } """ ) @@ -1348,4 +1347,13 @@ final class EnumTests: XCTestCase { ) } + func testEnumCaseWithWildcardAsFirstName() { + assertParse( + #""" + enum Foo { + case a(_ x: Int) + } + """# + ) + } } diff --git a/Tests/SwiftParserTest/translated/InvalidTests.swift b/Tests/SwiftParserTest/translated/InvalidTests.swift index 6d3beb05502..de836932453 100644 --- a/Tests/SwiftParserTest/translated/InvalidTests.swift +++ b/Tests/SwiftParserTest/translated/InvalidTests.swift @@ -480,13 +480,17 @@ final class InvalidTests: XCTestCase { assertParse( """ func were1️⃣ - wolf2️⃣() {} + wolf2️⃣() 3️⃣{} """, diagnostics: [ DiagnosticSpec(locationMarker: "1️⃣", message: "expected '(' to start parameter clause"), - DiagnosticSpec(locationMarker: "2️⃣", message: "expected ')' to end parameter clause"), - DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '()' in function"), - ] + DiagnosticSpec(locationMarker: "2️⃣", message: "expected ':' in parameter"), + DiagnosticSpec(locationMarker: "3️⃣", message: "expected ')' to end parameter clause"), + ], + fixedSource: """ + func were( + wolf: () ){} + """ ) } @@ -494,12 +498,13 @@ final class InvalidTests: XCTestCase { assertParse( """ func hammer1️⃣ - leavings2️⃣(x: T) {} + leavings2️⃣(x: T) {} """, diagnostics: [ DiagnosticSpec(locationMarker: "1️⃣", message: "expected '(' to start parameter clause"), + DiagnosticSpec(locationMarker: "2️⃣", message: "expected ':' and type in parameter"), DiagnosticSpec(locationMarker: "2️⃣", message: "expected ')' to end parameter clause"), - DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(x: T)' in function"), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(x: T)' in function"), ] ) } diff --git a/Tests/SwiftParserTest/translated/RecoveryTests.swift b/Tests/SwiftParserTest/translated/RecoveryTests.swift index 40f4a03eb6a..01bac7fb9a0 100644 --- a/Tests/SwiftParserTest/translated/RecoveryTests.swift +++ b/Tests/SwiftParserTest/translated/RecoveryTests.swift @@ -1439,7 +1439,6 @@ final class RecoveryTests: XCTestCase { """#, diagnostics: [ DiagnosticSpec(locationMarker: "1️⃣", message: "expected 'func' in function"), - DiagnosticSpec(locationMarker: "2️⃣", message: "expected type in parameter"), DiagnosticSpec(locationMarker: "2️⃣", message: #"unexpected code '"No one else was in the room where it happened"' in parameter clause"#), ] ) @@ -1454,7 +1453,6 @@ final class RecoveryTests: XCTestCase { """#, diagnostics: [ DiagnosticSpec(locationMarker: "1️⃣", message: "expected 'func' in function"), - DiagnosticSpec(locationMarker: "2️⃣", message: "expected type in parameter"), DiagnosticSpec(locationMarker: "2️⃣", message: #"unexpected code '"The room where it happened, the room where it happened"' in parameter clause"#), ] ) @@ -1618,11 +1616,12 @@ final class RecoveryTests: XCTestCase { // Parser hangs at swift::Parser::parseType public enum TestA { public static func convertFromExtenndition( - s._core.count 1️⃣!= 0, "Can't form a Character from an empty String") + s1️⃣._core.count != 0, "Can't form a Character from an empty String") } """#, diagnostics: [ - DiagnosticSpec(message: #"unexpected code '!= 0, "Can't form a Character from an empty String"' in parameter clause"#) + DiagnosticSpec(message: "expected ':' and type in parameter"), + DiagnosticSpec(message: #"unexpected code '._core.count != 0, "Can't form a Character from an empty String"' in parameter clause"#), ] ) } @@ -1632,11 +1631,12 @@ final class RecoveryTests: XCTestCase { #""" public enum TestB { public static func convertFromExtenndition( - s._core.count 1️⃣?= 0, "Can't form a Character from an empty String") + s1️⃣._core.count ?= 0, "Can't form a Character from an empty String") } """#, diagnostics: [ - DiagnosticSpec(message: #"unexpected code '?= 0, "Can't form a Character from an empty String"' in parameter clause"#) + DiagnosticSpec(message: "expected ':' and type in parameter"), + DiagnosticSpec(message: #"unexpected code '._core.count ?= 0, "Can't form a Character from an empty String"' in parameter clause"#), ] ) } @@ -1654,10 +1654,11 @@ final class RecoveryTests: XCTestCase { assertParse( """ var baz: bar - func foo1(bar!=baz) {} + func foo1(bar1️⃣!=baz) {} """, diagnostics: [ - // TODO: Old parser expected error on line 2: unnamed parameters must be written with the empty name '_' + DiagnosticSpec(message: "expected ':' and type in parameter"), + DiagnosticSpec(message: "unexpected code '!=baz' in parameter clause"), ] ) } @@ -1665,10 +1666,11 @@ final class RecoveryTests: XCTestCase { func testRecovery137() { assertParse( """ - func foo2(bar! = baz) {} + func foo2(bar1️⃣! = baz) {} """, diagnostics: [ - // TODO: Old parser expected error on line 1: unnamed parameters must be written with the empty name '_' + DiagnosticSpec(message: "expected ':' and type in parameter"), + DiagnosticSpec(message: "unexpected code '! = baz' in parameter clause"), ] ) } @@ -1721,7 +1723,7 @@ final class RecoveryTests: XCTestCase { """, diagnostics: [ DiagnosticSpec(locationMarker: "1️⃣", message: "expected '>' to end generic parameter clause"), - DiagnosticSpec(locationMarker: "2️⃣", message: "expected type and ')' to end parameter clause"), + DiagnosticSpec(locationMarker: "2️⃣", message: "expected ')' to end parameter clause"), DiagnosticSpec(locationMarker: "3️⃣", message: "unexpected code ')}' before struct"), DiagnosticSpec(locationMarker: "4️⃣", message: "initializers cannot have a name", fixIts: ["remove 'x'"]), ] diff --git a/Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift b/Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift index fea0bea81a1..29052f5d2c2 100644 --- a/Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift +++ b/Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift @@ -378,15 +378,11 @@ public struct AddCompletionHandler: PeerMacro { newParameterList = parameterList.appending(completionHandlerParam) } - let callArguments: [String] = try parameterList.map { param in - guard let argName = param.secondName ?? param.firstName else { - throw CustomError.message( - "@addCompletionHandler argument must have a name" - ) - } + let callArguments: [String] = parameterList.map { param in + let argName = param.secondName ?? param.firstName - if let paramName = param.firstName, paramName.text != "_" { - return "\(paramName.text): \(argName.text)" + if param.firstName.text != "_" { + return "\(param.firstName.text): \(argName.text)" } return "\(argName.text)"