From fe710b249a8fc19a6763e63e6ead2277b6b2d276 Mon Sep 17 00:00:00 2001 From: Alex Hoppen Date: Thu, 30 Mar 2023 08:19:52 -0700 Subject: [PATCH] Split FunctionParameterSyntax and related types FunctionParameterSyntax was used in a number of cases (function parameter, closure parameter and enum case parameter) and because it needs to satisfy all of them all its parameters are optional. Split it into three different types that have non-optional children. rdar://106874808 --- .../Sources/SyntaxSupport/DeclNodes.swift | 100 +- .../Sources/SyntaxSupport/ExprNodes.swift | 97 +- .../generated/BasicFormat.swift | 4 + Sources/SwiftParser/CMakeLists.txt | 1 + Sources/SwiftParser/Declarations.swift | 190 +- Sources/SwiftParser/Expressions.swift | 5 +- Sources/SwiftParser/Names.swift | 4 +- Sources/SwiftParser/Parameters.swift | 298 + .../SwiftParser/generated/Parser+Entry.swift | 24 + .../ParseDiagnosticsGenerator.swift | 2 +- .../generated/SwiftSyntax.md | 6 + Sources/SwiftSyntax/generated/Misc.swift | 30 + .../generated/SyntaxAnyVisitor.swift | 48 + .../generated/SyntaxCollections.swift | 446 ++ .../SwiftSyntax/generated/SyntaxEnum.swift | 18 + .../SwiftSyntax/generated/SyntaxKind.swift | 10 + .../generated/SyntaxRewriter.swift | 150 + .../SwiftSyntax/generated/SyntaxTraits.swift | 8 + .../generated/SyntaxTransform.swift | 84 + .../SwiftSyntax/generated/SyntaxVisitor.swift | 150 + .../generated/raw/RawSyntaxNodes.swift | 572 +- .../generated/raw/RawSyntaxValidation.swift | 70 +- .../generated/syntaxNodes/SyntaxNodes.swift | 5309 ++++++++++------- .../ConvenienceInitializers.swift | 23 - .../generated/BuildableCollectionNodes.swift | 14 + .../generated/ResultBuilders.swift | 166 + ...bleByStringInterpolationConformances.swift | 6 + .../FunctionParameterUtils.swift | 10 +- Tests/SwiftParserTest/DeclarationTests.swift | 3 +- Tests/SwiftParserTest/ExpressionTests.swift | 30 + Tests/SwiftParserTest/StatementTests.swift | 2 +- .../translated/EnumTests.swift | 12 +- .../translated/InvalidTests.swift | 17 +- .../translated/RecoveryTests.swift | 24 +- .../MacroSystemTests.swift | 12 +- 35 files changed, 5568 insertions(+), 2377 deletions(-) create mode 100644 Sources/SwiftParser/Parameters.swift 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)"