From 3986f911ba1a7030940663105577ee48a3607d31 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Fri, 13 Jan 2023 10:26:58 +0000 Subject: [PATCH 1/7] Re-introduce ExpressionStmtSyntax This was recently removed, but will represent an if/switch expression when used as a statement. --- gyb_syntax_support/StmtNodes.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/gyb_syntax_support/StmtNodes.py b/gyb_syntax_support/StmtNodes.py index 0db0bff3010..8d3362327d4 100644 --- a/gyb_syntax_support/StmtNodes.py +++ b/gyb_syntax_support/StmtNodes.py @@ -10,6 +10,12 @@ Child('Statement', kind='Stmt'), ]), + # expr-stmt -> expression ';'? + Node('ExpressionStmt', name_for_diagnostics='expression', kind='Stmt', + children=[ + Child('Expression', kind='Expr'), + ]), + # continue-stmt -> 'continue' label? ';'? Node('ContinueStmt', name_for_diagnostics="'continue' statement", kind='Stmt', children=[ From accec5955549ef4d69bf4265bf2a020fc19492f0 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Fri, 13 Jan 2023 10:26:58 +0000 Subject: [PATCH 2/7] Introduce IfExprSyntax This replaces IfStmtSyntax, and will be wrapped in an ExpressionStmtSyntax when used as a statement. --- gyb_syntax_support/ExprNodes.py | 19 +++++++++++++++++++ gyb_syntax_support/StmtNodes.py | 19 ------------------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/gyb_syntax_support/ExprNodes.py b/gyb_syntax_support/ExprNodes.py index d923360c20c..f58d25bd44e 100644 --- a/gyb_syntax_support/ExprNodes.py +++ b/gyb_syntax_support/ExprNodes.py @@ -281,6 +281,25 @@ Child("BooleanLiteral", kind='KeywordToken', text_choices=['true', 'false']) ]), + # if-stmt -> identifier? ':'? 'if' condition-list code-block + # else-clause ';'? + Node('IfExpr', name_for_diagnostics="'if' statement", kind='Expr', + traits=['WithCodeBlock'], + children=[ + Child('IfKeyword', kind='KeywordToken', text_choices=['if']), + Child('Conditions', kind='ConditionElementList', + collection_element_name='Condition'), + Child('Body', kind='CodeBlock', name_for_diagnostics='body'), + Child('ElseKeyword', kind='ElseToken', + is_optional=True), + Child('ElseBody', kind='Syntax', name_for_diagnostics='else body', + node_choices=[ + Child('IfExpr', kind='IfExpr'), + Child('CodeBlock', kind='CodeBlock'), + ], + is_optional=True), + ]), + # ? expr : # Ternary expression without the condition and the second choice. # NOTE: This appears only in SequenceExpr. diff --git a/gyb_syntax_support/StmtNodes.py b/gyb_syntax_support/StmtNodes.py index 8d3362327d4..8aec3ceb3e1 100644 --- a/gyb_syntax_support/StmtNodes.py +++ b/gyb_syntax_support/StmtNodes.py @@ -250,25 +250,6 @@ Child('Expression', kind='Expr'), ]), - # if-stmt -> identifier? ':'? 'if' condition-list code-block - # else-clause ';'? - Node('IfStmt', name_for_diagnostics="'if' statement", kind='Stmt', - traits=['WithCodeBlock'], - children=[ - Child('IfKeyword', kind='KeywordToken', text_choices=['if']), - Child('Conditions', kind='ConditionElementList', - collection_element_name='Condition'), - Child('Body', kind='CodeBlock', name_for_diagnostics='body'), - Child('ElseKeyword', kind='ElseToken', - is_optional=True), - Child('ElseBody', kind='Syntax', name_for_diagnostics='else body', - node_choices=[ - Child('IfStmt', kind='IfStmt'), - Child('CodeBlock', kind='CodeBlock'), - ], - is_optional=True), - ]), - # switch-case -> unknown-attr? switch-case-label stmt-list # | unknown-attr? switch-default-label stmt-list Node('SwitchCase', name_for_diagnostics='switch case', kind='Syntax', From 7b3522c964419d5ace6cfdcc982ab87849ac2058 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Fri, 13 Jan 2023 10:26:58 +0000 Subject: [PATCH 3/7] Parse IfExprSyntax Update the parser to support parsing IfExprSyntax. For now, this only updates the existing statement parsing, and does not attempt to parse in expression position. --- Sources/SwiftParser/Expressions.swift | 45 +++++++++ Sources/SwiftParser/Statements.swift | 48 ++------- .../MigrateToNewIfLetSyntax.swift | 6 +- .../ConvenienceInitializers.swift | 2 +- .../SyntaxNodeWithBody.swift | 10 +- Tests/SwiftParserTest/StatementTests.swift | 4 +- .../MigrateToNewIfLetSyntax.swift | 99 ++++++++++--------- .../FunctionTests.swift | 2 +- .../SwiftSyntaxBuilderTest/IfStmtTests.swift | 30 +++--- 9 files changed, 133 insertions(+), 113 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 367f33d5fcd..2f9dbaba003 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -2587,6 +2587,51 @@ extension Parser.Lookahead { } } +// MARK: Conditional Expressions + +extension Parser { + /// Parse an if statement. + /// + /// Grammar + /// ======= + /// + /// if-expression → 'if' condition-list code-block else-clause? + /// else-clause → 'else' code-block | else if-statement + @_spi(RawSyntax) + public mutating func parseIfExpression( + ifHandle: RecoveryConsumptionHandle + ) -> RawIfExprSyntax { + let (unexpectedBeforeIfKeyword, ifKeyword) = self.eat(ifHandle) + // A scope encloses the condition and true branch for any variables bound + // by a conditional binding. The else branch does *not* see these variables. + let conditions = self.parseConditionList() + let body = self.parseCodeBlock(introducer: ifKeyword) + + // The else branch, if any, is outside of the scope of the condition. + let elseKeyword = self.consume(if: .keyword(.else)) + let elseBody: RawIfExprSyntax.ElseBody? + if elseKeyword != nil { + if self.at(.keyword(.if)) { + elseBody = .ifExpr(self.parseIfExpression(ifHandle: .constant(.keyword(.if)))) + } else { + elseBody = .codeBlock(self.parseCodeBlock(introducer: ifKeyword)) + } + } else { + elseBody = nil + } + + return RawIfExprSyntax( + unexpectedBeforeIfKeyword, + ifKeyword: ifKeyword, + conditions: conditions, + body: body, + elseKeyword: elseKeyword, + elseBody: elseBody, + arena: self.arena + ) + } +} + // MARK: Lookahead extension Parser.Lookahead { diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index acfc1204873..fabf8b1c9f0 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -97,7 +97,12 @@ extension Parser { return label(self.parseRepeatWhileStatement(repeatHandle: handle), with: optLabel) case (.ifKeyword, let handle)?: - return label(self.parseIfStatement(ifHandle: handle), with: optLabel) + let ifExpr = self.parseIfExpression(ifHandle: handle) + let ifStmt = RawExpressionStmtSyntax( + expression: RawExprSyntax(ifExpr), + arena: self.arena + ) + return label(ifStmt, with: optLabel) case (.guardKeyword, let handle)?: return label(self.parseGuardStatement(guardHandle: handle), with: optLabel) case (.switchKeyword, let handle)?: @@ -129,47 +134,6 @@ extension Parser { // MARK: Conditional Statements -extension Parser { - /// Parse an if statement. - /// - /// Grammar - /// ======= - /// - /// if-statement → 'if' condition-list code-block else-clause? - /// else-clause → 'else' code-block | else if-statement - @_spi(RawSyntax) - public mutating func parseIfStatement(ifHandle: RecoveryConsumptionHandle) -> RawIfStmtSyntax { - let (unexpectedBeforeIfKeyword, ifKeyword) = self.eat(ifHandle) - // A scope encloses the condition and true branch for any variables bound - // by a conditional binding. The else branch does *not* see these variables. - let conditions = self.parseConditionList() - let body = self.parseCodeBlock(introducer: ifKeyword) - - // The else branch, if any, is outside of the scope of the condition. - let elseKeyword = self.consume(if: .keyword(.else)) - let elseBody: RawIfStmtSyntax.ElseBody? - if elseKeyword != nil { - if self.at(.keyword(.if)) { - elseBody = .ifStmt(self.parseIfStatement(ifHandle: .constant(.keyword(.if)))) - } else { - elseBody = .codeBlock(self.parseCodeBlock(introducer: ifKeyword)) - } - } else { - elseBody = nil - } - - return RawIfStmtSyntax( - unexpectedBeforeIfKeyword, - ifKeyword: ifKeyword, - conditions: conditions, - body: body, - elseKeyword: elseKeyword, - elseBody: elseBody, - arena: self.arena - ) - } -} - extension Parser { /// Parse a guard statement. /// diff --git a/Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift b/Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift index a6b7bd25534..f3afce8fe56 100644 --- a/Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift +++ b/Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift @@ -13,7 +13,7 @@ import SwiftSyntax import SwiftParser -/// ``MigrateToNewIfLetSyntax`` will visit each if statement in the Syntax tree, and +/// ``MigrateToNewIfLetSyntax`` will visit each if expression in the Syntax tree, and /// checks if the there is an if condition which is of the pre Swift 5.7 "if-let-style" /// and rewrites it to the new one. /// @@ -34,7 +34,7 @@ import SwiftParser /// // ... /// } public struct MigrateToNewIfLetSyntax: RefactoringProvider { - public static func refactor(syntax node: IfStmtSyntax, in context: ()) -> StmtSyntax? { + public static func refactor(syntax node: IfExprSyntax, in context: ()) -> IfExprSyntax? { // Visit all conditions in the node. let newConditions = node.conditions.enumerated().map { (index, condition) -> ConditionElementListSyntax.Element in var conditionCopy = condition @@ -57,6 +57,6 @@ public struct MigrateToNewIfLetSyntax: RefactoringProvider { } return conditionCopy } - return StmtSyntax(node.withConditions(ConditionElementListSyntax(newConditions))) + return node.withConditions(ConditionElementListSyntax(newConditions)) } } diff --git a/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift b/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift index f2d166a75be..eb4ca0adc7e 100644 --- a/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift +++ b/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift @@ -188,7 +188,7 @@ extension FunctionParameter { // MARK: - IfStmt -extension IfStmt { +extension IfExpr { /// A convenience initializer that uses builder closures to express an /// if body, potentially with a second trailing builder closure for an else /// body. diff --git a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift index 0ca1550e22b..f25da399426 100644 --- a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift +++ b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift @@ -88,11 +88,11 @@ extension ExtensionDecl: HasTrailingMemberDeclBlock {} extension ProtocolDecl: HasTrailingMemberDeclBlock {} extension StructDecl: HasTrailingMemberDeclBlock {} -// MARK: - IfStmt -// IfStmtSyntax is a special scenario as we also have the `else` body or an if-else +// MARK: - IfExpr +// IfExprSyntax is a special scenario as we also have the `else` body or an if-else // So we cannot conform to `HasTrailingCodeBlock` -public extension IfStmt { +public extension IfExpr { init(_ signature: String, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemList, @CodeBlockItemListBuilder `else` elseBuilder: () -> CodeBlockItemList? = { nil }) { self = "\(raw: signature) {}" self.body = CodeBlock(statements: bodyBuilder()) @@ -100,10 +100,10 @@ public extension IfStmt { self.elseKeyword = elseBody != nil ? .keyword(.else) : nil } - init(_ signature: String, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemList, elseIf: IfStmt) { + init(_ signature: String, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemList, elseIf: IfExpr) { self = "\(raw: signature) {}" self.body = CodeBlock(statements: bodyBuilder()) - self.elseBody = .ifStmt(elseIf) + self.elseBody = .ifExpr(elseIf) self.elseKeyword = elseBody != nil ? .keyword(.else) : nil } } diff --git a/Tests/SwiftParserTest/StatementTests.swift b/Tests/SwiftParserTest/StatementTests.swift index bf2fcad7fb1..26ee1970a8c 100644 --- a/Tests/SwiftParserTest/StatementTests.swift +++ b/Tests/SwiftParserTest/StatementTests.swift @@ -21,7 +21,7 @@ final class StatementTests: XCTestCase { if let baz {} """, substructure: Syntax( - IfStmtSyntax( + IfExprSyntax( ifKeyword: .keyword(.if), conditions: ConditionElementListSyntax([ ConditionElementSyntax( @@ -47,7 +47,7 @@ final class StatementTests: XCTestCase { if let self = self {} """, substructure: Syntax( - IfStmtSyntax( + IfExprSyntax( ifKeyword: .keyword(.if), conditions: ConditionElementListSyntax([ ConditionElementSyntax( diff --git a/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift b/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift index 6f4a3df4e9a..5d381d764b6 100644 --- a/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift +++ b/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift @@ -17,102 +17,113 @@ import SwiftSyntaxBuilder import XCTest import _SwiftSyntaxTestSupport +@discardableResult +func testRefactorIfLet( + _ syntax: ExprSyntax, + expected: ExprSyntax, + file: StaticString = #file, + line: UInt = #line +) throws -> ExprSyntax { + let ifExpr = try XCTUnwrap( + syntax.as(IfExprSyntax.self), + file: file, + line: line + ) + + let refactored = try XCTUnwrap( + MigrateToNewIfLetSyntax.refactor(syntax: ifExpr), + file: file, + line: line + ) + + AssertStringsEqualWithDiff(expected.description, refactored.description) + return ExprSyntax(refactored) +} + final class MigrateToNewIfLetSyntaxTest: XCTestCase { func testRefactoring() throws { - let baselineSyntax: StmtSyntax = """ + let baselineSyntax: ExprSyntax = """ if let x = x {} """ - let expectedSyntax: StmtSyntax = """ + let expectedSyntax: ExprSyntax = """ if let x {} """ - let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self)) - let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self)) - - let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline)) - - AssertStringsEqualWithDiff(expected.description, refactored.description) + try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testIdempotence() throws { - let baselineSyntax: StmtSyntax = """ + let baselineSyntax: ExprSyntax = """ if let x = x {} """ - let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self)) - - let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline)) - let refactoredAgain = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline)) + let expectedSyntax: ExprSyntax = """ + if let x {} + """ - AssertStringsEqualWithDiff(refactored.description, refactoredAgain.description) + let refactored = try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try testRefactorIfLet(refactored, expected: expectedSyntax) } func testMultiBinding() throws { - let baselineSyntax: StmtSyntax = """ + let baselineSyntax: ExprSyntax = """ if let x = x, var y = y, let z = z {} """ - let expectedSyntax: StmtSyntax = """ + let expectedSyntax: ExprSyntax = """ if let x, var y, let z {} """ - let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self)) - let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self)) - - let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline)) - - AssertStringsEqualWithDiff(expected.description, refactored.description) + try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testMixedBinding() throws { - let baselineSyntax: StmtSyntax = """ + let baselineSyntax: ExprSyntax = """ if let x = x, var y = x, let z = y.w {} """ - let expectedSyntax: StmtSyntax = """ + let expectedSyntax: ExprSyntax = """ if let x, var y = x, let z = y.w {} """ - let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self)) - let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self)) - - let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline)) - - AssertStringsEqualWithDiff(expected.description, refactored.description) + try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testConditions() throws { - let baselineSyntax: StmtSyntax = """ + let baselineSyntax: ExprSyntax = """ if let x = x + 1, x == x, !x {} """ - let expectedSyntax: StmtSyntax = """ + let expectedSyntax: ExprSyntax = """ if let x = x + 1, x == x, !x {} """ - let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self)) - let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self)) - - let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline)) - - AssertStringsEqualWithDiff(expected.description, refactored.description) + try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testWhitespaceNormalization() throws { - let baselineSyntax: StmtSyntax = """ + let baselineSyntax: ExprSyntax = """ if let x = x , let y = y {} """ - let expectedSyntax: StmtSyntax = """ + let expectedSyntax: ExprSyntax = """ if let x, let y {} """ - let baseline = try XCTUnwrap(baselineSyntax.as(IfStmtSyntax.self)) - let expected = try XCTUnwrap(expectedSyntax.as(IfStmtSyntax.self)) + try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) + } - let refactored = try XCTUnwrap(MigrateToNewIfLetSyntax.refactor(syntax: baseline)) + func testIfStmt() throws { + let baselineSyntax: StmtSyntax = """ + if let x = x {} + """ + + let expectedSyntax: ExprSyntax = """ + if let x {} + """ - AssertStringsEqualWithDiff(expected.description, refactored.description) + let exprStmt = try XCTUnwrap(baselineSyntax.as(ExpressionStmtSyntax.self)) + try testRefactorIfLet(exprStmt.expression, expected: expectedSyntax) } } diff --git a/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift b/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift index 9442df88055..9de7b7a7da5 100644 --- a/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift @@ -19,7 +19,7 @@ import _SwiftSyntaxTestSupport final class FunctionTests: XCTestCase { func testFibonacci() { let buildable = FunctionDecl("func fibonacci(_ n: Int) -> Int") { - IfStmt("if n <= 1 { return n }") + IfExpr("if n <= 1 { return n }") ReturnStmt("return fibonacci(n - 1) + self.fibonacci(n - 2)") } diff --git a/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift b/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift index d6eed3085dc..25874df2f29 100644 --- a/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift @@ -15,11 +15,11 @@ import SwiftSyntax import SwiftSyntaxBuilder final class IfStmtTests: XCTestCase { - func testEmptyIfStmt() { + func testEmptyIfExpr() { // Use the convenience initializer from IfStmtConvenienceInitializers. This is // disambiguated by the absence of a labelName parameter and the use of a // trailing closure. - let buildable = IfStmt(conditions: ConditionElementList { BooleanLiteralExpr(false) }) {} + let buildable = IfExpr(conditions: ConditionElementList { BooleanLiteralExpr(false) }) {} AssertBuildResult( buildable, """ @@ -30,9 +30,9 @@ final class IfStmtTests: XCTestCase { } func testIfStmtyntax() { - let testCases: [UInt: (IfStmt, String)] = [ + let testCases: [UInt: (IfExpr, String)] = [ #line: ( - IfStmt( + IfExpr( """ if foo == x { return foo @@ -46,7 +46,7 @@ final class IfStmtTests: XCTestCase { """ ), #line: ( - IfStmt("if foo == x") { ReturnStmt("return foo") }, + IfExpr("if foo == x") { ReturnStmt("return foo") }, """ if foo == x { return foo @@ -54,7 +54,7 @@ final class IfStmtTests: XCTestCase { """ ), #line: ( - IfStmt("if foo == x") { + IfExpr("if foo == x") { ReturnStmt("return foo") } else: { ReturnStmt("return bar") @@ -68,7 +68,7 @@ final class IfStmtTests: XCTestCase { """ ), #line: ( - IfStmt("if foo == x", bodyBuilder: { ReturnStmt("return foo") }, elseIf: IfStmtSyntax("if foo == z") { ReturnStmt("return baz") }), + IfExpr("if foo == x", bodyBuilder: { ReturnStmt("return foo") }, elseIf: IfExpr("if foo == z") { ReturnStmt("return baz") }), """ if foo == x { return foo @@ -86,16 +86,16 @@ final class IfStmtTests: XCTestCase { } func testIfStmtSpacing() { - let testCases: [UInt: (IfStmt, String)] = [ + let testCases: [UInt: (IfExpr, String)] = [ #line: ( - IfStmt(conditions: ConditionElementList { Expr("!(true)") }) {}, + IfExpr(conditions: ConditionElementList { Expr("!(true)") }) {}, """ if !(true) { } """ ), #line: ( - IfStmt( + IfExpr( """ if !(false) { } @@ -114,10 +114,10 @@ final class IfStmtTests: XCTestCase { } } - func testIfElseStmt() { + func testIfElseExpr() { // Use the convenience initializer from IfStmtConvenienceInitializers // with an else branch expressed by a second trailing closure. - let buildable = IfStmt(conditions: ConditionElementList { BooleanLiteralExpr(true) }) { + let buildable = IfExpr(conditions: ConditionElementList { BooleanLiteralExpr(true) }) { FunctionCallExpr(callee: ExprSyntax("print")) { TupleExprElement(expression: StringLiteralExpr(content: "Hello from the if-branch!")) } @@ -138,8 +138,8 @@ final class IfStmtTests: XCTestCase { ) } - func testIfLetStmt() { - let buildable = IfStmt( + func testIfLetExpr() { + let buildable = IfExpr( conditions: ConditionElementList { OptionalBindingCondition( letOrVarKeyword: .let, @@ -158,7 +158,7 @@ final class IfStmtTests: XCTestCase { } func testIfCaseStmt() { - let buildable = IfStmt( + let buildable = IfExpr( conditions: ConditionElementList { MatchingPatternCondition( pattern: ExpressionPattern(expression: MemberAccessExpr(name: "x")), From 5f8331fda7e37b6d75e29763fb42ea710858e9cb Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Fri, 13 Jan 2023 10:26:59 +0000 Subject: [PATCH 4/7] Introduce SwitchExprSyntax This replaces SwitchStmtSyntax, and will be wrapped in an ExpressionStmtSyntax when used as a statement. --- gyb_syntax_support/ExprNodes.py | 64 +++++++++++++++++++++++++++++++++ gyb_syntax_support/StmtNodes.py | 64 --------------------------------- 2 files changed, 64 insertions(+), 64 deletions(-) diff --git a/gyb_syntax_support/ExprNodes.py b/gyb_syntax_support/ExprNodes.py index f58d25bd44e..7d0529243f4 100644 --- a/gyb_syntax_support/ExprNodes.py +++ b/gyb_syntax_support/ExprNodes.py @@ -300,6 +300,70 @@ is_optional=True), ]), + # switch-expr -> identifier? ':'? 'switch' expr '{' + # switch-case-list '}' ';'? + Node('SwitchExpr', name_for_diagnostics="'switch' statement", kind='Expr', + traits=['Braced'], + children=[ + Child('SwitchKeyword', kind='KeywordToken', text_choices=['switch']), + Child('Expression', kind='Expr'), + Child('LeftBrace', kind='LeftBraceToken'), + Child('Cases', kind='SwitchCaseList', + collection_element_name='Case'), + Child('RightBrace', kind='RightBraceToken', + requires_leading_newline=True), + ]), + + # switch-case-list -> switch-case switch-case-list? + Node('SwitchCaseList', name_for_diagnostics=None, kind='SyntaxCollection', + element='Syntax', element_name='SwitchCase', + element_choices=['SwitchCase', 'IfConfigDecl'], + elements_separated_by_newline=True), + + # switch-case -> unknown-attr? switch-case-label stmt-list + # | unknown-attr? switch-default-label stmt-list + Node('SwitchCase', name_for_diagnostics='switch case', kind='Syntax', + traits=['WithStatements'], + parser_function='parseSwitchCase', + children=[ + Child('UnknownAttr', kind='Attribute', is_optional=True), + Child('Label', kind='Syntax', name_for_diagnostics='label', + node_choices=[ + Child('Default', kind='SwitchDefaultLabel'), + Child('Case', kind='SwitchCaseLabel'), + ]), + Child('Statements', kind='CodeBlockItemList', + collection_element_name='Statement', + is_indented=True), + ]), + + # switch-case-label -> 'case' case-item-list ':' + Node('SwitchCaseLabel', name_for_diagnostics=None, kind='Syntax', + children=[ + Child('CaseKeyword', kind='KeywordToken', text_choices=['case']), + Child('CaseItems', kind='CaseItemList', + collection_element_name='CaseItem'), + Child('Colon', kind='ColonToken'), + ]), + + # switch-default-label -> 'default' ':' + Node('SwitchDefaultLabel', name_for_diagnostics=None, kind='Syntax', + children=[ + Child('DefaultKeyword', kind='KeywordToken', text_choices=['default']), + Child('Colon', kind='ColonToken'), + ]), + + # case-item -> pattern where-clause? ','? + Node('CaseItem', name_for_diagnostics=None, kind='Syntax', + traits=['WithTrailingComma'], + children=[ + Child('Pattern', kind='Pattern'), + Child('WhereClause', kind='WhereClause', + is_optional=True), + Child('TrailingComma', kind='CommaToken', + is_optional=True), + ]), + # ? expr : # Ternary expression without the condition and the second choice. # NOTE: This appears only in SequenceExpr. diff --git a/gyb_syntax_support/StmtNodes.py b/gyb_syntax_support/StmtNodes.py index 8aec3ceb3e1..758f52ef4b7 100644 --- a/gyb_syntax_support/StmtNodes.py +++ b/gyb_syntax_support/StmtNodes.py @@ -42,12 +42,6 @@ Child('Body', kind='CodeBlock'), ]), - # switch-case-list -> switch-case switch-case-list? - Node('SwitchCaseList', name_for_diagnostics=None, kind='SyntaxCollection', - element='Syntax', element_name='SwitchCase', - element_choices=['SwitchCase', 'IfConfigDecl'], - elements_separated_by_newline=True), - # repeat-while-stmt -> label? ':'? 'repeat' code-block 'while' expr ';'? Node('RepeatWhileStmt', name_for_diagnostics="'repeat' statement", kind='Stmt', traits=['WithCodeBlock'], @@ -99,20 +93,6 @@ Child('Body', kind='CodeBlock', name_for_diagnostics='body'), ]), - # switch-stmt -> identifier? ':'? 'switch' expr '{' - # switch-case-list '}' ';'? - Node('SwitchStmt', name_for_diagnostics="'switch' statement", kind='Stmt', - traits=['Braced'], - children=[ - Child('SwitchKeyword', kind='KeywordToken', text_choices=['switch']), - Child('Expression', kind='Expr'), - Child('LeftBrace', kind='LeftBraceToken'), - Child('Cases', kind='SwitchCaseList', - collection_element_name='Case'), - Child('RightBrace', kind='RightBraceToken', - requires_leading_newline=True), - ]), - # catch-clause-list -> catch-clause catch-clause-list? Node('CatchClauseList', name_for_diagnostics="'catch' clause", kind='SyntaxCollection', element='CatchClause'), @@ -250,41 +230,6 @@ Child('Expression', kind='Expr'), ]), - # switch-case -> unknown-attr? switch-case-label stmt-list - # | unknown-attr? switch-default-label stmt-list - Node('SwitchCase', name_for_diagnostics='switch case', kind='Syntax', - traits=['WithStatements'], - parser_function='parseSwitchCase', - children=[ - Child('UnknownAttr', kind='Attribute', is_optional=True), - Child('Label', kind='Syntax', name_for_diagnostics='label', - node_choices=[ - Child('Default', kind='SwitchDefaultLabel'), - Child('Case', kind='SwitchCaseLabel'), - ]), - Child('Statements', kind='CodeBlockItemList', - collection_element_name='Statement', - is_indented=True), - ]), - - # switch-default-label -> 'default' ':' - Node('SwitchDefaultLabel', name_for_diagnostics=None, kind='Syntax', - children=[ - Child('DefaultKeyword', kind='KeywordToken', text_choices=['default']), - Child('Colon', kind='ColonToken'), - ]), - - # case-item -> pattern where-clause? ','? - Node('CaseItem', name_for_diagnostics=None, kind='Syntax', - traits=['WithTrailingComma'], - children=[ - Child('Pattern', kind='Pattern'), - Child('WhereClause', kind='WhereClause', - is_optional=True), - Child('TrailingComma', kind='CommaToken', - is_optional=True), - ]), - # catch-item -> pattern? where-clause? ','? Node('CatchItem', name_for_diagnostics=None, kind='Syntax', traits=['WithTrailingComma'], @@ -296,15 +241,6 @@ is_optional=True), ]), - # switch-case-label -> 'case' case-item-list ':' - Node('SwitchCaseLabel', name_for_diagnostics=None, kind='Syntax', - children=[ - Child('CaseKeyword', kind='KeywordToken', text_choices=['case']), - Child('CaseItems', kind='CaseItemList', - collection_element_name='CaseItem'), - Child('Colon', kind='ColonToken'), - ]), - # catch-clause 'catch' case-item-list? code-block Node('CatchClause', name_for_diagnostics="'catch' clause", kind='Syntax', traits=['WithCodeBlock'], From 617d2b87095be0cc8eba12699bdd947f6ad57015 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Fri, 13 Jan 2023 10:26:59 +0000 Subject: [PATCH 5/7] Parse SwitchExprSyntax Update the parser to support parsing SwitchExprSyntax. For now, this only updates the existing statement parsing, and does not attempt to parse in expression position. --- Sources/SwiftParser/Expressions.swift | 282 +++++++++++++++++ Sources/SwiftParser/Statements.swift | 287 +----------------- .../SwiftSyntaxBuilderTest/SwitchTests.swift | 2 +- 3 files changed, 289 insertions(+), 282 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 2f9dbaba003..4f1edcaa638 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -2632,6 +2632,288 @@ extension Parser { } } +// MARK: Switch Expressions + +extension Parser { + /// Parse a switch expression. + /// + /// Grammar + /// ======= + /// + /// switch-expression → 'switch' expression '{' switch-cases? '}' + /// switch-cases → switch-case switch-cases? + @_spi(RawSyntax) + public mutating func parseSwitchExpression( + switchHandle: RecoveryConsumptionHandle + ) -> RawSwitchExprSyntax { + let (unexpectedBeforeSwitchKeyword, switchKeyword) = self.eat(switchHandle) + + let subject = self.parseExpression(.basic) + let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace) + + let cases = self.parseSwitchCases(allowStandaloneStmtRecovery: !lbrace.isMissing) + + let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: switchKeyword) + return RawSwitchExprSyntax( + unexpectedBeforeSwitchKeyword, + switchKeyword: switchKeyword, + expression: subject, + unexpectedBeforeLBrace, + leftBrace: lbrace, + cases: cases, + unexpectedBeforeRBrace, + rightBrace: rbrace, + arena: self.arena + ) + } + + /// Parse a list of switch case clauses. + /// + /// Grammar + /// ======= + /// + /// switch-cases → switch-case switch-cases? + /// + /// If `allowStandaloneStmtRecovery` is `true` and we discover a statement that + /// isn't covered by a case, we assume that the developer forgot to wrote the + /// `case` and synthesize it. If `allowStandaloneStmtOrDeclRecovery` is `false`, + /// this recovery is disabled. + @_spi(RawSyntax) + public mutating func parseSwitchCases(allowStandaloneStmtRecovery: Bool) -> RawSwitchCaseListSyntax { + var elements = [RawSwitchCaseListSyntax.Element]() + var elementsProgress = LoopProgressCondition() + while !self.at(any: [.eof, .rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword]) + && elementsProgress.evaluate(currentToken) + { + if self.lookahead().isAtStartOfSwitchCase(allowRecovery: false) { + elements.append(.switchCase(self.parseSwitchCase())) + } else if self.canRecoverTo(.poundIfKeyword) != nil { + // '#if' in 'case' position can enclose zero or more 'case' or 'default' + // clauses. + elements.append( + .ifConfigDecl( + self.parsePoundIfDirective( + { $0.parseSwitchCases(allowStandaloneStmtRecovery: allowStandaloneStmtRecovery) }, + syntax: { parser, cases in + guard cases.count == 1, let firstCase = cases.first else { + assert(cases.isEmpty) + return .switchCases(RawSwitchCaseListSyntax(elements: [], arena: parser.arena)) + } + return .switchCases(firstCase) + } + ) + ) + ) + } else if allowStandaloneStmtRecovery && (self.atStartOfExpression() || self.atStartOfStatement() || self.atStartOfDeclaration()) { + // Synthesize a label for the stamenent or declaration that isn't coverd by a case right now. + let statements = parseSwitchCaseBody() + elements.append( + .switchCase( + RawSwitchCaseSyntax( + unknownAttr: nil, + label: .case( + RawSwitchCaseLabelSyntax( + caseKeyword: missingToken(.keyword(.case), text: nil), + caseItems: RawCaseItemListSyntax( + elements: [ + RawCaseItemSyntax( + pattern: RawPatternSyntax( + RawIdentifierPatternSyntax( + identifier: missingToken(.identifier, text: nil), + arena: self.arena + ) + ), + whereClause: nil, + trailingComma: nil, + arena: self.arena + ) + ], + arena: self.arena + ), + colon: missingToken(.colon, text: nil), + arena: self.arena + ) + ), + statements: statements, + arena: self.arena + ) + ) + ) + } else if self.lookahead().isAtStartOfSwitchCase(allowRecovery: true) { + elements.append(.switchCase(self.parseSwitchCase())) + } else { + break + } + } + return RawSwitchCaseListSyntax(elements: elements, arena: self.arena) + } + + mutating func parseSwitchCaseBody() -> RawCodeBlockItemListSyntax { + var items = [RawCodeBlockItemSyntax]() + var loopProgress = LoopProgressCondition() + while !self.at(any: [.rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword]) + && !self.lookahead().isStartOfConditionalSwitchCases(), + let newItem = self.parseCodeBlockItem(), + loopProgress.evaluate(currentToken) + { + items.append(newItem) + } + return RawCodeBlockItemListSyntax(elements: items, arena: self.arena) + } + + /// Parse a single switch case clause. + /// + /// Grammar + /// ======= + /// + /// switch-case → case-label statements + /// switch-case → default-label statements + /// switch-case → conditional-switch-case + @_spi(RawSyntax) + public mutating func parseSwitchCase() -> RawSwitchCaseSyntax { + var unknownAttr: RawAttributeSyntax? + if let at = self.consume(if: .atSign) { + let (unexpectedBeforeIdent, ident) = self.expectIdentifier() + + unknownAttr = RawAttributeSyntax( + atSignToken: at, + unexpectedBeforeIdent, + attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: ident, genericArgumentClause: nil, arena: self.arena)), + leftParen: nil, + argument: nil, + rightParen: nil, + arena: self.arena + ) + } else { + unknownAttr = nil + } + + let label: RawSwitchCaseSyntax.Label + switch self.canRecoverTo(anyIn: SwitchCaseStart.self) { + case (.caseKeyword, let handle)?: + label = .case(self.parseSwitchCaseLabel(handle)) + case (.defaultKeyword, let handle)?: + label = .default(self.parseSwitchDefaultLabel(handle)) + case nil: + label = .case( + RawSwitchCaseLabelSyntax( + caseKeyword: missingToken(.keyword(.case)), + caseItems: RawCaseItemListSyntax( + elements: [ + RawCaseItemSyntax( + pattern: RawPatternSyntax(RawIdentifierPatternSyntax(identifier: missingToken(.identifier), arena: self.arena)), + whereClause: nil, + trailingComma: nil, + arena: self.arena + ) + ], + arena: self.arena + ), + colon: missingToken(.colon), + arena: self.arena + ) + ) + } + + // Parse the body. + let statements = parseSwitchCaseBody() + + return RawSwitchCaseSyntax( + unknownAttr: unknownAttr, + label: label, + statements: statements, + arena: self.arena + ) + } + + /// Parse a switch case with a 'case' label. + /// + /// Grammar + /// ======= + /// + /// case-label → attributes? case case-item-list ':' + /// case-item-list → pattern where-clause? | pattern where-clause? ',' case-item-list + @_spi(RawSyntax) + public mutating func parseSwitchCaseLabel( + _ handle: RecoveryConsumptionHandle + ) -> RawSwitchCaseLabelSyntax { + let (unexpectedBeforeCaseKeyword, caseKeyword) = self.eat(handle) + var caseItems = [RawCaseItemSyntax]() + do { + var keepGoing: RawTokenSyntax? = nil + var loopProgress = LoopProgressCondition() + repeat { + let (pattern, whereClause) = self.parseGuardedCasePattern() + keepGoing = self.consume(if: .comma) + caseItems.append( + RawCaseItemSyntax( + pattern: pattern, + whereClause: whereClause, + trailingComma: keepGoing, + arena: self.arena + ) + ) + } while keepGoing != nil && loopProgress.evaluate(currentToken) + } + let (unexpectedBeforeColon, colon) = self.expect(.colon) + return RawSwitchCaseLabelSyntax( + unexpectedBeforeCaseKeyword, + caseKeyword: caseKeyword, + caseItems: RawCaseItemListSyntax(elements: caseItems, arena: self.arena), + unexpectedBeforeColon, + colon: colon, + arena: self.arena + ) + } + + /// Parse a switch case with a 'default' label. + /// + /// Grammar + /// ======= + /// + /// default-label → attributes? 'default' ':' + @_spi(RawSyntax) + public mutating func parseSwitchDefaultLabel( + _ handle: RecoveryConsumptionHandle + ) -> RawSwitchDefaultLabelSyntax { + let (unexpectedBeforeDefaultKeyword, defaultKeyword) = self.eat(handle) + let (unexpectedBeforeColon, colon) = self.expect(.colon) + return RawSwitchDefaultLabelSyntax( + unexpectedBeforeDefaultKeyword, + defaultKeyword: defaultKeyword, + unexpectedBeforeColon, + colon: colon, + arena: self.arena + ) + } + + /// Parse a pattern-matching clause for a case statement, + /// including the guard expression. + /// + /// Grammar + /// ======= + /// + /// case-item → pattern where-clause? + mutating func parseGuardedCasePattern() -> (RawPatternSyntax, RawWhereClauseSyntax?) { + let pattern = self.parseMatchingPattern(context: .matching) + + // Parse the optional 'where' guard, with this particular pattern's bound + // vars in scope. + let whereClause: RawWhereClauseSyntax? + if let whereKeyword = self.consume(if: .keyword(.where)) { + let guardExpr = self.parseExpression(.trailingClosure) + whereClause = RawWhereClauseSyntax( + whereKeyword: whereKeyword, + guardResult: guardExpr, + arena: self.arena + ) + } else { + whereClause = nil + } + return (pattern, whereClause) + } +} + // MARK: Lookahead extension Parser.Lookahead { diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index fabf8b1c9f0..bdadb199bdb 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -106,7 +106,12 @@ extension Parser { case (.guardKeyword, let handle)?: return label(self.parseGuardStatement(guardHandle: handle), with: optLabel) case (.switchKeyword, let handle)?: - return label(self.parseSwitchStatement(switchHandle: handle), with: optLabel) + let switchExpr = self.parseSwitchExpression(switchHandle: handle) + let switchStmt = RawExpressionStmtSyntax( + expression: RawExprSyntax(switchExpr), + arena: self.arena + ) + return label(switchStmt, with: optLabel) case (.breakKeyword, let handle)?: return label(self.parseBreakStatement(breakHandle: handle), with: optLabel) case (.continueKeyword, let handle)?: @@ -646,286 +651,6 @@ extension Parser { } } -// MARK: Switch Statements - -extension Parser { - /// Parse a switch statement. - /// - /// Grammar - /// ======= - /// - /// switch-statement → 'switch' expression '{' switch-cases? '}' - /// switch-cases → switch-case switch-cases? - @_spi(RawSyntax) - public mutating func parseSwitchStatement(switchHandle: RecoveryConsumptionHandle) -> RawSwitchStmtSyntax { - let (unexpectedBeforeSwitchKeyword, switchKeyword) = self.eat(switchHandle) - - let subject = self.parseExpression(.basic) - let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace) - - let cases = self.parseSwitchCases(allowStandaloneStmtRecovery: !lbrace.isMissing) - - let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: switchKeyword) - return RawSwitchStmtSyntax( - unexpectedBeforeSwitchKeyword, - switchKeyword: switchKeyword, - expression: subject, - unexpectedBeforeLBrace, - leftBrace: lbrace, - cases: cases, - unexpectedBeforeRBrace, - rightBrace: rbrace, - arena: self.arena - ) - } - - /// Parse a list of switch case clauses. - /// - /// Grammar - /// ======= - /// - /// switch-cases → switch-case switch-cases? - /// - /// If `allowStandaloneStmtRecovery` is `true` and we discover a statement that - /// isn't covered by a case, we assume that the developer forgot to wrote the - /// `case` and synthesize it. If `allowStandaloneStmtOrDeclRecovery` is `false`, - /// this recovery is disabled. - @_spi(RawSyntax) - public mutating func parseSwitchCases(allowStandaloneStmtRecovery: Bool) -> RawSwitchCaseListSyntax { - var elements = [RawSwitchCaseListSyntax.Element]() - var elementsProgress = LoopProgressCondition() - while !self.at(any: [.eof, .rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword]) - && elementsProgress.evaluate(currentToken) - { - if self.lookahead().isAtStartOfSwitchCase(allowRecovery: false) { - elements.append(.switchCase(self.parseSwitchCase())) - } else if self.canRecoverTo(.poundIfKeyword) != nil { - // '#if' in 'case' position can enclose zero or more 'case' or 'default' - // clauses. - elements.append( - .ifConfigDecl( - self.parsePoundIfDirective( - { $0.parseSwitchCases(allowStandaloneStmtRecovery: allowStandaloneStmtRecovery) }, - syntax: { parser, cases in - guard cases.count == 1, let firstCase = cases.first else { - assert(cases.isEmpty) - return .switchCases(RawSwitchCaseListSyntax(elements: [], arena: parser.arena)) - } - return .switchCases(firstCase) - } - ) - ) - ) - } else if allowStandaloneStmtRecovery && (self.atStartOfExpression() || self.atStartOfStatement() || self.atStartOfDeclaration()) { - // Synthesize a label for the stamenent or declaration that isn't coverd by a case right now. - let statements = parseSwitchCaseBody() - elements.append( - .switchCase( - RawSwitchCaseSyntax( - unknownAttr: nil, - label: .case( - RawSwitchCaseLabelSyntax( - caseKeyword: missingToken(.keyword(.case), text: nil), - caseItems: RawCaseItemListSyntax( - elements: [ - RawCaseItemSyntax( - pattern: RawPatternSyntax( - RawIdentifierPatternSyntax( - identifier: missingToken(.identifier, text: nil), - arena: self.arena - ) - ), - whereClause: nil, - trailingComma: nil, - arena: self.arena - ) - ], - arena: self.arena - ), - colon: missingToken(.colon, text: nil), - arena: self.arena - ) - ), - statements: statements, - arena: self.arena - ) - ) - ) - } else if self.lookahead().isAtStartOfSwitchCase(allowRecovery: true) { - elements.append(.switchCase(self.parseSwitchCase())) - } else { - break - } - } - return RawSwitchCaseListSyntax(elements: elements, arena: self.arena) - } - - mutating func parseSwitchCaseBody() -> RawCodeBlockItemListSyntax { - var items = [RawCodeBlockItemSyntax]() - var loopProgress = LoopProgressCondition() - while !self.at(any: [.rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword]) - && !self.lookahead().isStartOfConditionalSwitchCases(), - let newItem = self.parseCodeBlockItem(), - loopProgress.evaluate(currentToken) - { - items.append(newItem) - } - return RawCodeBlockItemListSyntax(elements: items, arena: self.arena) - } - - /// Parse a single switch case clause. - /// - /// Grammar - /// ======= - /// - /// switch-case → case-label statements - /// switch-case → default-label statements - /// switch-case → conditional-switch-case - @_spi(RawSyntax) - public mutating func parseSwitchCase() -> RawSwitchCaseSyntax { - var unknownAttr: RawAttributeSyntax? - if let at = self.consume(if: .atSign) { - let (unexpectedBeforeIdent, ident) = self.expectIdentifier() - - unknownAttr = RawAttributeSyntax( - atSignToken: at, - unexpectedBeforeIdent, - attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: ident, genericArgumentClause: nil, arena: self.arena)), - leftParen: nil, - argument: nil, - rightParen: nil, - arena: self.arena - ) - } else { - unknownAttr = nil - } - - let label: RawSwitchCaseSyntax.Label - switch self.canRecoverTo(anyIn: SwitchCaseStart.self) { - case (.caseKeyword, let handle)?: - label = .case(self.parseSwitchCaseLabel(handle)) - case (.defaultKeyword, let handle)?: - label = .default(self.parseSwitchDefaultLabel(handle)) - case nil: - label = .case( - RawSwitchCaseLabelSyntax( - caseKeyword: missingToken(.keyword(.case)), - caseItems: RawCaseItemListSyntax( - elements: [ - RawCaseItemSyntax( - pattern: RawPatternSyntax(RawIdentifierPatternSyntax(identifier: missingToken(.identifier), arena: self.arena)), - whereClause: nil, - trailingComma: nil, - arena: self.arena - ) - ], - arena: self.arena - ), - colon: missingToken(.colon), - arena: self.arena - ) - ) - } - - // Parse the body. - let statements = parseSwitchCaseBody() - - return RawSwitchCaseSyntax( - unknownAttr: unknownAttr, - label: label, - statements: statements, - arena: self.arena - ) - } - - /// Parse a switch case with a 'case' label. - /// - /// Grammar - /// ======= - /// - /// case-label → attributes? case case-item-list ':' - /// case-item-list → pattern where-clause? | pattern where-clause? ',' case-item-list - @_spi(RawSyntax) - public mutating func parseSwitchCaseLabel( - _ handle: RecoveryConsumptionHandle - ) -> RawSwitchCaseLabelSyntax { - let (unexpectedBeforeCaseKeyword, caseKeyword) = self.eat(handle) - var caseItems = [RawCaseItemSyntax]() - do { - var keepGoing: RawTokenSyntax? = nil - var loopProgress = LoopProgressCondition() - repeat { - let (pattern, whereClause) = self.parseGuardedCasePattern() - keepGoing = self.consume(if: .comma) - caseItems.append( - RawCaseItemSyntax( - pattern: pattern, - whereClause: whereClause, - trailingComma: keepGoing, - arena: self.arena - ) - ) - } while keepGoing != nil && loopProgress.evaluate(currentToken) - } - let (unexpectedBeforeColon, colon) = self.expect(.colon) - return RawSwitchCaseLabelSyntax( - unexpectedBeforeCaseKeyword, - caseKeyword: caseKeyword, - caseItems: RawCaseItemListSyntax(elements: caseItems, arena: self.arena), - unexpectedBeforeColon, - colon: colon, - arena: self.arena - ) - } - - /// Parse a switch case with a 'default' label. - /// - /// Grammar - /// ======= - /// - /// default-label → attributes? 'default' ':' - @_spi(RawSyntax) - public mutating func parseSwitchDefaultLabel( - _ handle: RecoveryConsumptionHandle - ) -> RawSwitchDefaultLabelSyntax { - let (unexpectedBeforeDefaultKeyword, defaultKeyword) = self.eat(handle) - let (unexpectedBeforeColon, colon) = self.expect(.colon) - return RawSwitchDefaultLabelSyntax( - unexpectedBeforeDefaultKeyword, - defaultKeyword: defaultKeyword, - unexpectedBeforeColon, - colon: colon, - arena: self.arena - ) - } - - /// Parse a pattern-matching clause for a case statement, - /// including the guard expression. - /// - /// Grammar - /// ======= - /// - /// case-item → pattern where-clause? - mutating func parseGuardedCasePattern() -> (RawPatternSyntax, RawWhereClauseSyntax?) { - let pattern = self.parseMatchingPattern(context: .matching) - - // Parse the optional 'where' guard, with this particular pattern's bound - // vars in scope. - let whereClause: RawWhereClauseSyntax? - if let whereKeyword = self.consume(if: .keyword(.where)) { - let guardExpr = self.parseExpression(.trailingClosure) - whereClause = RawWhereClauseSyntax( - whereKeyword: whereKeyword, - guardResult: guardExpr, - arena: self.arena - ) - } else { - whereClause = nil - } - return (pattern, whereClause) - } -} - // MARK: Control Transfer Statements extension Parser { diff --git a/Tests/SwiftSyntaxBuilderTest/SwitchTests.swift b/Tests/SwiftSyntaxBuilderTest/SwitchTests.swift index 51773ab7572..1cf3791567b 100644 --- a/Tests/SwiftSyntaxBuilderTest/SwitchTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/SwitchTests.swift @@ -16,7 +16,7 @@ import SwiftSyntaxBuilder final class SwitchTests: XCTestCase { func testSwitch() { - let syntax = SwitchStmt(expression: Expr("count")) { + let syntax = SwitchExpr(expression: Expr("count")) { for num in 1..<3 { SwitchCase("case \(literal: num):") { Expr("print(count)") From 13e66ad0e448ad641975f680a3da73021622379f Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Fri, 13 Jan 2023 10:26:59 +0000 Subject: [PATCH 6/7] Parse IfExpr and SwitchExpr in expression position Start parsing if and switch expressions as unary expressions (as we don't allow postfix grammar for them). In addition, parse if/switch expressions in statement position if we see a `try`/`await`/`move`, or a trailing `as Type`. --- Sources/SwiftParser/Expressions.swift | 63 ++++++-- Sources/SwiftParser/RawTokenKindSubset.swift | 20 +++ Sources/SwiftParser/Statements.swift | 26 +++- Sources/SwiftParser/TopLevel.swift | 33 +++- Tests/SwiftParserTest/ExpressionTests.swift | 151 +++++++++++++++++++ 5 files changed, 271 insertions(+), 22 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 4f1edcaa638..cadf5c3c41e 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -18,6 +18,11 @@ extension TokenConsumer { case (.awaitTryMove, let handle)?: var backtrack = self.lookahead() backtrack.eat(handle) + + // These can be parsed as expressions with try/await. + if backtrack.at(anyIn: IfOrSwitch.self) != nil { + return true + } if backtrack.atStartOfDeclaration() || backtrack.atStartOfStatement() { // If after the 'try' we are at a declaration or statement, it can't be a valid expression. // Decide how we want to consume the 'try': @@ -202,6 +207,30 @@ extension Parser { ) } + /// Parse an unresolved 'as' expression. + /// + /// type-casting-operator → 'as' type + /// type-casting-operator → 'as' '?' type + /// type-casting-operator → 'as' '!' type + /// + mutating func parseUnresolvedAsExpr( + handle: TokenConsumptionHandle + ) -> (operator: RawExprSyntax, rhs: RawExprSyntax) { + let asKeyword = self.eat(handle) + let failable = self.consume(ifAny: [.postfixQuestionMark, .exclamationMark]) + let op = RawUnresolvedAsExprSyntax( + asTok: asKeyword, + questionOrExclamationMark: failable, + arena: self.arena + ) + + // Parse the right type expression operand as part of the 'as' production. + let type = self.parseType() + let rhs = RawTypeExprSyntax(type: type, arena: self.arena) + + return (RawExprSyntax(op), RawExprSyntax(rhs)) + } + /// Parse an expression sequence operators. /// /// Returns `nil` if the current token is not at an operator. @@ -324,19 +353,7 @@ extension Parser { return (RawExprSyntax(op), RawExprSyntax(rhs)) case (.asKeyword, let handle)?: - let asKeyword = self.eat(handle) - let failable = self.consume(ifAny: [.postfixQuestionMark, .exclamationMark]) - let op = RawUnresolvedAsExprSyntax( - asTok: asKeyword, - questionOrExclamationMark: failable, - arena: self.arena - ) - - // Parse the right type expression operand as part of the 'as' production. - let type = self.parseType() - let rhs = RawTypeExprSyntax(type: type, arena: self.arena) - - return (RawExprSyntax(op), RawExprSyntax(rhs)) + return parseUnresolvedAsExpr(handle: handle) case (.async, _)?: if self.peek().rawTokenKind == .arrow || self.peek().rawTokenKind == .keyword(.throws) { @@ -510,6 +527,21 @@ extension Parser { ) } + // Try parse an 'if' or 'switch' as an expression. Note we do this here in + // parseUnaryExpression as we don't allow postfix syntax to hang off such + // expressions to avoid ambiguities such as postfix '.member', which can + // currently be parsed as a static dot member for a result builder. + if self.at(.keyword(.switch)) { + return RawExprSyntax( + parseSwitchExpression(switchHandle: .constant(.keyword(.switch))) + ) + } + if self.at(.keyword(.if)) { + return RawExprSyntax( + parseIfExpression(ifHandle: .constant(.keyword(.if))) + ) + } + switch self.at(anyIn: ExpressionPrefixOperator.self) { case (.prefixAmpersand, let handle)?: let amp = self.eat(handle) @@ -2526,6 +2558,11 @@ extension Parser.Lookahead { return false } + // If this is the start of a switch body, this isn't a trailing closure. + if self.peek().rawTokenKind == .keyword(.case) { + return false; + } + // If this is a normal expression (not an expr-basic) then trailing closures // are allowed, so this is obviously one. // TODO: We could handle try to disambiguate cases like: diff --git a/Sources/SwiftParser/RawTokenKindSubset.swift b/Sources/SwiftParser/RawTokenKindSubset.swift index 6de03cae7d1..60212129825 100644 --- a/Sources/SwiftParser/RawTokenKindSubset.swift +++ b/Sources/SwiftParser/RawTokenKindSubset.swift @@ -612,6 +612,26 @@ enum AwaitTryMove: RawTokenKindSubset { } } +enum IfOrSwitch: RawTokenKindSubset { + case ifKeyword + case switchKeyword + + init?(lexeme: Lexer.Lexeme) { + switch lexeme { + case RawTokenKindMatch(.keyword(.if)): self = .ifKeyword + case RawTokenKindMatch(.keyword(.switch)): self = .switchKeyword + default: return nil + } + } + + var rawTokenKind: RawTokenKind { + switch self { + case .ifKeyword: return .keyword(.if) + case .switchKeyword: return .keyword(.switch) + } + } +} + enum ExpressionPrefixOperator: RawTokenKindSubset { case backslash case prefixAmpersand diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index bdadb199bdb..084a2d1459c 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -654,6 +654,24 @@ extension Parser { // MARK: Control Transfer Statements extension Parser { + private func isStartOfReturnExpr() -> Bool { + if self.at(any: [ + .rightBrace, .keyword(.case), .keyword(.default), .semicolon, .eof, + .poundIfKeyword, .poundErrorKeyword, .poundWarningKeyword, + .poundEndifKeyword, .poundElseKeyword, .poundElseifKeyword, + ]) { + return false + } + // Allowed for if/switch expressions. + if self.at(anyIn: IfOrSwitch.self) != nil { + return true + } + if self.atStartOfStatement() || self.atStartOfDeclaration() { + return false + } + return true + } + /// Parse a return statement /// /// Grammar @@ -669,13 +687,7 @@ extension Parser { // enclosing stmt-brace to get it by eagerly eating it unless the return is // followed by a '}', '', statement or decl start keyword sequence. let expr: RawExprSyntax? - if !self.at(any: [ - .rightBrace, .keyword(.case), .keyword(.default), .semicolon, .eof, - .poundIfKeyword, .poundErrorKeyword, .poundWarningKeyword, - .poundEndifKeyword, .poundElseKeyword, .poundElseifKeyword, - ]) - && !self.atStartOfStatement() && !self.atStartOfDeclaration() - { + if isStartOfReturnExpr() { let parsedExpr = self.parseExpression() if hasMisplacedTry && !parsedExpr.is(RawTryExprSyntax.self) { expr = RawExprSyntax( diff --git a/Sources/SwiftParser/TopLevel.swift b/Sources/SwiftParser/TopLevel.swift index d5ac99e9f17..cadca458446 100644 --- a/Sources/SwiftParser/TopLevel.swift +++ b/Sources/SwiftParser/TopLevel.swift @@ -194,6 +194,35 @@ extension Parser { ) } + private mutating func parseStatementItem() -> RawCodeBlockItemSyntax.Item { + let stmt = self.parseStatement() + + // Special case: An 'if' or 'switch' statement followed by an 'as' must + // be an if/switch expression in a coercion. + // We could also achieve this by more eagerly attempting to parse an 'if' + // or 'switch' as an expression when in statement position, but that + // could result in less useful recovery behavior. + if at(.keyword(.as)), let stmtExpr = stmt.as(RawExpressionStmtSyntax.self) { + let expr = stmtExpr.expression + if expr.is(RawIfExprSyntax.self) || expr.is(RawSwitchExprSyntax.self) { + let (op, rhs) = parseUnresolvedAsExpr( + handle: .init(tokenKind: .keyword(.as)) + ) + let sequence = RawExprSyntax( + RawSequenceExprSyntax( + elements: RawExprListSyntax( + elements: [expr, op, rhs], + arena: self.arena + ), + arena: self.arena + ) + ) + return .expr(sequence) + } + } + return .stmt(stmt) + } + /// `isAtTopLevel` determines whether this is trying to parse an item that's at /// the top level of the source file. If this is the case, we allow skipping /// closing braces while trying to recover to the next item. @@ -227,13 +256,13 @@ extension Parser { } else if self.atStartOfDeclaration(allowInitDecl: allowInitDecl) { return .decl(self.parseDeclaration()) } else if self.atStartOfStatement() { - return .stmt(self.parseStatement()) + return self.parseStatementItem() } else if self.atStartOfExpression() { return .expr(self.parseExpression()) } else if self.atStartOfDeclaration(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl, allowRecovery: true) { return .decl(self.parseDeclaration()) } else if self.atStartOfStatement(allowRecovery: true) { - return .stmt(self.parseStatement()) + return self.parseStatementItem() } else { return .expr(RawExprSyntax(RawMissingExprSyntax(arena: self.arena))) } diff --git a/Tests/SwiftParserTest/ExpressionTests.swift b/Tests/SwiftParserTest/ExpressionTests.swift index 72e02a22bf3..59fb5392188 100644 --- a/Tests/SwiftParserTest/ExpressionTests.swift +++ b/Tests/SwiftParserTest/ExpressionTests.swift @@ -874,3 +874,154 @@ final class MemberExprTests: XCTestCase { } } } + +final class StatementExpressionTests: XCTestCase { + func testIfExprInCoercion() { + AssertParse( + """ + func foo() { + if .random() { 0 } else { 1 } as Int + } + """ + ) + } + func testSwitchExprInCoercion() { + AssertParse( + """ + func foo() { + switch Bool.random() { case true: 0 case false: 1 } as Int + } + """ + ) + } + func testIfExprInReturn() { + AssertParse( + """ + func foo() { + return if .random() { 0 } else { 1 } + } + """ + ) + } + func testSwitchExprInReturn() { + AssertParse( + """ + func foo() { + return switch Bool.random() { case true: 0 case false: 1 } + } + """ + ) + } + func testTryIf1() { + AssertParse( + """ + func foo() -> Int { + try if .random() { 0 } else { 1 } + } + """ + ) + } + func testTryIf2() { + AssertParse( + """ + func foo() -> Int { + return try if .random() { 0 } else { 1 } + } + """ + ) + } + func testTryIf3() { + AssertParse( + """ + func foo() -> Int { + let x = try if .random() { 0 } else { 1 } + return x + } + """ + ) + } + func testAwaitIf1() { + AssertParse( + """ + func foo() async -> Int { + await if .random() { 0 } else { 1 } + } + """ + ) + } + func testAwaitIf2() { + AssertParse( + """ + func foo() async -> Int { + return await if .random() { 0 } else { 1 } + } + """ + ) + } + func testAwaitIf3() { + AssertParse( + """ + func foo() async -> Int { + let x = await if .random() { 0 } else { 1 } + return x + } + """ + ) + } + func testTrySwitch1() { + AssertParse( + """ + func foo() -> Int { + try switch Bool.random() { case true: 0 case false: 1 } + } + """ + ) + } + func testTrySwitch2() { + AssertParse( + """ + func foo() -> Int { + return try switch Bool.random() { case true: 0 case false: 1 } + } + """ + ) + } + func testTrySwitch3() { + AssertParse( + """ + func foo() -> Int { + let x = try switch Bool.random() { case true: 0 case false: 1 } + return x + } + """ + ) + } + func testAwaitSwitch1() { + AssertParse( + """ + func foo() async -> Int { + await switch Bool.random() { case true: 0 case false: 1 } + } + """ + ) + } + func testAwaitSwitch2() { + AssertParse( + """ + func foo() async -> Int { + return await switch Bool.random() { case true: 0 case false: 1 } + } + """ + ) + } + func testAwaitSwitch3() { + AssertParse( + """ + func foo() async -> Int { + let x = await switch Bool.random() { case true: 0 case false: 1 } + return x + } + """ + ) + } +} From 9095e45780cfcfbf3aca8e72c77409651b6f2080 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Fri, 13 Jan 2023 10:27:00 +0000 Subject: [PATCH 7/7] Generate gyb --- .../gyb_generated/ExprNodes.swift | 161 + .../gyb_generated/StmtNodes.swift | 169 +- .../generated/BasicFormat.swift | 2 +- .../gyb_generated/SwiftSyntax.md | 15 +- .../Raw/gyb_generated/RawSyntaxNodes.swift | 1566 +- .../gyb_generated/RawSyntaxValidation.swift | 166 +- Sources/SwiftSyntax/generated/Misc.swift | 21 +- .../generated/SyntaxAnyVisitor.swift | 16 +- .../generated/SyntaxBaseNodes.swift | 13 +- .../SwiftSyntax/generated/SyntaxEnum.swift | 16 +- .../SwiftSyntax/generated/SyntaxKind.swift | 6 +- .../SwiftSyntax/generated/SyntaxTraits.swift | 4 +- .../generated/SyntaxTransform.swift | 34 +- .../SwiftSyntax/generated/SyntaxVisitor.swift | 57 +- .../gyb_generated/SyntaxFactory.swift | 511 +- .../gyb_generated/SyntaxRewriter.swift | 311 +- .../syntax_nodes/SyntaxExprNodes.swift | 770 + .../syntax_nodes/SyntaxNodes.swift | 19914 ++++++++-------- .../syntax_nodes/SyntaxStmtNodes.swift | 2045 +- .../generated/BuildableNodes.swift | 4 +- ...bleByStringInterpolationConformances.swift | 7 +- .../generated/Typealiases.swift | 6 +- 22 files changed, 13063 insertions(+), 12751 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift index 1ad9dbaa0b3..ef7cc080b95 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift @@ -514,6 +514,167 @@ public let EXPR_NODES: [Node] = [ ]) ]), + Node(name: "IfExpr", + nameForDiagnostics: "'if' statement", + kind: "Expr", + traits: [ + "WithCodeBlock" + ], + children: [ + Child(name: "IfKeyword", + kind: "KeywordToken", + tokenChoices: [ + "Keyword" + ], + textChoices: [ + "if" + ]), + Child(name: "Conditions", + kind: "ConditionElementList", + collectionElementName: "Condition"), + Child(name: "Body", + kind: "CodeBlock"), + Child(name: "ElseKeyword", + kind: "ElseToken", + isOptional: true), + Child(name: "ElseBody", + kind: "Syntax", + isOptional: true, + nodeChoices: [ + Child(name: "IfExpr", + kind: "IfExpr"), + Child(name: "CodeBlock", + kind: "CodeBlock") + ]) + ]), + + Node(name: "SwitchExpr", + nameForDiagnostics: "'switch' statement", + kind: "Expr", + traits: [ + "Braced" + ], + children: [ + Child(name: "SwitchKeyword", + kind: "KeywordToken", + tokenChoices: [ + "Keyword" + ], + textChoices: [ + "switch" + ]), + Child(name: "Expression", + kind: "Expr"), + Child(name: "LeftBrace", + kind: "LeftBraceToken", + tokenChoices: [ + "LeftBrace" + ]), + Child(name: "Cases", + kind: "SwitchCaseList", + collectionElementName: "Case"), + Child(name: "RightBrace", + kind: "RightBraceToken", + tokenChoices: [ + "RightBrace" + ], + requiresLeadingNewline: true) + ]), + + Node(name: "SwitchCaseList", + nameForDiagnostics: nil, + kind: "SyntaxCollection", + element: "Syntax", + elementName: "SwitchCase", + elementChoices: ["SwitchCase", "IfConfigDecl"], + elementsSeparatedByNewline: true), + + Node(name: "SwitchCase", + nameForDiagnostics: "switch case", + kind: "Syntax", + traits: [ + "WithStatements" + ], + parserFunction: "parseSwitchCase", + children: [ + Child(name: "UnknownAttr", + kind: "Attribute", + isOptional: true), + Child(name: "Label", + kind: "Syntax", + nodeChoices: [ + Child(name: "Default", + kind: "SwitchDefaultLabel"), + Child(name: "Case", + kind: "SwitchCaseLabel") + ]), + Child(name: "Statements", + kind: "CodeBlockItemList", + collectionElementName: "Statement", + isIndented: true) + ]), + + Node(name: "SwitchCaseLabel", + nameForDiagnostics: nil, + kind: "Syntax", + children: [ + Child(name: "CaseKeyword", + kind: "KeywordToken", + tokenChoices: [ + "Keyword" + ], + textChoices: [ + "case" + ]), + Child(name: "CaseItems", + kind: "CaseItemList", + collectionElementName: "CaseItem"), + Child(name: "Colon", + kind: "ColonToken", + tokenChoices: [ + "Colon" + ]) + ]), + + Node(name: "SwitchDefaultLabel", + nameForDiagnostics: nil, + kind: "Syntax", + children: [ + Child(name: "DefaultKeyword", + kind: "KeywordToken", + tokenChoices: [ + "Keyword" + ], + textChoices: [ + "default" + ]), + Child(name: "Colon", + kind: "ColonToken", + tokenChoices: [ + "Colon" + ]) + ]), + + Node(name: "CaseItem", + nameForDiagnostics: nil, + kind: "Syntax", + traits: [ + "WithTrailingComma" + ], + children: [ + Child(name: "Pattern", + kind: "Pattern"), + Child(name: "WhereClause", + kind: "WhereClause", + isOptional: true), + Child(name: "TrailingComma", + kind: "CommaToken", + isOptional: true, + tokenChoices: [ + "Comma" + ]) + ]), + Node(name: "UnresolvedTernaryExpr", nameForDiagnostics: nil, kind: "Expr", diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift index ecaa28f1efc..f8476074cc3 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift @@ -31,6 +31,14 @@ public let STMT_NODES: [Node] = [ kind: "Stmt") ]), + Node(name: "ExpressionStmt", + nameForDiagnostics: "expression", + kind: "Stmt", + children: [ + Child(name: "Expression", + kind: "Expr") + ]), + Node(name: "ContinueStmt", nameForDiagnostics: "'continue' statement", kind: "Stmt", @@ -92,14 +100,6 @@ public let STMT_NODES: [Node] = [ kind: "CodeBlock") ]), - Node(name: "SwitchCaseList", - nameForDiagnostics: nil, - kind: "SyntaxCollection", - element: "Syntax", - elementName: "SwitchCase", - elementChoices: ["SwitchCase", "IfConfigDecl"], - elementsSeparatedByNewline: true), - Node(name: "RepeatWhileStmt", nameForDiagnostics: "'repeat' statement", kind: "Stmt", @@ -228,39 +228,6 @@ public let STMT_NODES: [Node] = [ kind: "CodeBlock") ]), - Node(name: "SwitchStmt", - nameForDiagnostics: "'switch' statement", - kind: "Stmt", - traits: [ - "Braced" - ], - children: [ - Child(name: "SwitchKeyword", - kind: "KeywordToken", - tokenChoices: [ - "Keyword" - ], - textChoices: [ - "switch" - ]), - Child(name: "Expression", - kind: "Expr"), - Child(name: "LeftBrace", - kind: "LeftBraceToken", - tokenChoices: [ - "LeftBrace" - ]), - Child(name: "Cases", - kind: "SwitchCaseList", - collectionElementName: "Case"), - Child(name: "RightBrace", - kind: "RightBraceToken", - tokenChoices: [ - "RightBrace" - ], - requiresLeadingNewline: true) - ]), - Node(name: "CatchClauseList", nameForDiagnostics: "'catch' clause", kind: "SyntaxCollection", @@ -530,104 +497,6 @@ public let STMT_NODES: [Node] = [ kind: "Expr") ]), - Node(name: "IfStmt", - nameForDiagnostics: "'if' statement", - kind: "Stmt", - traits: [ - "WithCodeBlock" - ], - children: [ - Child(name: "IfKeyword", - kind: "KeywordToken", - tokenChoices: [ - "Keyword" - ], - textChoices: [ - "if" - ]), - Child(name: "Conditions", - kind: "ConditionElementList", - collectionElementName: "Condition"), - Child(name: "Body", - kind: "CodeBlock"), - Child(name: "ElseKeyword", - kind: "ElseToken", - isOptional: true), - Child(name: "ElseBody", - kind: "Syntax", - isOptional: true, - nodeChoices: [ - Child(name: "IfStmt", - kind: "IfStmt"), - Child(name: "CodeBlock", - kind: "CodeBlock") - ]) - ]), - - Node(name: "SwitchCase", - nameForDiagnostics: "switch case", - kind: "Syntax", - traits: [ - "WithStatements" - ], - parserFunction: "parseSwitchCase", - children: [ - Child(name: "UnknownAttr", - kind: "Attribute", - isOptional: true), - Child(name: "Label", - kind: "Syntax", - nodeChoices: [ - Child(name: "Default", - kind: "SwitchDefaultLabel"), - Child(name: "Case", - kind: "SwitchCaseLabel") - ]), - Child(name: "Statements", - kind: "CodeBlockItemList", - collectionElementName: "Statement", - isIndented: true) - ]), - - Node(name: "SwitchDefaultLabel", - nameForDiagnostics: nil, - kind: "Syntax", - children: [ - Child(name: "DefaultKeyword", - kind: "KeywordToken", - tokenChoices: [ - "Keyword" - ], - textChoices: [ - "default" - ]), - Child(name: "Colon", - kind: "ColonToken", - tokenChoices: [ - "Colon" - ]) - ]), - - Node(name: "CaseItem", - nameForDiagnostics: nil, - kind: "Syntax", - traits: [ - "WithTrailingComma" - ], - children: [ - Child(name: "Pattern", - kind: "Pattern"), - Child(name: "WhereClause", - kind: "WhereClause", - isOptional: true), - Child(name: "TrailingComma", - kind: "CommaToken", - isOptional: true, - tokenChoices: [ - "Comma" - ]) - ]), - Node(name: "CatchItem", nameForDiagnostics: nil, kind: "Syntax", @@ -649,28 +518,6 @@ public let STMT_NODES: [Node] = [ ]) ]), - Node(name: "SwitchCaseLabel", - nameForDiagnostics: nil, - kind: "Syntax", - children: [ - Child(name: "CaseKeyword", - kind: "KeywordToken", - tokenChoices: [ - "Keyword" - ], - textChoices: [ - "case" - ]), - Child(name: "CaseItems", - kind: "CaseItemList", - collectionElementName: "CaseItem"), - Child(name: "Colon", - kind: "ColonToken", - tokenChoices: [ - "Colon" - ]) - ]), - Node(name: "CatchClause", nameForDiagnostics: "'catch' clause", kind: "Syntax", diff --git a/Sources/SwiftBasicFormat/generated/BasicFormat.swift b/Sources/SwiftBasicFormat/generated/BasicFormat.swift index 7285df7933b..587ec3ebae4 100644 --- a/Sources/SwiftBasicFormat/generated/BasicFormat.swift +++ b/Sources/SwiftBasicFormat/generated/BasicFormat.swift @@ -113,7 +113,7 @@ open class BasicFormat: SyntaxRewriter { return true case \MemberDeclBlockSyntax.rightBrace: return true - case \SwitchStmtSyntax.rightBrace: + case \SwitchExprSyntax.rightBrace: return true default: return putNextTokenOnNewLine diff --git a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md index e3904ee46e9..d16920a3653 100644 --- a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md @@ -85,20 +85,19 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - - - - -- - - - - - - -- - ### Expressions @@ -128,6 +127,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- - - - @@ -282,6 +283,11 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- +- +- +- - - - @@ -369,7 +375,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- - - - @@ -381,11 +386,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- -- -- - -- - - - diff --git a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift index d8b1b67b7c9..b2205a3e3a7 100644 --- a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift +++ b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift @@ -65,7 +65,7 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .missingExpr, .inOutExpr, .tryExpr, .awaitExpr, .moveExpr, .borrowExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packExpansionExpr, .packElementExpr, .sequenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true + case .missingExpr, .inOutExpr, .tryExpr, .awaitExpr, .moveExpr, .borrowExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packExpansionExpr, .packElementExpr, .sequenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ifExpr, .switchExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true default: return false } } @@ -96,7 +96,7 @@ public struct RawStmtSyntax: RawStmtSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .missingStmt, .labeledStmt, .continueStmt, .whileStmt, .deferStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .throwStmt, .ifStmt, .poundAssertStmt: return true + case .missingStmt, .labeledStmt, .expressionStmt, .continueStmt, .whileStmt, .deferStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .throwStmt, .poundAssertStmt: return true default: return false } } @@ -2658,6 +2658,583 @@ public struct RawBooleanLiteralExprSyntax: RawExprSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawIfExprSyntax: RawExprSyntaxNodeProtocol { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum ElseBody: RawSyntaxNodeProtocol { + case `ifExpr`(RawIfExprSyntax) + case `codeBlock`(RawCodeBlockSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return RawIfExprSyntax.isKindOf(raw) || RawCodeBlockSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .ifExpr(let node): return node.raw + case .codeBlock(let node): return node.raw + } + } + + public init?(_ other: T) where T : RawSyntaxNodeProtocol { + if let node = RawIfExprSyntax(other) { + self = .ifExpr(node) + return + } + if let node = RawCodeBlockSyntax(other) { + self = .codeBlock(node) + return + } + return nil + } + } + + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .ifExpr + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? = nil, + ifKeyword: RawTokenSyntax, + _ unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? = nil, + conditions: RawConditionElementListSyntax, + _ unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? = nil, + body: RawCodeBlockSyntax, + _ unexpectedBetweenBodyAndElseKeyword: RawUnexpectedNodesSyntax? = nil, + elseKeyword: RawTokenSyntax?, + _ unexpectedBetweenElseKeywordAndElseBody: RawUnexpectedNodesSyntax? = nil, + elseBody: ElseBody?, + _ unexpectedAfterElseBody: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .ifExpr, uninitializedCount: 11, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeIfKeyword?.raw + layout[1] = ifKeyword.raw + layout[2] = unexpectedBetweenIfKeywordAndConditions?.raw + layout[3] = conditions.raw + layout[4] = unexpectedBetweenConditionsAndBody?.raw + layout[5] = body.raw + layout[6] = unexpectedBetweenBodyAndElseKeyword?.raw + layout[7] = elseKeyword?.raw + layout[8] = unexpectedBetweenElseKeywordAndElseBody?.raw + layout[9] = elseBody?.raw + layout[10] = unexpectedAfterElseBody?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var ifKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var conditions: RawConditionElementListSyntax { + layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))! + } + public var unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var body: RawCodeBlockSyntax { + layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))! + } + public var unexpectedBetweenBodyAndElseKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var elseKeyword: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenElseKeywordAndElseBody: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var elseBody: RawSyntax? { + layoutView.children[9] + } + public var unexpectedAfterElseBody: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawSwitchExprSyntax: RawExprSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .switchExpr + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? = nil, + switchKeyword: RawTokenSyntax, + _ unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? = nil, + leftBrace: RawTokenSyntax, + _ unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? = nil, + cases: RawSwitchCaseListSyntax, + _ unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? = nil, + rightBrace: RawTokenSyntax, + _ unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .switchExpr, uninitializedCount: 11, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeSwitchKeyword?.raw + layout[1] = switchKeyword.raw + layout[2] = unexpectedBetweenSwitchKeywordAndExpression?.raw + layout[3] = expression.raw + layout[4] = unexpectedBetweenExpressionAndLeftBrace?.raw + layout[5] = leftBrace.raw + layout[6] = unexpectedBetweenLeftBraceAndCases?.raw + layout[7] = cases.raw + layout[8] = unexpectedBetweenCasesAndRightBrace?.raw + layout[9] = rightBrace.raw + layout[10] = unexpectedAfterRightBrace?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var switchKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var expression: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! + } + public var unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var leftBrace: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var cases: RawSwitchCaseListSyntax { + layoutView.children[7].map(RawSwitchCaseListSyntax.init(raw:))! + } + public var unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var rightBrace: RawTokenSyntax { + layoutView.children[9].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawSwitchCaseListSyntax: RawSyntaxNodeProtocol { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum Element: RawSyntaxNodeProtocol { + case `switchCase`(RawSwitchCaseSyntax) + case `ifConfigDecl`(RawIfConfigDeclSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return RawSwitchCaseSyntax.isKindOf(raw) || RawIfConfigDeclSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .switchCase(let node): return node.raw + case .ifConfigDecl(let node): return node.raw + } + } + + public init?(_ other: T) where T : RawSyntaxNodeProtocol { + if let node = RawSwitchCaseSyntax(other) { + self = .switchCase(node) + return + } + if let node = RawIfConfigDeclSyntax(other) { + self = .ifConfigDecl(node) + return + } + return nil + } + } + + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .switchCaseList + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init(elements: [Element], arena: __shared SyntaxArena) { + let raw = RawSyntax.makeLayout( + kind: .switchCaseList, 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(raw: raw) + } + + public var elements: [RawSyntax] { + layoutView.children.map { RawSyntax(raw: $0!) } + } +} + +@_spi(RawSyntax) +public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum Label: RawSyntaxNodeProtocol { + case `default`(RawSwitchDefaultLabelSyntax) + case `case`(RawSwitchCaseLabelSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return RawSwitchDefaultLabelSyntax.isKindOf(raw) || RawSwitchCaseLabelSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .default(let node): return node.raw + case .case(let node): return node.raw + } + } + + public init?(_ other: T) where T : RawSyntaxNodeProtocol { + if let node = RawSwitchDefaultLabelSyntax(other) { + self = .default(node) + return + } + if let node = RawSwitchCaseLabelSyntax(other) { + self = .case(node) + return + } + return nil + } + } + + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .switchCase + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? = nil, + unknownAttr: RawAttributeSyntax?, + _ unexpectedBetweenUnknownAttrAndLabel: RawUnexpectedNodesSyntax? = nil, + label: Label, + _ unexpectedBetweenLabelAndStatements: RawUnexpectedNodesSyntax? = nil, + statements: RawCodeBlockItemListSyntax, + _ unexpectedAfterStatements: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .switchCase, uninitializedCount: 7, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeUnknownAttr?.raw + layout[1] = unknownAttr?.raw + layout[2] = unexpectedBetweenUnknownAttrAndLabel?.raw + layout[3] = label.raw + layout[4] = unexpectedBetweenLabelAndStatements?.raw + layout[5] = statements.raw + layout[6] = unexpectedAfterStatements?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var unknownAttr: RawAttributeSyntax? { + layoutView.children[1].map(RawAttributeSyntax.init(raw:)) + } + public var unexpectedBetweenUnknownAttrAndLabel: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var label: RawSyntax { + layoutView.children[3]! + } + public var unexpectedBetweenLabelAndStatements: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var statements: RawCodeBlockItemListSyntax { + layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw:))! + } + public var unexpectedAfterStatements: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .switchCaseLabel + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? = nil, + caseKeyword: RawTokenSyntax, + _ unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? = nil, + caseItems: RawCaseItemListSyntax, + _ unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax, + _ unexpectedAfterColon: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .switchCaseLabel, uninitializedCount: 7, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeCaseKeyword?.raw + layout[1] = caseKeyword.raw + layout[2] = unexpectedBetweenCaseKeywordAndCaseItems?.raw + layout[3] = caseItems.raw + layout[4] = unexpectedBetweenCaseItemsAndColon?.raw + layout[5] = colon.raw + layout[6] = unexpectedAfterColon?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var caseKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var caseItems: RawCaseItemListSyntax { + layoutView.children[3].map(RawCaseItemListSyntax.init(raw:))! + } + public var unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var colon: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .switchDefaultLabel + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? = nil, + defaultKeyword: RawTokenSyntax, + _ unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax, + _ unexpectedAfterColon: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .switchDefaultLabel, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeDefaultKeyword?.raw + layout[1] = defaultKeyword.raw + layout[2] = unexpectedBetweenDefaultKeywordAndColon?.raw + layout[3] = colon.raw + layout[4] = unexpectedAfterColon?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var defaultKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var colon: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .caseItem + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforePattern: RawUnexpectedNodesSyntax? = nil, + pattern: RawPatternSyntax, + _ unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? = nil, + whereClause: RawWhereClauseSyntax?, + _ unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .caseItem, uninitializedCount: 7, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforePattern?.raw + layout[1] = pattern.raw + layout[2] = unexpectedBetweenPatternAndWhereClause?.raw + layout[3] = whereClause?.raw + layout[4] = unexpectedBetweenWhereClauseAndTrailingComma?.raw + layout[5] = trailingComma?.raw + layout[6] = unexpectedAfterTrailingComma?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var pattern: RawPatternSyntax { + layoutView.children[1].map(RawPatternSyntax.init(raw:))! + } + public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var whereClause: RawWhereClauseSyntax? { + layoutView.children[3].map(RawWhereClauseSyntax.init(raw:)) + } + public var unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var trailingComma: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { @@ -12741,6 +13318,56 @@ public struct RawLabeledStmtSyntax: RawStmtSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawExpressionStmtSyntax: RawStmtSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .expressionStmt + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .expressionStmt, uninitializedCount: 3, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedAfterExpression?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! + } + public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawContinueStmtSyntax: RawStmtSyntaxNodeProtocol { @@ -12931,75 +13558,6 @@ public struct RawDeferStmtSyntax: RawStmtSyntaxNodeProtocol { } } -@_spi(RawSyntax) -public struct RawSwitchCaseListSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Element: RawSyntaxNodeProtocol { - case `switchCase`(RawSwitchCaseSyntax) - case `ifConfigDecl`(RawIfConfigDeclSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawSwitchCaseSyntax.isKindOf(raw) || RawIfConfigDeclSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .switchCase(let node): return node.raw - case .ifConfigDecl(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawSwitchCaseSyntax(other) { - self = .switchCase(node) - return - } - if let node = RawIfConfigDeclSyntax(other) { - self = .ifConfigDecl(node) - return - } - return nil - } - } - - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCaseList - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init(elements: [Element], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .switchCaseList, 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(raw: raw) - } - - public var elements: [RawSyntax] { - layoutView.children.map { RawSyntax(raw: $0!) } - } -} - @_spi(RawSyntax) public struct RawRepeatWhileStmtSyntax: RawStmtSyntaxNodeProtocol { @@ -13346,107 +13904,17 @@ public struct RawForInStmtSyntax: RawStmtSyntaxNodeProtocol { public var unexpectedBetweenSequenceExprAndWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var whereClause: RawWhereClauseSyntax? { - layoutView.children[17].map(RawWhereClauseSyntax.init(raw:)) - } - public var unexpectedBetweenWhereClauseAndBody: RawUnexpectedNodesSyntax? { - layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var body: RawCodeBlockSyntax { - layoutView.children[19].map(RawCodeBlockSyntax.init(raw:))! - } - public var unexpectedAfterBody: RawUnexpectedNodesSyntax? { - layoutView.children[20].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawSwitchStmtSyntax: RawStmtSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchStmt - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init( - _ unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? = nil, - switchKeyword: RawTokenSyntax, - _ unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? = nil, - leftBrace: RawTokenSyntax, - _ unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? = nil, - cases: RawSwitchCaseListSyntax, - _ unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? = nil, - rightBrace: RawTokenSyntax, - _ unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .switchStmt, uninitializedCount: 11, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeSwitchKeyword?.raw - layout[1] = switchKeyword.raw - layout[2] = unexpectedBetweenSwitchKeywordAndExpression?.raw - layout[3] = expression.raw - layout[4] = unexpectedBetweenExpressionAndLeftBrace?.raw - layout[5] = leftBrace.raw - layout[6] = unexpectedBetweenLeftBraceAndCases?.raw - layout[7] = cases.raw - layout[8] = unexpectedBetweenCasesAndRightBrace?.raw - layout[9] = rightBrace.raw - layout[10] = unexpectedAfterRightBrace?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var switchKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var expression: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! - } - public var unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftBrace: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var cases: RawSwitchCaseListSyntax { - layoutView.children[7].map(RawSwitchCaseListSyntax.init(raw:))! + public var whereClause: RawWhereClauseSyntax? { + layoutView.children[17].map(RawWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedBetweenWhereClauseAndBody: RawUnexpectedNodesSyntax? { + layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightBrace: RawTokenSyntax { - layoutView.children[9].map(RawTokenSyntax.init(raw:))! + public var body: RawCodeBlockSyntax { + layoutView.children[19].map(RawCodeBlockSyntax.init(raw:))! } - public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedAfterBody: RawUnexpectedNodesSyntax? { + layoutView.children[20].map(RawUnexpectedNodesSyntax.init(raw:)) } } @@ -14062,262 +14530,22 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { public var unexpectedBeforeCondition: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var condition: RawSyntax { - layoutView.children[1]! - } - public var unexpectedBetweenConditionAndTrailingComma: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var trailingComma: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .availabilityCondition - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init( - _ unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? = nil, - availabilityKeyword: RawTokenSyntax, - _ unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? = nil, - availabilitySpec: RawAvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .availabilityCondition, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAvailabilityKeyword?.raw - layout[1] = availabilityKeyword.raw - layout[2] = unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndAvailabilitySpec?.raw - layout[5] = availabilitySpec.raw - layout[6] = unexpectedBetweenAvailabilitySpecAndRightParen?.raw - layout[7] = rightParen.raw - layout[8] = unexpectedAfterRightParen?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var availabilityKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var availabilitySpec: RawAvailabilitySpecListSyntax { - layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw:))! - } - public var unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var rightParen: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .matchingPatternCondition - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init( - _ unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? = nil, - caseKeyword: RawTokenSyntax, - _ unexpectedBetweenCaseKeywordAndPattern: RawUnexpectedNodesSyntax? = nil, - pattern: RawPatternSyntax, - _ unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? = nil, - typeAnnotation: RawTypeAnnotationSyntax?, - _ unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? = nil, - initializer: RawInitializerClauseSyntax, - _ unexpectedAfterInitializer: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .matchingPatternCondition, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeCaseKeyword?.raw - layout[1] = caseKeyword.raw - layout[2] = unexpectedBetweenCaseKeywordAndPattern?.raw - layout[3] = pattern.raw - layout[4] = unexpectedBetweenPatternAndTypeAnnotation?.raw - layout[5] = typeAnnotation?.raw - layout[6] = unexpectedBetweenTypeAnnotationAndInitializer?.raw - layout[7] = initializer.raw - layout[8] = unexpectedAfterInitializer?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var caseKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenCaseKeywordAndPattern: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var pattern: RawPatternSyntax { - layoutView.children[3].map(RawPatternSyntax.init(raw:))! - } - public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var typeAnnotation: RawTypeAnnotationSyntax? { - layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw:)) - } - public var unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var initializer: RawInitializerClauseSyntax { - layoutView.children[7].map(RawInitializerClauseSyntax.init(raw:))! - } - public var unexpectedAfterInitializer: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .optionalBindingCondition - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init( - _ unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? = nil, - letOrVarKeyword: RawTokenSyntax, - _ unexpectedBetweenLetOrVarKeywordAndPattern: RawUnexpectedNodesSyntax? = nil, - pattern: RawPatternSyntax, - _ unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? = nil, - typeAnnotation: RawTypeAnnotationSyntax?, - _ unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? = nil, - initializer: RawInitializerClauseSyntax?, - _ unexpectedAfterInitializer: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .optionalBindingCondition, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLetOrVarKeyword?.raw - layout[1] = letOrVarKeyword.raw - layout[2] = unexpectedBetweenLetOrVarKeywordAndPattern?.raw - layout[3] = pattern.raw - layout[4] = unexpectedBetweenPatternAndTypeAnnotation?.raw - layout[5] = typeAnnotation?.raw - layout[6] = unexpectedBetweenTypeAnnotationAndInitializer?.raw - layout[7] = initializer?.raw - layout[8] = unexpectedAfterInitializer?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var letOrVarKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLetOrVarKeywordAndPattern: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var pattern: RawPatternSyntax { - layoutView.children[3].map(RawPatternSyntax.init(raw:))! - } - public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var typeAnnotation: RawTypeAnnotationSyntax? { - layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw:)) + public var condition: RawSyntax { + layoutView.children[1]! } - public var unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedBetweenConditionAndTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var initializer: RawInitializerClauseSyntax? { - layoutView.children[7].map(RawInitializerClauseSyntax.init(raw:)) + public var trailingComma: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterInitializer: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol { +public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14325,7 +14553,7 @@ public struct RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .hasSymbolCondition + return raw.kind == .availabilityCondition } public var raw: RawSyntax @@ -14340,52 +14568,52 @@ public struct RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeHasSymbolKeyword: RawUnexpectedNodesSyntax? = nil, - hasSymbolKeyword: RawTokenSyntax, - _ unexpectedBetweenHasSymbolKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? = nil, + availabilityKeyword: RawTokenSyntax, + _ unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? = nil, + availabilitySpec: RawAvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? = nil, rightParen: RawTokenSyntax, _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .hasSymbolCondition, uninitializedCount: 9, arena: arena) { layout in + kind: .availabilityCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeHasSymbolKeyword?.raw - layout[1] = hasSymbolKeyword.raw - layout[2] = unexpectedBetweenHasSymbolKeywordAndLeftParen?.raw + layout[0] = unexpectedBeforeAvailabilityKeyword?.raw + layout[1] = availabilityKeyword.raw + layout[2] = unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndExpression?.raw - layout[5] = expression.raw - layout[6] = unexpectedBetweenExpressionAndRightParen?.raw + layout[4] = unexpectedBetweenLeftParenAndAvailabilitySpec?.raw + layout[5] = availabilitySpec.raw + layout[6] = unexpectedBetweenAvailabilitySpecAndRightParen?.raw layout[7] = rightParen.raw layout[8] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeHasSymbolKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var hasSymbolKeyword: RawTokenSyntax { + public var availabilityKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenHasSymbolKeywordAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } public var leftParen: RawTokenSyntax { layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[5].map(RawExprSyntax.init(raw:))! + public var availabilitySpec: RawAvailabilitySpecListSyntax { + layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw:))! } - public var unexpectedBetweenExpressionAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } public var rightParen: RawTokenSyntax { @@ -14397,47 +14625,7 @@ public struct RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .conditionElementList - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init(elements: [RawConditionElementSyntax], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .conditionElementList, 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(raw: raw) - } - - public var elements: [RawConditionElementSyntax] { - layoutView.children.map { RawConditionElementSyntax(raw: $0!) } - } -} - -@_spi(RawSyntax) -public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { +public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14445,7 +14633,7 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .throwStmt + return raw.kind == .matchingPatternCondition } public var raw: RawSyntax @@ -14460,73 +14648,64 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } public init( - _ unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? = nil, - throwKeyword: RawTokenSyntax, - _ unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? = nil, + caseKeyword: RawTokenSyntax, + _ unexpectedBetweenCaseKeywordAndPattern: RawUnexpectedNodesSyntax? = nil, + pattern: RawPatternSyntax, + _ unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? = nil, + typeAnnotation: RawTypeAnnotationSyntax?, + _ unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? = nil, + initializer: RawInitializerClauseSyntax, + _ unexpectedAfterInitializer: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .throwStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .matchingPatternCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeThrowKeyword?.raw - layout[1] = throwKeyword.raw - layout[2] = unexpectedBetweenThrowKeywordAndExpression?.raw - layout[3] = expression.raw - layout[4] = unexpectedAfterExpression?.raw + layout[0] = unexpectedBeforeCaseKeyword?.raw + layout[1] = caseKeyword.raw + layout[2] = unexpectedBetweenCaseKeywordAndPattern?.raw + layout[3] = pattern.raw + layout[4] = unexpectedBetweenPatternAndTypeAnnotation?.raw + layout[5] = typeAnnotation?.raw + layout[6] = unexpectedBetweenTypeAnnotationAndInitializer?.raw + layout[7] = initializer.raw + layout[8] = unexpectedAfterInitializer?.raw } self.init(raw: raw) } - public var unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var throwKeyword: RawTokenSyntax { + public var caseKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCaseKeywordAndPattern: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! + public var pattern: RawPatternSyntax { + layoutView.children[3].map(RawPatternSyntax.init(raw:))! } - public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var typeAnnotation: RawTypeAnnotationSyntax? { + layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw:)) + } + public var unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var initializer: RawInitializerClauseSyntax { + layoutView.children[7].map(RawInitializerClauseSyntax.init(raw:))! + } + public var unexpectedAfterInitializer: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawIfStmtSyntax: RawStmtSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum ElseBody: RawSyntaxNodeProtocol { - case `ifStmt`(RawIfStmtSyntax) - case `codeBlock`(RawCodeBlockSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawIfStmtSyntax.isKindOf(raw) || RawCodeBlockSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .ifStmt(let node): return node.raw - case .codeBlock(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawIfStmtSyntax(other) { - self = .ifStmt(node) - return - } - if let node = RawCodeBlockSyntax(other) { - self = .codeBlock(node) - return - } - return nil - } - } - +public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14534,7 +14713,7 @@ public struct RawIfStmtSyntax: RawStmtSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifStmt + return raw.kind == .optionalBindingCondition } public var raw: RawSyntax @@ -14549,103 +14728,64 @@ public struct RawIfStmtSyntax: RawStmtSyntaxNodeProtocol { } public init( - _ unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? = nil, - ifKeyword: RawTokenSyntax, - _ unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? = nil, - conditions: RawConditionElementListSyntax, - _ unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? = nil, - body: RawCodeBlockSyntax, - _ unexpectedBetweenBodyAndElseKeyword: RawUnexpectedNodesSyntax? = nil, - elseKeyword: RawTokenSyntax?, - _ unexpectedBetweenElseKeywordAndElseBody: RawUnexpectedNodesSyntax? = nil, - elseBody: ElseBody?, - _ unexpectedAfterElseBody: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? = nil, + letOrVarKeyword: RawTokenSyntax, + _ unexpectedBetweenLetOrVarKeywordAndPattern: RawUnexpectedNodesSyntax? = nil, + pattern: RawPatternSyntax, + _ unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? = nil, + typeAnnotation: RawTypeAnnotationSyntax?, + _ unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? = nil, + initializer: RawInitializerClauseSyntax?, + _ unexpectedAfterInitializer: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .ifStmt, uninitializedCount: 11, arena: arena) { layout in + kind: .optionalBindingCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeIfKeyword?.raw - layout[1] = ifKeyword.raw - layout[2] = unexpectedBetweenIfKeywordAndConditions?.raw - layout[3] = conditions.raw - layout[4] = unexpectedBetweenConditionsAndBody?.raw - layout[5] = body.raw - layout[6] = unexpectedBetweenBodyAndElseKeyword?.raw - layout[7] = elseKeyword?.raw - layout[8] = unexpectedBetweenElseKeywordAndElseBody?.raw - layout[9] = elseBody?.raw - layout[10] = unexpectedAfterElseBody?.raw + layout[0] = unexpectedBeforeLetOrVarKeyword?.raw + layout[1] = letOrVarKeyword.raw + layout[2] = unexpectedBetweenLetOrVarKeywordAndPattern?.raw + layout[3] = pattern.raw + layout[4] = unexpectedBetweenPatternAndTypeAnnotation?.raw + layout[5] = typeAnnotation?.raw + layout[6] = unexpectedBetweenTypeAnnotationAndInitializer?.raw + layout[7] = initializer?.raw + layout[8] = unexpectedAfterInitializer?.raw } self.init(raw: raw) } - public var unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var ifKeyword: RawTokenSyntax { + public var letOrVarKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLetOrVarKeywordAndPattern: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var conditions: RawConditionElementListSyntax { - layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))! + public var pattern: RawPatternSyntax { + layoutView.children[3].map(RawPatternSyntax.init(raw:))! } - public var unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var body: RawCodeBlockSyntax { - layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))! + public var typeAnnotation: RawTypeAnnotationSyntax? { + layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw:)) } - public var unexpectedBetweenBodyAndElseKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAnnotationAndInitializer: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var elseKeyword: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenElseKeywordAndElseBody: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var elseBody: RawSyntax? { - layoutView.children[9] + public var initializer: RawInitializerClauseSyntax? { + layoutView.children[7].map(RawInitializerClauseSyntax.init(raw:)) } - public var unexpectedAfterElseBody: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedAfterInitializer: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Label: RawSyntaxNodeProtocol { - case `default`(RawSwitchDefaultLabelSyntax) - case `case`(RawSwitchCaseLabelSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawSwitchDefaultLabelSyntax.isKindOf(raw) || RawSwitchCaseLabelSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .default(let node): return node.raw - case .case(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawSwitchDefaultLabelSyntax(other) { - self = .default(node) - return - } - if let node = RawSwitchCaseLabelSyntax(other) { - self = .case(node) - return - } - return nil - } - } - +public struct RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14653,7 +14793,7 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCase + return raw.kind == .hasSymbolCondition } public var raw: RawSyntax @@ -14668,54 +14808,64 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? = nil, - unknownAttr: RawAttributeSyntax?, - _ unexpectedBetweenUnknownAttrAndLabel: RawUnexpectedNodesSyntax? = nil, - label: Label, - _ unexpectedBetweenLabelAndStatements: RawUnexpectedNodesSyntax? = nil, - statements: RawCodeBlockItemListSyntax, - _ unexpectedAfterStatements: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeHasSymbolKeyword: RawUnexpectedNodesSyntax? = nil, + hasSymbolKeyword: RawTokenSyntax, + _ unexpectedBetweenHasSymbolKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .switchCase, uninitializedCount: 7, arena: arena) { layout in + kind: .hasSymbolCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeUnknownAttr?.raw - layout[1] = unknownAttr?.raw - layout[2] = unexpectedBetweenUnknownAttrAndLabel?.raw - layout[3] = label.raw - layout[4] = unexpectedBetweenLabelAndStatements?.raw - layout[5] = statements.raw - layout[6] = unexpectedAfterStatements?.raw + layout[0] = unexpectedBeforeHasSymbolKeyword?.raw + layout[1] = hasSymbolKeyword.raw + layout[2] = unexpectedBetweenHasSymbolKeywordAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndExpression?.raw + layout[5] = expression.raw + layout[6] = unexpectedBetweenExpressionAndRightParen?.raw + layout[7] = rightParen.raw + layout[8] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeHasSymbolKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var unknownAttr: RawAttributeSyntax? { - layoutView.children[1].map(RawAttributeSyntax.init(raw:)) + public var hasSymbolKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenUnknownAttrAndLabel: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenHasSymbolKeywordAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var label: RawSyntax { - layoutView.children[3]! + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLabelAndStatements: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndExpression: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var statements: RawCodeBlockItemListSyntax { - layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[5].map(RawExprSyntax.init(raw:))! } - public var unexpectedAfterStatements: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var rightParen: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { +public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14723,7 +14873,7 @@ public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchDefaultLabel + return raw.kind == .conditionElementList } public var raw: RawSyntax @@ -14737,45 +14887,25 @@ public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? = nil, - defaultKeyword: RawTokenSyntax, - _ unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax, - _ unexpectedAfterColon: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawConditionElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .switchDefaultLabel, uninitializedCount: 5, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeDefaultKeyword?.raw - layout[1] = defaultKeyword.raw - layout[2] = unexpectedBetweenDefaultKeywordAndColon?.raw - layout[3] = colon.raw - layout[4] = unexpectedAfterColon?.raw + kind: .conditionElementList, 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(raw: raw) } - public var unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var defaultKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var colon: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawConditionElementSyntax] { + layoutView.children.map { RawConditionElementSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { +public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14783,7 +14913,7 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .caseItem + return raw.kind == .throwStmt } public var raw: RawSyntax @@ -14798,50 +14928,40 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforePattern: RawUnexpectedNodesSyntax? = nil, - pattern: RawPatternSyntax, - _ unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? = nil, - whereClause: RawWhereClauseSyntax?, - _ unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? = nil, + throwKeyword: RawTokenSyntax, + _ unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .caseItem, uninitializedCount: 7, arena: arena) { layout in + kind: .throwStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePattern?.raw - layout[1] = pattern.raw - layout[2] = unexpectedBetweenPatternAndWhereClause?.raw - layout[3] = whereClause?.raw - layout[4] = unexpectedBetweenWhereClauseAndTrailingComma?.raw - layout[5] = trailingComma?.raw - layout[6] = unexpectedAfterTrailingComma?.raw + layout[0] = unexpectedBeforeThrowKeyword?.raw + layout[1] = throwKeyword.raw + layout[2] = unexpectedBetweenThrowKeywordAndExpression?.raw + layout[3] = expression.raw + layout[4] = unexpectedAfterExpression?.raw } self.init(raw: raw) } - public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var pattern: RawPatternSyntax { - layoutView.children[1].map(RawPatternSyntax.init(raw:))! + public var throwKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var whereClause: RawWhereClauseSyntax? { - layoutView.children[3].map(RawWhereClauseSyntax.init(raw:)) + public var expression: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var trailingComma: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) @@ -14914,76 +15034,6 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol { } } -@_spi(RawSyntax) -public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCaseLabel - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init( - _ unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? = nil, - caseKeyword: RawTokenSyntax, - _ unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? = nil, - caseItems: RawCaseItemListSyntax, - _ unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax, - _ unexpectedAfterColon: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .switchCaseLabel, uninitializedCount: 7, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeCaseKeyword?.raw - layout[1] = caseKeyword.raw - layout[2] = unexpectedBetweenCaseKeywordAndCaseItems?.raw - layout[3] = caseItems.raw - layout[4] = unexpectedBetweenCaseItemsAndColon?.raw - layout[5] = colon.raw - layout[6] = unexpectedAfterColon?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var caseKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var caseItems: RawCaseItemListSyntax { - layoutView.children[3].map(RawCaseItemListSyntax.init(raw:))! - } - public var unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var colon: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - @_spi(RawSyntax) public struct RawCatchClauseSyntax: RawSyntaxNodeProtocol { diff --git a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift index 2986ef640a3..bf8c8fcf4f4 100644 --- a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift @@ -409,6 +409,86 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) break + case .ifExpr: + assert(layout.count == 11) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawConditionElementListSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawCodeBlockSyntax.self)) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self)) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + assertAnyHasNoError(kind, 9, [ + verify(layout[9], as: RawSyntax?.self), + verify(layout[9], as: RawSyntax?.self), + ]) + assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) + break + case .switchExpr: + assert(layout.count == 11) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self)) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawSwitchCaseListSyntax.self)) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax.self)) + assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) + break + case .switchCaseList: + for (index, element) in layout.enumerated() { + assertAnyHasNoError(kind, index, [ + verify(element, as: RawSwitchCaseSyntax.self), + verify(element, as: RawIfConfigDeclSyntax.self), + ]) + } + break + case .switchCase: + assert(layout.count == 7) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawAttributeSyntax?.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertAnyHasNoError(kind, 3, [ + verify(layout[3], as: RawSyntax.self), + verify(layout[3], as: RawSyntax.self), + ]) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawCodeBlockItemListSyntax.self)) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + break + case .switchCaseLabel: + assert(layout.count == 7) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawCaseItemListSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self)) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + break + case .switchDefaultLabel: + assert(layout.count == 5) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + break + case .caseItem: + assert(layout.count == 7) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawPatternSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawWhereClauseSyntax?.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self)) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + break case .unresolvedTernaryExpr: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1879,6 +1959,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 5, verify(layout[5], as: RawStmtSyntax.self)) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) break + case .expressionStmt: + assert(layout.count == 3) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawExprSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + break case .continueStmt: assert(layout.count == 5) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1905,14 +1991,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 3, verify(layout[3], as: RawCodeBlockSyntax.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) break - case .switchCaseList: - for (index, element) in layout.enumerated() { - assertAnyHasNoError(kind, index, [ - verify(element, as: RawSwitchCaseSyntax.self), - verify(element, as: RawIfConfigDeclSyntax.self), - ]) - } - break case .repeatWhileStmt: assert(layout.count == 9) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1969,20 +2047,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 19, verify(layout[19], as: RawCodeBlockSyntax.self)) assertNoError(kind, 20, verify(layout[20], as: RawUnexpectedNodesSyntax?.self)) break - case .switchStmt: - assert(layout.count == 11) - assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) - assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self)) - assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 7, verify(layout[7], as: RawSwitchCaseListSyntax.self)) - assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax.self)) - assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) - break case .catchClauseList: for (index, element) in layout.enumerated() { assertNoError(kind, index, verify(element, as: RawCatchClauseSyntax.self)) @@ -2126,54 +2190,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) break - case .ifStmt: - assert(layout.count == 11) - assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) - assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawConditionElementListSyntax.self)) - assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawCodeBlockSyntax.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self)) - assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) - assertAnyHasNoError(kind, 9, [ - verify(layout[9], as: RawSyntax?.self), - verify(layout[9], as: RawSyntax?.self), - ]) - assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) - break - case .switchCase: - assert(layout.count == 7) - assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawAttributeSyntax?.self)) - assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertAnyHasNoError(kind, 3, [ - verify(layout[3], as: RawSyntax.self), - verify(layout[3], as: RawSyntax.self), - ]) - assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawCodeBlockItemListSyntax.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - break - case .switchDefaultLabel: - assert(layout.count == 5) - assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) - assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self)) - assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - break - case .caseItem: - assert(layout.count == 7) - assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawPatternSyntax.self)) - assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawWhereClauseSyntax?.self)) - assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - break case .catchItem: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -2184,16 +2200,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self)) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) break - case .switchCaseLabel: - assert(layout.count == 7) - assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self)) - assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawCaseItemListSyntax.self)) - assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) - break case .catchClause: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/Misc.swift b/Sources/SwiftSyntax/generated/Misc.swift index 79af8c35cf5..ccafef50beb 100644 --- a/Sources/SwiftSyntax/generated/Misc.swift +++ b/Sources/SwiftSyntax/generated/Misc.swift @@ -114,6 +114,7 @@ extension Syntax { .node(ExprListSyntax.self), .node(ExpressionPatternSyntax.self), .node(ExpressionSegmentSyntax.self), + .node(ExpressionStmtSyntax.self), .node(ExtensionDeclSyntax.self), .node(FallthroughStmtSyntax.self), .node(FloatLiteralExprSyntax.self), @@ -141,7 +142,7 @@ extension Syntax { .node(IfConfigClauseListSyntax.self), .node(IfConfigClauseSyntax.self), .node(IfConfigDeclSyntax.self), - .node(IfStmtSyntax.self), + .node(IfExprSyntax.self), .node(ImplementsAttributeArgumentsSyntax.self), .node(ImplicitlyUnwrappedOptionalTypeSyntax.self), .node(ImportDeclSyntax.self), @@ -242,7 +243,7 @@ extension Syntax { .node(SwitchCaseListSyntax.self), .node(SwitchCaseSyntax.self), .node(SwitchDefaultLabelSyntax.self), - .node(SwitchStmtSyntax.self), + .node(SwitchExprSyntax.self), .node(TargetFunctionEntrySyntax.self), .node(TernaryExprSyntax.self), .node(ThrowStmtSyntax.self), @@ -477,6 +478,8 @@ extension SyntaxKind { return ExpressionPatternSyntax.self case .expressionSegment: return ExpressionSegmentSyntax.self + case .expressionStmt: + return ExpressionStmtSyntax.self case .extensionDecl: return ExtensionDeclSyntax.self case .fallthroughStmt: @@ -531,8 +534,8 @@ extension SyntaxKind { return IfConfigClauseSyntax.self case .ifConfigDecl: return IfConfigDeclSyntax.self - case .ifStmt: - return IfStmtSyntax.self + case .ifExpr: + return IfExprSyntax.self case .implementsAttributeArguments: return ImplementsAttributeArgumentsSyntax.self case .implicitlyUnwrappedOptionalType: @@ -733,8 +736,8 @@ extension SyntaxKind { return SwitchCaseSyntax.self case .switchDefaultLabel: return SwitchDefaultLabelSyntax.self - case .switchStmt: - return SwitchStmtSyntax.self + case .switchExpr: + return SwitchExprSyntax.self case .targetFunctionEntry: return TargetFunctionEntrySyntax.self case .ternaryExpr: @@ -1004,6 +1007,8 @@ extension SyntaxKind { return "pattern" case .expressionSegment: return nil + case .expressionStmt: + return "expression" case .extensionDecl: return "extension" case .fallthroughStmt: @@ -1058,7 +1063,7 @@ extension SyntaxKind { return "conditional compilation clause" case .ifConfigDecl: return "conditional compilation block" - case .ifStmt: + case .ifExpr: return "'if' statement" case .implementsAttributeArguments: return "@_implements arguemnts" @@ -1260,7 +1265,7 @@ extension SyntaxKind { return "switch case" case .switchDefaultLabel: return nil - case .switchStmt: + case .switchExpr: return "'switch' statement" case .targetFunctionEntry: return "attribute argument" diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index c87a0f4406d..0399e8754c9 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -817,6 +817,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ExpressionStmtSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ExpressionStmtSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -1033,11 +1041,11 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: IfStmtSyntax) -> SyntaxVisitorContinueKind { + override open func visit(_ node: IfExprSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } - override open func visitPost(_ node: IfStmtSyntax) { + override open func visitPost(_ node: IfExprSyntax) { visitAnyPost(node._syntaxNode) } @@ -1841,11 +1849,11 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: SwitchStmtSyntax) -> SyntaxVisitorContinueKind { + override open func visit(_ node: SwitchExprSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } - override open func visitPost(_ node: SwitchStmtSyntax) { + override open func visitPost(_ node: SwitchExprSyntax) { visitAnyPost(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index b16a5d28cb9..935fe2112ec 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -218,7 +218,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public init? < S: SyntaxProtocol > (_ node: S) { switch node.raw.kind { - case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: + case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: self._syntaxNode = node._syntaxNode default: return nil @@ -231,7 +231,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { internal init(_ data: SyntaxData) { #if DEBUG switch data.raw.kind { - case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: + case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: break default: fatalError("Unable to create ExprSyntax from \(data.raw.kind)") @@ -283,6 +283,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { .node(ForcedValueExprSyntax.self), .node(FunctionCallExprSyntax.self), .node(IdentifierExprSyntax.self), + .node(IfExprSyntax.self), .node(InOutExprSyntax.self), .node(InfixOperatorExprSyntax.self), .node(IntegerLiteralExprSyntax.self), @@ -305,6 +306,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { .node(StringLiteralExprSyntax.self), .node(SubscriptExprSyntax.self), .node(SuperRefExprSyntax.self), + .node(SwitchExprSyntax.self), .node(TernaryExprSyntax.self), .node(TryExprSyntax.self), .node(TupleExprSyntax.self), @@ -519,7 +521,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public init? < S: SyntaxProtocol > (_ node: S) { switch node.raw.kind { - case .breakStmt, .continueStmt, .deferStmt, .doStmt, .fallthroughStmt, .forInStmt, .guardStmt, .ifStmt, .labeledStmt, .missingStmt, .poundAssertStmt, .repeatWhileStmt, .returnStmt, .switchStmt, .throwStmt, .whileStmt, .yieldStmt: + case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .poundAssertStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: self._syntaxNode = node._syntaxNode default: return nil @@ -532,7 +534,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { internal init(_ data: SyntaxData) { #if DEBUG switch data.raw.kind { - case .breakStmt, .continueStmt, .deferStmt, .doStmt, .fallthroughStmt, .forInStmt, .guardStmt, .ifStmt, .labeledStmt, .missingStmt, .poundAssertStmt, .repeatWhileStmt, .returnStmt, .switchStmt, .throwStmt, .whileStmt, .yieldStmt: + case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .poundAssertStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: break default: fatalError("Unable to create StmtSyntax from \(data.raw.kind)") @@ -572,16 +574,15 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { .node(ContinueStmtSyntax.self), .node(DeferStmtSyntax.self), .node(DoStmtSyntax.self), + .node(ExpressionStmtSyntax.self), .node(FallthroughStmtSyntax.self), .node(ForInStmtSyntax.self), .node(GuardStmtSyntax.self), - .node(IfStmtSyntax.self), .node(LabeledStmtSyntax.self), .node(MissingStmtSyntax.self), .node(PoundAssertStmtSyntax.self), .node(RepeatWhileStmtSyntax.self), .node(ReturnStmtSyntax.self), - .node(SwitchStmtSyntax.self), .node(ThrowStmtSyntax.self), .node(WhileStmtSyntax.self), .node(YieldStmtSyntax.self)]) diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index e92b1593336..eba75a56ff7 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -208,6 +208,8 @@ public enum SyntaxEnum { case expressionSegment(ExpressionSegmentSyntax) + case expressionStmt(ExpressionStmtSyntax) + case extensionDecl(ExtensionDeclSyntax) case fallthroughStmt(FallthroughStmtSyntax) @@ -262,7 +264,7 @@ public enum SyntaxEnum { case ifConfigDecl(IfConfigDeclSyntax) - case ifStmt(IfStmtSyntax) + case ifExpr(IfExprSyntax) case implementsAttributeArguments(ImplementsAttributeArgumentsSyntax) @@ -464,7 +466,7 @@ public enum SyntaxEnum { case switchDefaultLabel(SwitchDefaultLabelSyntax) - case switchStmt(SwitchStmtSyntax) + case switchExpr(SwitchExprSyntax) case targetFunctionEntry(TargetFunctionEntrySyntax) @@ -735,6 +737,8 @@ public extension Syntax { return .expressionPattern(ExpressionPatternSyntax(self)!) case .expressionSegment: return .expressionSegment(ExpressionSegmentSyntax(self)!) + case .expressionStmt: + return .expressionStmt(ExpressionStmtSyntax(self)!) case .extensionDecl: return .extensionDecl(ExtensionDeclSyntax(self)!) case .fallthroughStmt: @@ -789,8 +793,8 @@ public extension Syntax { return .ifConfigClause(IfConfigClauseSyntax(self)!) case .ifConfigDecl: return .ifConfigDecl(IfConfigDeclSyntax(self)!) - case .ifStmt: - return .ifStmt(IfStmtSyntax(self)!) + case .ifExpr: + return .ifExpr(IfExprSyntax(self)!) case .implementsAttributeArguments: return .implementsAttributeArguments(ImplementsAttributeArgumentsSyntax(self)!) case .implicitlyUnwrappedOptionalType: @@ -991,8 +995,8 @@ public extension Syntax { return .switchCase(SwitchCaseSyntax(self)!) case .switchDefaultLabel: return .switchDefaultLabel(SwitchDefaultLabelSyntax(self)!) - case .switchStmt: - return .switchStmt(SwitchStmtSyntax(self)!) + case .switchExpr: + return .switchExpr(SwitchExprSyntax(self)!) case .targetFunctionEntry: return .targetFunctionEntry(TargetFunctionEntrySyntax(self)!) case .ternaryExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index 26ba9923042..d2b8c212076 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -208,6 +208,8 @@ public enum SyntaxKind { case expressionSegment + case expressionStmt + case extensionDecl case fallthroughStmt @@ -262,7 +264,7 @@ public enum SyntaxKind { case ifConfigDecl - case ifStmt + case ifExpr case implementsAttributeArguments @@ -464,7 +466,7 @@ public enum SyntaxKind { case switchDefaultLabel - case switchStmt + case switchExpr case targetFunctionEntry diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index 176bb519057..44d980d4744 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -322,7 +322,7 @@ extension GenericRequirementSyntax: WithTrailingCommaSyntax { extension GuardStmtSyntax: WithCodeBlockSyntax { } -extension IfStmtSyntax: WithCodeBlockSyntax { +extension IfExprSyntax: WithCodeBlockSyntax { } extension ImportDeclSyntax: AttributedSyntax { @@ -388,7 +388,7 @@ extension SubscriptDeclSyntax: AttributedSyntax { extension SwitchCaseSyntax: WithStatementsSyntax { } -extension SwitchStmtSyntax: BracedSyntax { +extension SwitchExprSyntax: BracedSyntax { } extension TargetFunctionEntrySyntax: WithTrailingCommaSyntax { diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift index e15b7123dd7..99872c9abc9 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift @@ -496,6 +496,11 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ExpressionSegmentSyntax) -> ResultType + /// Visiting `ExpressionStmtSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: ExpressionStmtSyntax) -> ResultType + /// Visiting `ExtensionDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -631,10 +636,10 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: IfConfigDeclSyntax) -> ResultType - /// Visiting `IfStmtSyntax` specifically. + /// Visiting `IfExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: IfStmtSyntax) -> ResultType + func visit(_ node: IfExprSyntax) -> ResultType /// Visiting `ImplementsAttributeArgumentsSyntax` specifically. /// - Parameter node: the node we are visiting. @@ -1136,10 +1141,10 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType - /// Visiting `SwitchStmtSyntax` specifically. + /// Visiting `SwitchExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: SwitchStmtSyntax) -> ResultType + func visit(_ node: SwitchExprSyntax) -> ResultType /// Visiting `TargetFunctionEntrySyntax` specifically. /// - Parameter node: the node we are visiting. @@ -1992,6 +1997,13 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } + /// Visiting `ExpressionStmtSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: ExpressionStmtSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `ExtensionDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2181,10 +2193,10 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } - /// Visiting `IfStmtSyntax` specifically. + /// Visiting `IfExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. - public func visit(_ node: IfStmtSyntax) -> ResultType { + public func visit(_ node: IfExprSyntax) -> ResultType { visitAny(Syntax(node)) } @@ -2888,10 +2900,10 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } - /// Visiting `SwitchStmtSyntax` specifically. + /// Visiting `SwitchExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. - public func visit(_ node: SwitchStmtSyntax) -> ResultType { + public func visit(_ node: SwitchExprSyntax) -> ResultType { visitAny(Syntax(node)) } @@ -3341,6 +3353,8 @@ extension SyntaxTransformVisitor { return visit(derived) case .expressionSegment(let derived): return visit(derived) + case .expressionStmt(let derived): + return visit(derived) case .extensionDecl(let derived): return visit(derived) case .fallthroughStmt(let derived): @@ -3395,7 +3409,7 @@ extension SyntaxTransformVisitor { return visit(derived) case .ifConfigDecl(let derived): return visit(derived) - case .ifStmt(let derived): + case .ifExpr(let derived): return visit(derived) case .implementsAttributeArguments(let derived): return visit(derived) @@ -3597,7 +3611,7 @@ extension SyntaxTransformVisitor { return visit(derived) case .switchDefaultLabel(let derived): return visit(derived) - case .switchStmt(let derived): + case .switchExpr(let derived): return visit(derived) case .targetFunctionEntry(let derived): return visit(derived) diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index de213985e94..cad800087b1 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -1168,6 +1168,18 @@ open class SyntaxVisitor { open func visitPost(_ node: ExpressionSegmentSyntax) { } + /// Visiting `ExpressionStmtSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ExpressionStmtSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `ExpressionStmtSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ExpressionStmtSyntax) { + } + /// Visiting `ExtensionDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1492,16 +1504,16 @@ open class SyntaxVisitor { open func visitPost(_ node: IfConfigDeclSyntax) { } - /// Visiting `IfStmtSyntax` specifically. + /// Visiting `IfExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. - open func visit(_ node: IfStmtSyntax) -> SyntaxVisitorContinueKind { + open func visit(_ node: IfExprSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } - /// The function called after visiting `IfStmtSyntax` and its descendents. + /// The function called after visiting `IfExprSyntax` and its descendents. /// - node: the node we just finished visiting. - open func visitPost(_ node: IfStmtSyntax) { + open func visitPost(_ node: IfExprSyntax) { } /// Visiting `ImplementsAttributeArgumentsSyntax` specifically. @@ -2704,16 +2716,16 @@ open class SyntaxVisitor { open func visitPost(_ node: SwitchDefaultLabelSyntax) { } - /// Visiting `SwitchStmtSyntax` specifically. + /// Visiting `SwitchExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. - open func visit(_ node: SwitchStmtSyntax) -> SyntaxVisitorContinueKind { + open func visit(_ node: SwitchExprSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } - /// The function called after visiting `SwitchStmtSyntax` and its descendents. + /// The function called after visiting `SwitchExprSyntax` and its descendents. /// - node: the node we just finished visiting. - open func visitPost(_ node: SwitchStmtSyntax) { + open func visitPost(_ node: SwitchExprSyntax) { } /// Visiting `TargetFunctionEntrySyntax` specifically. @@ -4205,6 +4217,17 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplExpressionStmtSyntax(_ data: SyntaxData) { + let node = ExpressionStmtSyntax(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 visitImplExtensionDeclSyntax(_ data: SyntaxData) { let node = ExtensionDeclSyntax(data) @@ -4503,8 +4526,8 @@ open class SyntaxVisitor { } /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplIfStmtSyntax(_ data: SyntaxData) { - let node = IfStmtSyntax(data) + private func visitImplIfExprSyntax(_ data: SyntaxData) { + let node = IfExprSyntax(data) let needsChildren = (visit(node) == .visitChildren) // Avoid calling into visitChildren if possible. if needsChildren && !node.raw.layoutView!.children.isEmpty { @@ -5614,8 +5637,8 @@ open class SyntaxVisitor { } /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplSwitchStmtSyntax(_ data: SyntaxData) { - let node = SwitchStmtSyntax(data) + private func visitImplSwitchExprSyntax(_ data: SyntaxData) { + let node = SwitchExprSyntax(data) let needsChildren = (visit(node) == .visitChildren) // Avoid calling into visitChildren if possible. if needsChildren && !node.raw.layoutView!.children.isEmpty { @@ -6217,6 +6240,8 @@ open class SyntaxVisitor { visitImplExpressionPatternSyntax(data) case .expressionSegment: visitImplExpressionSegmentSyntax(data) + case .expressionStmt: + visitImplExpressionStmtSyntax(data) case .extensionDecl: visitImplExtensionDeclSyntax(data) case .fallthroughStmt: @@ -6271,8 +6296,8 @@ open class SyntaxVisitor { visitImplIfConfigClauseSyntax(data) case .ifConfigDecl: visitImplIfConfigDeclSyntax(data) - case .ifStmt: - visitImplIfStmtSyntax(data) + case .ifExpr: + visitImplIfExprSyntax(data) case .implementsAttributeArguments: visitImplImplementsAttributeArgumentsSyntax(data) case .implicitlyUnwrappedOptionalType: @@ -6473,8 +6498,8 @@ open class SyntaxVisitor { visitImplSwitchCaseSyntax(data) case .switchDefaultLabel: visitImplSwitchDefaultLabelSyntax(data) - case .switchStmt: - visitImplSwitchStmtSyntax(data) + case .switchExpr: + visitImplSwitchExprSyntax(data) case .targetFunctionEntry: visitImplTargetFunctionEntrySyntax(data) case .ternaryExpr: diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift index 620efb42847..903da850a67 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift @@ -1228,6 +1228,248 @@ public enum SyntaxFactory { return BooleanLiteralExprSyntax(data) } } + @available(*, deprecated, message: "Use initializer on IfExprSyntax") + public static func makeIfExpr(_ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, ifKeyword: TokenSyntax, _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, conditions: ConditionElementListSyntax, _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, elseKeyword: TokenSyntax?, _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, elseBody: Syntax?, _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil) -> IfExprSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeIfKeyword?.raw, + ifKeyword.raw, + unexpectedBetweenIfKeywordAndConditions?.raw, + conditions.raw, + unexpectedBetweenConditionsAndBody?.raw, + body.raw, + unexpectedBetweenBodyAndElseKeyword?.raw, + elseKeyword?.raw, + unexpectedBetweenElseKeywordAndElseBody?.raw, + elseBody?.raw, + unexpectedAfterElseBody?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.ifExpr, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return IfExprSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on IfExprSyntax") + public static func makeBlankIfExpr(presence: SourcePresence = .present) -> IfExprSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .ifExpr, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.if), arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.conditionElementList, arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlock, arena: arena), + nil, + nil, + nil, + nil, + nil, + ], arena: arena)) + return IfExprSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchExprSyntax") + public static func makeSwitchExpr(_ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, switchKeyword: TokenSyntax, _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, leftBrace: TokenSyntax, _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, cases: SwitchCaseListSyntax, _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, rightBrace: TokenSyntax, _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil) -> SwitchExprSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeSwitchKeyword?.raw, + switchKeyword.raw, + unexpectedBetweenSwitchKeywordAndExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndCases?.raw, + cases.raw, + unexpectedBetweenCasesAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchExpr, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchExprSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchExprSyntax") + public static func makeBlankSwitchExpr(presence: SourcePresence = .present) -> SwitchExprSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchExpr, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.switch), arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.switchCaseList, arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena), + nil, + ], arena: arena)) + return SwitchExprSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") + public static func makeSwitchCaseList( + _ elements: [Syntax]) -> SwitchCaseListSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + from: elements.map { $0.raw }, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchCaseListSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") + public static func makeBlankSwitchCaseList(presence: SourcePresence = .present) -> SwitchCaseListSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseList, + from: [ + ], arena: arena)) + return SwitchCaseListSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") + public static func makeSwitchCase(_ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, unknownAttr: AttributeSyntax?, _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, label: Syntax, _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, statements: CodeBlockItemListSyntax, _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil) -> SwitchCaseSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeUnknownAttr?.raw, + unknownAttr?.raw, + unexpectedBetweenUnknownAttrAndLabel?.raw, + label.raw, + unexpectedBetweenLabelAndStatements?.raw, + statements.raw, + unexpectedAfterStatements?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCase, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchCaseSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") + public static func makeBlankSwitchCase(presence: SourcePresence = .present) -> SwitchCaseSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCase, + from: [ + nil, + nil, + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena), + nil, + ], arena: arena)) + return SwitchCaseSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") + public static func makeSwitchCaseLabel(_ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, caseKeyword: TokenSyntax, _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, caseItems: CaseItemListSyntax, _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchCaseLabelSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeCaseKeyword?.raw, + caseKeyword.raw, + unexpectedBetweenCaseKeywordAndCaseItems?.raw, + caseItems.raw, + unexpectedBetweenCaseItemsAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseLabel, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchCaseLabelSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") + public static func makeBlankSwitchCaseLabel(presence: SourcePresence = .present) -> SwitchCaseLabelSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseLabel, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.case), arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.caseItemList, arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), + nil, + ], arena: arena)) + return SwitchCaseLabelSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") + public static func makeSwitchDefaultLabel(_ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, defaultKeyword: TokenSyntax, _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchDefaultLabelSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeDefaultKeyword?.raw, + defaultKeyword.raw, + unexpectedBetweenDefaultKeywordAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchDefaultLabel, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchDefaultLabelSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") + public static func makeBlankSwitchDefaultLabel(presence: SourcePresence = .present) -> SwitchDefaultLabelSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchDefaultLabel, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.default), arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), + nil, + ], arena: arena)) + return SwitchDefaultLabelSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on CaseItemSyntax") + public static func makeCaseItem(_ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, pattern: PatternSyntax, _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, whereClause: WhereClauseSyntax?, _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> CaseItemSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndWhereClause?.raw, + whereClause?.raw, + unexpectedBetweenWhereClauseAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.caseItem, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return CaseItemSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on CaseItemSyntax") + public static func makeBlankCaseItem(presence: SourcePresence = .present) -> CaseItemSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .caseItem, + from: [ + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena), + nil, + nil, + nil, + nil, + nil, + ], arena: arena)) + return CaseItemSyntax(data) + } + } @available(*, deprecated, message: "Use initializer on UnresolvedTernaryExprSyntax") public static func makeUnresolvedTernaryExpr(_ unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? = nil, questionMark: TokenSyntax, _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, firstChoice: ExprSyntax, _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, colonMark: TokenSyntax, _ unexpectedAfterColonMark: UnexpectedNodesSyntax? = nil) -> UnresolvedTernaryExprSyntax { let layout: [RawSyntax?] = [ @@ -5939,6 +6181,33 @@ public enum SyntaxFactory { return LabeledStmtSyntax(data) } } + @available(*, deprecated, message: "Use initializer on ExpressionStmtSyntax") + public static func makeExpressionStmt(_ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil) -> ExpressionStmtSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedAfterExpression?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.expressionStmt, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return ExpressionStmtSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on ExpressionStmtSyntax") + public static func makeBlankExpressionStmt(presence: SourcePresence = .present) -> ExpressionStmtSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .expressionStmt, + from: [ + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena), + nil, + ], arena: arena)) + return ExpressionStmtSyntax(data) + } + } @available(*, deprecated, message: "Use initializer on ContinueStmtSyntax") public static func makeContinueStmt(_ unexpectedBeforeContinueKeyword: UnexpectedNodesSyntax? = nil, continueKeyword: TokenSyntax, _ unexpectedBetweenContinueKeywordAndLabel: UnexpectedNodesSyntax? = nil, label: TokenSyntax?, _ unexpectedAfterLabel: UnexpectedNodesSyntax? = nil) -> ContinueStmtSyntax { let layout: [RawSyntax?] = [ @@ -6036,26 +6305,6 @@ public enum SyntaxFactory { return DeferStmtSyntax(data) } } - @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") - public static func makeSwitchCaseList( - _ elements: [Syntax]) -> SwitchCaseListSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, - from: elements.map { $0.raw }, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchCaseListSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") - public static func makeBlankSwitchCaseList(presence: SourcePresence = .present) -> SwitchCaseListSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseList, - from: [ - ], arena: arena)) - return SwitchCaseListSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on RepeatWhileStmtSyntax") public static func makeRepeatWhileStmt(_ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, repeatKeyword: TokenSyntax, _ unexpectedBetweenRepeatKeywordAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedBetweenBodyAndWhileKeyword: UnexpectedNodesSyntax? = nil, whileKeyword: TokenSyntax, _ unexpectedBetweenWhileKeywordAndCondition: UnexpectedNodesSyntax? = nil, condition: ExprSyntax, _ unexpectedAfterCondition: UnexpectedNodesSyntax? = nil) -> RepeatWhileStmtSyntax { let layout: [RawSyntax?] = [ @@ -6228,49 +6477,6 @@ public enum SyntaxFactory { return ForInStmtSyntax(data) } } - @available(*, deprecated, message: "Use initializer on SwitchStmtSyntax") - public static func makeSwitchStmt(_ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, switchKeyword: TokenSyntax, _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, leftBrace: TokenSyntax, _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, cases: SwitchCaseListSyntax, _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, rightBrace: TokenSyntax, _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil) -> SwitchStmtSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeSwitchKeyword?.raw, - switchKeyword.raw, - unexpectedBetweenSwitchKeywordAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndCases?.raw, - cases.raw, - unexpectedBetweenCasesAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchStmt, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchStmtSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchStmtSyntax") - public static func makeBlankSwitchStmt(presence: SourcePresence = .present) -> SwitchStmtSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchStmt, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.switch), arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.switchCaseList, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena), - nil, - ], arena: arena)) - return SwitchStmtSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on CatchClauseListSyntax") public static func makeCatchClauseList( _ elements: [CatchClauseSyntax]) -> CatchClauseListSyntax { @@ -6759,150 +6965,6 @@ public enum SyntaxFactory { return ThrowStmtSyntax(data) } } - @available(*, deprecated, message: "Use initializer on IfStmtSyntax") - public static func makeIfStmt(_ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, ifKeyword: TokenSyntax, _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, conditions: ConditionElementListSyntax, _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, elseKeyword: TokenSyntax?, _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, elseBody: Syntax?, _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil) -> IfStmtSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeIfKeyword?.raw, - ifKeyword.raw, - unexpectedBetweenIfKeywordAndConditions?.raw, - conditions.raw, - unexpectedBetweenConditionsAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndElseKeyword?.raw, - elseKeyword?.raw, - unexpectedBetweenElseKeywordAndElseBody?.raw, - elseBody?.raw, - unexpectedAfterElseBody?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.ifStmt, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return IfStmtSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on IfStmtSyntax") - public static func makeBlankIfStmt(presence: SourcePresence = .present) -> IfStmtSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .ifStmt, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.if), arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.conditionElementList, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlock, arena: arena), - nil, - nil, - nil, - nil, - nil, - ], arena: arena)) - return IfStmtSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") - public static func makeSwitchCase(_ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, unknownAttr: AttributeSyntax?, _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, label: Syntax, _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, statements: CodeBlockItemListSyntax, _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil) -> SwitchCaseSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeUnknownAttr?.raw, - unknownAttr?.raw, - unexpectedBetweenUnknownAttrAndLabel?.raw, - label.raw, - unexpectedBetweenLabelAndStatements?.raw, - statements.raw, - unexpectedAfterStatements?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCase, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchCaseSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") - public static func makeBlankSwitchCase(presence: SourcePresence = .present) -> SwitchCaseSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCase, - from: [ - nil, - nil, - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena), - nil, - ], arena: arena)) - return SwitchCaseSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") - public static func makeSwitchDefaultLabel(_ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, defaultKeyword: TokenSyntax, _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchDefaultLabelSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeDefaultKeyword?.raw, - defaultKeyword.raw, - unexpectedBetweenDefaultKeywordAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchDefaultLabel, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchDefaultLabelSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") - public static func makeBlankSwitchDefaultLabel(presence: SourcePresence = .present) -> SwitchDefaultLabelSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchDefaultLabel, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.default), arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), - nil, - ], arena: arena)) - return SwitchDefaultLabelSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on CaseItemSyntax") - public static func makeCaseItem(_ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, pattern: PatternSyntax, _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, whereClause: WhereClauseSyntax?, _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> CaseItemSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.caseItem, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return CaseItemSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on CaseItemSyntax") - public static func makeBlankCaseItem(presence: SourcePresence = .present) -> CaseItemSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .caseItem, - from: [ - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena), - nil, - nil, - nil, - nil, - nil, - ], arena: arena)) - return CaseItemSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on CatchItemSyntax") public static func makeCatchItem(_ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, pattern: PatternSyntax?, _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, whereClause: WhereClauseSyntax?, _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> CatchItemSyntax { let layout: [RawSyntax?] = [ @@ -6938,41 +7000,6 @@ public enum SyntaxFactory { return CatchItemSyntax(data) } } - @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") - public static func makeSwitchCaseLabel(_ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, caseKeyword: TokenSyntax, _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, caseItems: CaseItemListSyntax, _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchCaseLabelSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndCaseItems?.raw, - caseItems.raw, - unexpectedBetweenCaseItemsAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseLabel, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchCaseLabelSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") - public static func makeBlankSwitchCaseLabel(presence: SourcePresence = .present) -> SwitchCaseLabelSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseLabel, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.case), arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.caseItemList, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), - nil, - ], arena: arena)) - return SwitchCaseLabelSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on CatchClauseSyntax") public static func makeCatchClause(_ unexpectedBeforeCatchKeyword: UnexpectedNodesSyntax? = nil, catchKeyword: TokenSyntax, _ unexpectedBetweenCatchKeywordAndCatchItems: UnexpectedNodesSyntax? = nil, catchItems: CatchItemListSyntax?, _ unexpectedBetweenCatchItemsAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil) -> CatchClauseSyntax { let layout: [RawSyntax?] = [ diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift index bfa21312ae8..e9357be9e89 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift @@ -331,6 +331,55 @@ open class SyntaxRewriter { return ExprSyntax(visitChildren(node)) } + /// Visit a `IfExprSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IfExprSyntax) -> ExprSyntax { + return ExprSyntax(visitChildren(node)) + } + + /// Visit a `SwitchExprSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchExprSyntax) -> ExprSyntax { + return ExprSyntax(visitChildren(node)) + } + + /// Visit a `SwitchCaseListSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseListSyntax) -> SwitchCaseListSyntax { + return Syntax(visitChildren(node)).cast(SwitchCaseListSyntax.self) + } + + /// Visit a `SwitchCaseSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseSyntax) -> SwitchCaseSyntax { + return Syntax(visitChildren(node)).cast(SwitchCaseSyntax.self) + } + + /// Visit a `SwitchCaseLabelSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseLabelSyntax) -> SwitchCaseLabelSyntax { + return Syntax(visitChildren(node)).cast(SwitchCaseLabelSyntax.self) + } + + /// Visit a `SwitchDefaultLabelSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchDefaultLabelSyntax) -> SwitchDefaultLabelSyntax { + return Syntax(visitChildren(node)).cast(SwitchDefaultLabelSyntax.self) + } + + /// Visit a `CaseItemSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CaseItemSyntax) -> CaseItemSyntax { + return Syntax(visitChildren(node)).cast(CaseItemSyntax.self) + } + /// Visit a `UnresolvedTernaryExprSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1269,6 +1318,13 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node)) } + /// Visit a `ExpressionStmtSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExpressionStmtSyntax) -> StmtSyntax { + return StmtSyntax(visitChildren(node)) + } + /// Visit a `ContinueStmtSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1290,13 +1346,6 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node)) } - /// Visit a `SwitchCaseListSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: SwitchCaseListSyntax) -> SwitchCaseListSyntax { - return Syntax(visitChildren(node)).cast(SwitchCaseListSyntax.self) - } - /// Visit a `RepeatWhileStmtSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1325,13 +1374,6 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node)) } - /// Visit a `SwitchStmtSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: SwitchStmtSyntax) -> StmtSyntax { - return StmtSyntax(visitChildren(node)) - } - /// Visit a `CatchClauseListSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1444,34 +1486,6 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node)) } - /// Visit a `IfStmtSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: IfStmtSyntax) -> StmtSyntax { - return StmtSyntax(visitChildren(node)) - } - - /// Visit a `SwitchCaseSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: SwitchCaseSyntax) -> SwitchCaseSyntax { - return Syntax(visitChildren(node)).cast(SwitchCaseSyntax.self) - } - - /// Visit a `SwitchDefaultLabelSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: SwitchDefaultLabelSyntax) -> SwitchDefaultLabelSyntax { - return Syntax(visitChildren(node)).cast(SwitchDefaultLabelSyntax.self) - } - - /// Visit a `CaseItemSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: CaseItemSyntax) -> CaseItemSyntax { - return Syntax(visitChildren(node)).cast(CaseItemSyntax.self) - } - /// Visit a `CatchItemSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -1479,13 +1493,6 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(CatchItemSyntax.self) } - /// Visit a `SwitchCaseLabelSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: SwitchCaseLabelSyntax) -> SwitchCaseLabelSyntax { - return Syntax(visitChildren(node)).cast(SwitchCaseLabelSyntax.self) - } - /// Visit a `CatchClauseSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2357,6 +2364,76 @@ open class SyntaxRewriter { return Syntax(visit(node)) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplIfExprSyntax(_ data: SyntaxData) -> Syntax { + let node = IfExprSyntax(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 visitImplSwitchExprSyntax(_ data: SyntaxData) -> Syntax { + let node = SwitchExprSyntax(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 visitImplSwitchCaseListSyntax(_ data: SyntaxData) -> Syntax { + let node = SwitchCaseListSyntax(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 visitImplSwitchCaseSyntax(_ data: SyntaxData) -> Syntax { + let node = SwitchCaseSyntax(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 visitImplSwitchCaseLabelSyntax(_ data: SyntaxData) -> Syntax { + let node = SwitchCaseLabelSyntax(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 visitImplSwitchDefaultLabelSyntax(_ data: SyntaxData) -> Syntax { + let node = SwitchDefaultLabelSyntax(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 visitImplCaseItemSyntax(_ data: SyntaxData) -> Syntax { + let node = CaseItemSyntax(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 visitImplUnresolvedTernaryExprSyntax(_ data: SyntaxData) -> Syntax { let node = UnresolvedTernaryExprSyntax(data) @@ -3698,8 +3775,8 @@ open class SyntaxRewriter { } /// Implementation detail of visit(_:). Do not call directly. - private func visitImplContinueStmtSyntax(_ data: SyntaxData) -> Syntax { - let node = ContinueStmtSyntax(data) + private func visitImplExpressionStmtSyntax(_ data: SyntaxData) -> Syntax { + let node = ExpressionStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) defer { visitPost(node._syntaxNode) } @@ -3708,8 +3785,8 @@ open class SyntaxRewriter { } /// Implementation detail of visit(_:). Do not call directly. - private func visitImplWhileStmtSyntax(_ data: SyntaxData) -> Syntax { - let node = WhileStmtSyntax(data) + private func visitImplContinueStmtSyntax(_ data: SyntaxData) -> Syntax { + let node = ContinueStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) defer { visitPost(node._syntaxNode) } @@ -3718,8 +3795,8 @@ open class SyntaxRewriter { } /// Implementation detail of visit(_:). Do not call directly. - private func visitImplDeferStmtSyntax(_ data: SyntaxData) -> Syntax { - let node = DeferStmtSyntax(data) + private func visitImplWhileStmtSyntax(_ data: SyntaxData) -> Syntax { + let node = WhileStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) defer { visitPost(node._syntaxNode) } @@ -3728,8 +3805,8 @@ open class SyntaxRewriter { } /// Implementation detail of visit(_:). Do not call directly. - private func visitImplSwitchCaseListSyntax(_ data: SyntaxData) -> Syntax { - let node = SwitchCaseListSyntax(data) + private func visitImplDeferStmtSyntax(_ data: SyntaxData) -> Syntax { + let node = DeferStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) defer { visitPost(node._syntaxNode) } @@ -3777,16 +3854,6 @@ open class SyntaxRewriter { return Syntax(visit(node)) } - /// Implementation detail of visit(_:). Do not call directly. - private func visitImplSwitchStmtSyntax(_ data: SyntaxData) -> Syntax { - let node = SwitchStmtSyntax(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 visitImplCatchClauseListSyntax(_ data: SyntaxData) -> Syntax { let node = CatchClauseListSyntax(data) @@ -3947,46 +4014,6 @@ open class SyntaxRewriter { return Syntax(visit(node)) } - /// Implementation detail of visit(_:). Do not call directly. - private func visitImplIfStmtSyntax(_ data: SyntaxData) -> Syntax { - let node = IfStmtSyntax(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 visitImplSwitchCaseSyntax(_ data: SyntaxData) -> Syntax { - let node = SwitchCaseSyntax(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 visitImplSwitchDefaultLabelSyntax(_ data: SyntaxData) -> Syntax { - let node = SwitchDefaultLabelSyntax(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 visitImplCaseItemSyntax(_ data: SyntaxData) -> Syntax { - let node = CaseItemSyntax(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 visitImplCatchItemSyntax(_ data: SyntaxData) -> Syntax { let node = CatchItemSyntax(data) @@ -3997,16 +4024,6 @@ open class SyntaxRewriter { return Syntax(visit(node)) } - /// Implementation detail of visit(_:). Do not call directly. - private func visitImplSwitchCaseLabelSyntax(_ data: SyntaxData) -> Syntax { - let node = SwitchCaseLabelSyntax(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 visitImplCatchClauseSyntax(_ data: SyntaxData) -> Syntax { let node = CatchClauseSyntax(data) @@ -4645,6 +4662,20 @@ open class SyntaxRewriter { return visitImplIntegerLiteralExprSyntax case .booleanLiteralExpr: return visitImplBooleanLiteralExprSyntax + case .ifExpr: + return visitImplIfExprSyntax + case .switchExpr: + return visitImplSwitchExprSyntax + case .switchCaseList: + return visitImplSwitchCaseListSyntax + case .switchCase: + return visitImplSwitchCaseSyntax + case .switchCaseLabel: + return visitImplSwitchCaseLabelSyntax + case .switchDefaultLabel: + return visitImplSwitchDefaultLabelSyntax + case .caseItem: + return visitImplCaseItemSyntax case .unresolvedTernaryExpr: return visitImplUnresolvedTernaryExprSyntax case .ternaryExpr: @@ -4913,14 +4944,14 @@ open class SyntaxRewriter { return visitImplDocumentationAttributeArgumentsSyntax case .labeledStmt: return visitImplLabeledStmtSyntax + case .expressionStmt: + return visitImplExpressionStmtSyntax case .continueStmt: return visitImplContinueStmtSyntax case .whileStmt: return visitImplWhileStmtSyntax case .deferStmt: return visitImplDeferStmtSyntax - case .switchCaseList: - return visitImplSwitchCaseListSyntax case .repeatWhileStmt: return visitImplRepeatWhileStmtSyntax case .guardStmt: @@ -4929,8 +4960,6 @@ open class SyntaxRewriter { return visitImplWhereClauseSyntax case .forInStmt: return visitImplForInStmtSyntax - case .switchStmt: - return visitImplSwitchStmtSyntax case .catchClauseList: return visitImplCatchClauseListSyntax case .doStmt: @@ -4963,18 +4992,8 @@ open class SyntaxRewriter { return visitImplConditionElementListSyntax case .throwStmt: return visitImplThrowStmtSyntax - case .ifStmt: - return visitImplIfStmtSyntax - case .switchCase: - return visitImplSwitchCaseSyntax - case .switchDefaultLabel: - return visitImplSwitchDefaultLabelSyntax - case .caseItem: - return visitImplCaseItemSyntax case .catchItem: return visitImplCatchItemSyntax - case .switchCaseLabel: - return visitImplSwitchCaseLabelSyntax case .catchClause: return visitImplCatchClauseSyntax case .poundAssertStmt: @@ -5178,6 +5197,20 @@ open class SyntaxRewriter { return visitImplIntegerLiteralExprSyntax(data) case .booleanLiteralExpr: return visitImplBooleanLiteralExprSyntax(data) + case .ifExpr: + return visitImplIfExprSyntax(data) + case .switchExpr: + return visitImplSwitchExprSyntax(data) + case .switchCaseList: + return visitImplSwitchCaseListSyntax(data) + case .switchCase: + return visitImplSwitchCaseSyntax(data) + case .switchCaseLabel: + return visitImplSwitchCaseLabelSyntax(data) + case .switchDefaultLabel: + return visitImplSwitchDefaultLabelSyntax(data) + case .caseItem: + return visitImplCaseItemSyntax(data) case .unresolvedTernaryExpr: return visitImplUnresolvedTernaryExprSyntax(data) case .ternaryExpr: @@ -5446,14 +5479,14 @@ open class SyntaxRewriter { return visitImplDocumentationAttributeArgumentsSyntax(data) case .labeledStmt: return visitImplLabeledStmtSyntax(data) + case .expressionStmt: + return visitImplExpressionStmtSyntax(data) case .continueStmt: return visitImplContinueStmtSyntax(data) case .whileStmt: return visitImplWhileStmtSyntax(data) case .deferStmt: return visitImplDeferStmtSyntax(data) - case .switchCaseList: - return visitImplSwitchCaseListSyntax(data) case .repeatWhileStmt: return visitImplRepeatWhileStmtSyntax(data) case .guardStmt: @@ -5462,8 +5495,6 @@ open class SyntaxRewriter { return visitImplWhereClauseSyntax(data) case .forInStmt: return visitImplForInStmtSyntax(data) - case .switchStmt: - return visitImplSwitchStmtSyntax(data) case .catchClauseList: return visitImplCatchClauseListSyntax(data) case .doStmt: @@ -5496,18 +5527,8 @@ open class SyntaxRewriter { return visitImplConditionElementListSyntax(data) case .throwStmt: return visitImplThrowStmtSyntax(data) - case .ifStmt: - return visitImplIfStmtSyntax(data) - case .switchCase: - return visitImplSwitchCaseSyntax(data) - case .switchDefaultLabel: - return visitImplSwitchDefaultLabelSyntax(data) - case .caseItem: - return visitImplCaseItemSyntax(data) case .catchItem: return visitImplCatchItemSyntax(data) - case .switchCaseLabel: - return visitImplSwitchCaseLabelSyntax(data) case .catchClause: return visitImplCatchClauseSyntax(data) case .poundAssertStmt: diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift index ca9fa47852c..cc739b609bc 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift @@ -4324,6 +4324,776 @@ extension BooleanLiteralExprSyntax: CustomReflectable { } } +// MARK: - IfExprSyntax + +public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public enum ElseBody: SyntaxChildChoices { + case `ifExpr`(IfExprSyntax) + case `codeBlock`(CodeBlockSyntax) + public var _syntaxNode: Syntax { + switch self { + case .ifExpr(let node): return node._syntaxNode + case .codeBlock(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: IfExprSyntax) { + self = .ifExpr(node) + } + public init(_ node: CodeBlockSyntax) { + self = .codeBlock(node) + } + public init?(_ node: S) { + if let node = node.as(IfExprSyntax.self) { + self = .ifExpr(node) + return + } + if let node = node.as(CodeBlockSyntax.self) { + self = .codeBlock(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(IfExprSyntax.self), + .node(CodeBlockSyntax.self), + ]) + } + } + + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .ifExpr else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `IfExprSyntax` 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) { + assert(data.raw.kind == .ifExpr) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, + ifKeyword: TokenSyntax = .keyword(.if), + _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, + conditions: ConditionElementListSyntax, + _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, + elseKeyword: TokenSyntax? = nil, + _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, + elseBody: ElseBody? = nil, + _ unexpectedAfterElseBody: 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(), (unexpectedBeforeIfKeyword, ifKeyword, unexpectedBetweenIfKeywordAndConditions, conditions, unexpectedBetweenConditionsAndBody, body, unexpectedBetweenBodyAndElseKeyword, elseKeyword, unexpectedBetweenElseKeywordAndElseBody, elseBody, unexpectedAfterElseBody))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeIfKeyword?.raw, + ifKeyword.raw, + unexpectedBetweenIfKeywordAndConditions?.raw, + conditions.raw, + unexpectedBetweenConditionsAndBody?.raw, + body.raw, + unexpectedBetweenBodyAndElseKeyword?.raw, + elseKeyword?.raw, + unexpectedBetweenElseKeywordAndElseBody?.raw, + elseBody?.raw, + unexpectedAfterElseBody?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.ifExpr, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 0, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBeforeIfKeyword(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBeforeIfKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeIfKeyword` to replace the node's + /// current `unexpectedBeforeIfKeyword`, if present. + public func withUnexpectedBeforeIfKeyword(_ newChild: UnexpectedNodesSyntax?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var ifKeyword: TokenSyntax { + get { + let childData = data.child(at: 1, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withIfKeyword(value) + } + } + + /// Returns a copy of the receiver with its `ifKeyword` replaced. + /// - param newChild: The new `ifKeyword` to replace the node's + /// current `ifKeyword`, if present. + public func withIfKeyword(_ newChild: TokenSyntax) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 2, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenIfKeywordAndConditions(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenIfKeywordAndConditions` replaced. + /// - param newChild: The new `unexpectedBetweenIfKeywordAndConditions` to replace the node's + /// current `unexpectedBetweenIfKeywordAndConditions`, if present. + public func withUnexpectedBetweenIfKeywordAndConditions(_ newChild: UnexpectedNodesSyntax?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var conditions: ConditionElementListSyntax { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + return ConditionElementListSyntax(childData!) + } + set(value) { + self = withConditions(value) + } + } + + /// Adds the provided `Condition` to the node's `conditions` + /// collection. + /// - param element: The new `Condition` to add to the node's + /// `conditions` collection. + /// - returns: A copy of the receiver with the provided `Condition` + /// appended to its `conditions` collection. + public func addCondition(_ element: ConditionElementSyntax) -> IfExprSyntax { + 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.conditionElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return IfExprSyntax(newData) + } + + /// Returns a copy of the receiver with its `conditions` replaced. + /// - param newChild: The new `conditions` to replace the node's + /// current `conditions`, if present. + public func withConditions(_ newChild: ConditionElementListSyntax) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenConditionsAndBody(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenConditionsAndBody` replaced. + /// - param newChild: The new `unexpectedBetweenConditionsAndBody` to replace the node's + /// current `unexpectedBetweenConditionsAndBody`, if present. + public func withUnexpectedBetweenConditionsAndBody(_ newChild: UnexpectedNodesSyntax?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var body: CodeBlockSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return CodeBlockSyntax(childData!) + } + set(value) { + self = withBody(value) + } + } + + /// Returns a copy of the receiver with its `body` replaced. + /// - param newChild: The new `body` to replace the node's + /// current `body`, if present. + public func withBody(_ newChild: CodeBlockSyntax) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenBodyAndElseKeyword(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenBodyAndElseKeyword` replaced. + /// - param newChild: The new `unexpectedBetweenBodyAndElseKeyword` to replace the node's + /// current `unexpectedBetweenBodyAndElseKeyword`, if present. + public func withUnexpectedBetweenBodyAndElseKeyword(_ newChild: UnexpectedNodesSyntax?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var elseKeyword: TokenSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withElseKeyword(value) + } + } + + /// Returns a copy of the receiver with its `elseKeyword` replaced. + /// - param newChild: The new `elseKeyword` to replace the node's + /// current `elseKeyword`, if present. + public func withElseKeyword(_ newChild: TokenSyntax?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenElseKeywordAndElseBody(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenElseKeywordAndElseBody` replaced. + /// - param newChild: The new `unexpectedBetweenElseKeywordAndElseBody` to replace the node's + /// current `unexpectedBetweenElseKeywordAndElseBody`, if present. + public func withUnexpectedBetweenElseKeywordAndElseBody(_ newChild: UnexpectedNodesSyntax?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var elseBody: ElseBody? { + get { + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return ElseBody(childData!) + } + set(value) { + self = withElseBody(value) + } + } + + /// Returns a copy of the receiver with its `elseBody` replaced. + /// - param newChild: The new `elseBody` to replace the node's + /// current `elseBody`, if present. + public func withElseBody(_ newChild: ElseBody?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public var unexpectedAfterElseBody: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 10, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterElseBody(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterElseBody` replaced. + /// - param newChild: The new `unexpectedAfterElseBody` to replace the node's + /// current `unexpectedAfterElseBody`, if present. + public func withUnexpectedAfterElseBody(_ newChild: UnexpectedNodesSyntax?) -> IfExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return IfExprSyntax(newData) + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeIfKeyword, + \Self.ifKeyword, + \Self.unexpectedBetweenIfKeywordAndConditions, + \Self.conditions, + \Self.unexpectedBetweenConditionsAndBody, + \Self.body, + \Self.unexpectedBetweenBodyAndElseKeyword, + \Self.elseKeyword, + \Self.unexpectedBetweenElseKeywordAndElseBody, + \Self.elseBody, + \Self.unexpectedAfterElseBody, + ]) + } + + 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 + case 5: + return "body" + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return "else body" + case 10: + return nil + default: + fatalError("Invalid index") + } + } +} + +extension IfExprSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeIfKeyword": unexpectedBeforeIfKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "ifKeyword": Syntax(ifKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenIfKeywordAndConditions": unexpectedBetweenIfKeywordAndConditions.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "conditions": Syntax(conditions).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenConditionsAndBody": unexpectedBetweenConditionsAndBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "body": Syntax(body).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenBodyAndElseKeyword": unexpectedBetweenBodyAndElseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "elseKeyword": elseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenElseKeywordAndElseBody": unexpectedBetweenElseKeywordAndElseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "elseBody": elseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterElseBody": unexpectedAfterElseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + +// MARK: - SwitchExprSyntax + +public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .switchExpr else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `SwitchExprSyntax` 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) { + assert(data.raw.kind == .switchExpr) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, + switchKeyword: TokenSyntax = .keyword(.switch), + _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, + cases: SwitchCaseListSyntax, + _ unexpectedBetweenCasesAndRightBrace: 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(), (unexpectedBeforeSwitchKeyword, switchKeyword, unexpectedBetweenSwitchKeywordAndExpression, expression, unexpectedBetweenExpressionAndLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndCases, cases, unexpectedBetweenCasesAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeSwitchKeyword?.raw, + switchKeyword.raw, + unexpectedBetweenSwitchKeywordAndExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndCases?.raw, + cases.raw, + unexpectedBetweenCasesAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.switchExpr, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 0, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBeforeSwitchKeyword(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBeforeSwitchKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeSwitchKeyword` to replace the node's + /// current `unexpectedBeforeSwitchKeyword`, if present. + public func withUnexpectedBeforeSwitchKeyword(_ newChild: UnexpectedNodesSyntax?) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var switchKeyword: TokenSyntax { + get { + let childData = data.child(at: 1, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withSwitchKeyword(value) + } + } + + /// Returns a copy of the receiver with its `switchKeyword` replaced. + /// - param newChild: The new `switchKeyword` to replace the node's + /// current `switchKeyword`, if present. + public func withSwitchKeyword(_ newChild: TokenSyntax) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 2, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenSwitchKeywordAndExpression(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenSwitchKeywordAndExpression` replaced. + /// - param newChild: The new `unexpectedBetweenSwitchKeywordAndExpression` to replace the node's + /// current `unexpectedBetweenSwitchKeywordAndExpression`, if present. + public func withUnexpectedBetweenSwitchKeywordAndExpression(_ newChild: UnexpectedNodesSyntax?) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var expression: ExprSyntax { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + return ExprSyntax(childData!) + } + set(value) { + self = withExpression(value) + } + } + + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenExpressionAndLeftBrace(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndLeftBrace` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndLeftBrace` to replace the node's + /// current `unexpectedBetweenExpressionAndLeftBrace`, if present. + public func withUnexpectedBetweenExpressionAndLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var leftBrace: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withLeftBrace(value) + } + } + + /// Returns a copy of the receiver with its `leftBrace` replaced. + /// - param newChild: The new `leftBrace` to replace the node's + /// current `leftBrace`, if present. + public func withLeftBrace(_ newChild: TokenSyntax) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenLeftBraceAndCases(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndCases` replaced. + /// - param newChild: The new `unexpectedBetweenLeftBraceAndCases` to replace the node's + /// current `unexpectedBetweenLeftBraceAndCases`, if present. + public func withUnexpectedBetweenLeftBraceAndCases(_ newChild: UnexpectedNodesSyntax?) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var cases: SwitchCaseListSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return SwitchCaseListSyntax(childData!) + } + set(value) { + self = withCases(value) + } + } + + /// Adds the provided `Case` to the node's `cases` + /// collection. + /// - param element: The new `Case` to add to the node's + /// `cases` collection. + /// - returns: A copy of the receiver with the provided `Case` + /// appended to its `cases` collection. + public func addCase(_ element: Syntax) -> SwitchExprSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[7] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 7, with: collection, arena: arena) + return SwitchExprSyntax(newData) + } + + /// Returns a copy of the receiver with its `cases` replaced. + /// - param newChild: The new `cases` to replace the node's + /// current `cases`, if present. + public func withCases(_ newChild: SwitchCaseListSyntax) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenCasesAndRightBrace(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenCasesAndRightBrace` replaced. + /// - param newChild: The new `unexpectedBetweenCasesAndRightBrace` to replace the node's + /// current `unexpectedBetweenCasesAndRightBrace`, if present. + public func withUnexpectedBetweenCasesAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var rightBrace: TokenSyntax { + get { + let childData = data.child(at: 9, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withRightBrace(value) + } + } + + /// Returns a copy of the receiver with its `rightBrace` replaced. + /// - param newChild: The new `rightBrace` to replace the node's + /// current `rightBrace`, if present. + public func withRightBrace(_ newChild: TokenSyntax) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 10, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightBrace(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. + /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's + /// current `unexpectedAfterRightBrace`, if present. + public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> SwitchExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return SwitchExprSyntax(newData) + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeSwitchKeyword, + \Self.switchKeyword, + \Self.unexpectedBetweenSwitchKeywordAndExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndCases, + \Self.cases, + \Self.unexpectedBetweenCasesAndRightBrace, + \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 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 SwitchExprSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeSwitchKeyword": unexpectedBeforeSwitchKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "switchKeyword": Syntax(switchKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenSwitchKeywordAndExpression": unexpectedBetweenSwitchKeywordAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndLeftBrace": unexpectedBetweenExpressionAndLeftBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftBrace": Syntax(leftBrace).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftBraceAndCases": unexpectedBetweenLeftBraceAndCases.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "cases": Syntax(cases).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCasesAndRightBrace": unexpectedBetweenCasesAndRightBrace.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: - UnresolvedTernaryExprSyntax public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift index 3033f4abc4d..726c15c9039 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift @@ -1891,326 +1891,265 @@ extension DictionaryElementSyntax: CustomReflectable { } } -// MARK: - ClosureCaptureItemSyntax +// MARK: - SwitchCaseSyntax + +public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { + public enum Label: SyntaxChildChoices { + case `default`(SwitchDefaultLabelSyntax) + case `case`(SwitchCaseLabelSyntax) + public var _syntaxNode: Syntax { + switch self { + case .default(let node): return node._syntaxNode + case .case(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: SwitchDefaultLabelSyntax) { + self = .default(node) + } + public init(_ node: SwitchCaseLabelSyntax) { + self = .case(node) + } + public init?(_ node: S) { + if let node = node.as(SwitchDefaultLabelSyntax.self) { + self = .default(node) + return + } + if let node = node.as(SwitchCaseLabelSyntax.self) { + self = .case(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(SwitchDefaultLabelSyntax.self), + .node(SwitchCaseLabelSyntax.self), + ]) + } + } -public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureItem else { return nil } + guard node.raw.kind == .switchCase else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureCaptureItemSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `SwitchCaseSyntax` 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) { - assert(data.raw.kind == .closureCaptureItem) + assert(data.raw.kind == .switchCase) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: TokenListSyntax? = nil, - _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax? = nil, - _ unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? = nil, - assignToken: TokenSyntax? = nil, - _ unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, + unknownAttr: AttributeSyntax? = nil, + _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, + label: Label, + _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedAfterStatements: 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(), (unexpectedBeforeSpecifier, specifier, unexpectedBetweenSpecifierAndName, name, unexpectedBetweenNameAndAssignToken, assignToken, unexpectedBetweenAssignTokenAndExpression, expression, unexpectedBetweenExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeUnknownAttr, unknownAttr, unexpectedBetweenUnknownAttrAndLabel, label, unexpectedBetweenLabelAndStatements, statements, unexpectedAfterStatements))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifier?.raw, - specifier?.raw, - unexpectedBetweenSpecifierAndName?.raw, - name?.raw, - unexpectedBetweenNameAndAssignToken?.raw, - assignToken?.raw, - unexpectedBetweenAssignTokenAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeUnknownAttr?.raw, + unknownAttr?.raw, + unexpectedBetweenUnknownAttrAndLabel?.raw, + label.raw, + unexpectedBetweenLabelAndStatements?.raw, + statements.raw, + unexpectedAfterStatements?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureItem, from: layout, arena: arena, + kind: SyntaxKind.switchCase, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeSpecifier(value) + self = withUnexpectedBeforeUnknownAttr(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeSpecifier` replaced. - /// - param newChild: The new `unexpectedBeforeSpecifier` to replace the node's - /// current `unexpectedBeforeSpecifier`, if present. - public func withUnexpectedBeforeSpecifier(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeUnknownAttr` replaced. + /// - param newChild: The new `unexpectedBeforeUnknownAttr` to replace the node's + /// current `unexpectedBeforeUnknownAttr`, if present. + public func withUnexpectedBeforeUnknownAttr(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) + return SwitchCaseSyntax(newData) } - public var specifier: TokenListSyntax? { + public var unknownAttr: AttributeSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) if childData == nil { return nil } - return TokenListSyntax(childData!) + return AttributeSyntax(childData!) } set(value) { - self = withSpecifier(value) - } - } - - /// Adds the provided `SpecifierToken` to the node's `specifier` - /// collection. - /// - param element: The new `SpecifierToken` to add to the node's - /// `specifier` collection. - /// - returns: A copy of the receiver with the provided `SpecifierToken` - /// appended to its `specifier` collection. - public func addSpecifierToken(_ element: TokenSyntax) -> ClosureCaptureItemSyntax { - 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.tokenList, - from: [element.raw], arena: arena) + self = withUnknownAttr(value) } - let newData = data.replacingChild(at: 1, with: collection, arena: arena) - return ClosureCaptureItemSyntax(newData) } - /// Returns a copy of the receiver with its `specifier` replaced. - /// - param newChild: The new `specifier` to replace the node's - /// current `specifier`, if present. - public func withSpecifier(_ newChild: TokenListSyntax?) -> ClosureCaptureItemSyntax { + /// Returns a copy of the receiver with its `unknownAttr` replaced. + /// - param newChild: The new `unknownAttr` to replace the node's + /// current `unknownAttr`, if present. + public func withUnknownAttr(_ newChild: AttributeSyntax?) -> SwitchCaseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) + return SwitchCaseSyntax(newData) } - public var unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenSpecifierAndName(value) + self = withUnexpectedBetweenUnknownAttrAndLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenSpecifierAndName` replaced. - /// - param newChild: The new `unexpectedBetweenSpecifierAndName` to replace the node's - /// current `unexpectedBetweenSpecifierAndName`, if present. - public func withUnexpectedBetweenSpecifierAndName(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenUnknownAttrAndLabel` replaced. + /// - param newChild: The new `unexpectedBetweenUnknownAttrAndLabel` to replace the node's + /// current `unexpectedBetweenUnknownAttrAndLabel`, if present. + public func withUnexpectedBetweenUnknownAttrAndLabel(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) + return SwitchCaseSyntax(newData) } - public var name: TokenSyntax? { + public var label: Label { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return Label(childData!) } set(value) { - self = withName(value) + self = withLabel(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax { + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel(_ newChild: Label) -> SwitchCaseSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) + return SwitchCaseSyntax(newData) } - public var unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndAssignToken(value) + self = withUnexpectedBetweenLabelAndStatements(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndAssignToken` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndAssignToken` to replace the node's - /// current `unexpectedBetweenNameAndAssignToken`, if present. - public func withUnexpectedBetweenNameAndAssignToken(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndStatements` replaced. + /// - param newChild: The new `unexpectedBetweenLabelAndStatements` to replace the node's + /// current `unexpectedBetweenLabelAndStatements`, if present. + public func withUnexpectedBetweenLabelAndStatements(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) + return SwitchCaseSyntax(newData) } - public var assignToken: TokenSyntax? { + public var statements: CodeBlockItemListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return CodeBlockItemListSyntax(childData!) } set(value) { - self = withAssignToken(value) + self = withStatements(value) } } - /// Returns a copy of the receiver with its `assignToken` replaced. - /// - param newChild: The new `assignToken` to replace the node's - /// current `assignToken`, if present. - public func withAssignToken(_ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax { + /// 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) -> SwitchCaseSyntax { + var collection: RawSyntax let arena = SyntaxArena() - let raw = newChild?.raw + if let col = raw.layoutView!.children[5] { + 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: 5, with: collection, arena: arena) + return SwitchCaseSyntax(newData) + } + + /// Returns a copy of the receiver with its `statements` replaced. + /// - param newChild: The new `statements` to replace the node's + /// current `statements`, if present. + public func withStatements(_ newChild: CodeBlockItemListSyntax) -> SwitchCaseSyntax { + let arena = SyntaxArena() + let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) + return SwitchCaseSyntax(newData) } - public var unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? { + public var unexpectedAfterStatements: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAssignTokenAndExpression(value) + self = withUnexpectedAfterStatements(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAssignTokenAndExpression` replaced. - /// - param newChild: The new `unexpectedBetweenAssignTokenAndExpression` to replace the node's - /// current `unexpectedBetweenAssignTokenAndExpression`, if present. - public func withUnexpectedBetweenAssignTokenAndExpression(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterStatements` replaced. + /// - param newChild: The new `unexpectedAfterStatements` to replace the node's + /// current `unexpectedAfterStatements`, if present. + public func withUnexpectedAfterStatements(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) + return SwitchCaseSyntax(newData) } - public var expression: ExprSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withExpression(value) - } - } - - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax) -> ClosureCaptureItemSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) - } - - public var unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenExpressionAndTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndTrailingComma` to replace the node's - /// current `unexpectedBetweenExpressionAndTrailingComma`, if present. - public func withUnexpectedBetweenExpressionAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) - } - - public var trailingComma: TokenSyntax? { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) - } - - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 10, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return ClosureCaptureItemSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeSpecifier, - \Self.specifier, - \Self.unexpectedBetweenSpecifierAndName, - \Self.name, - \Self.unexpectedBetweenNameAndAssignToken, - \Self.assignToken, - \Self.unexpectedBetweenAssignTokenAndExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, - ]) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeUnknownAttr, + \Self.unknownAttr, + \Self.unexpectedBetweenUnknownAttrAndLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndStatements, + \Self.statements, + \Self.unexpectedAfterStatements, + ]) } public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { @@ -2222,267 +2161,254 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "label" 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 ClosureCaptureItemSyntax: CustomReflectable { +extension SwitchCaseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeSpecifier": unexpectedBeforeSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "specifier": specifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenSpecifierAndName": unexpectedBetweenSpecifierAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "name": name.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenNameAndAssignToken": unexpectedBetweenNameAndAssignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "assignToken": assignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAssignTokenAndExpression": unexpectedBetweenAssignTokenAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenExpressionAndTrailingComma": unexpectedBetweenExpressionAndTrailingComma.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, + "unexpectedBeforeUnknownAttr": unexpectedBeforeUnknownAttr.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unknownAttr": unknownAttr.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenUnknownAttrAndLabel": unexpectedBetweenUnknownAttrAndLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "label": Syntax(label).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLabelAndStatements": unexpectedBetweenLabelAndStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), + "unexpectedAfterStatements": unexpectedAfterStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ClosureCaptureSignatureSyntax +// MARK: - SwitchCaseLabelSyntax -public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { +public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureSignature else { return nil } + guard node.raw.kind == .switchCaseLabel else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureCaptureSignatureSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `SwitchCaseLabelSyntax` 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) { - assert(data.raw.kind == .closureCaptureSignature) + assert(data.raw.kind == .switchCaseLabel) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, - leftSquare: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? = nil, - items: ClosureCaptureItemListSyntax? = nil, - _ unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? = nil, - rightSquare: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .keyword(.case), + _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, + caseItems: CaseItemListSyntax, + _ unexpectedBetweenCaseItemsAndColon: 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(), (unexpectedBeforeLeftSquare, leftSquare, unexpectedBetweenLeftSquareAndItems, items, unexpectedBetweenItemsAndRightSquare, rightSquare, unexpectedAfterRightSquare))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndCaseItems, caseItems, unexpectedBetweenCaseItemsAndColon, colon, unexpectedAfterColon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndItems?.raw, - items?.raw, - unexpectedBetweenItemsAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw, + unexpectedBeforeCaseKeyword?.raw, + caseKeyword.raw, + unexpectedBetweenCaseKeywordAndCaseItems?.raw, + caseItems.raw, + unexpectedBetweenCaseItemsAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureSignature, from: layout, arena: arena, + kind: SyntaxKind.switchCaseLabel, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftSquare(value) + self = withUnexpectedBeforeCaseKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftSquare` replaced. - /// - param newChild: The new `unexpectedBeforeLeftSquare` to replace the node's - /// current `unexpectedBeforeLeftSquare`, if present. - public func withUnexpectedBeforeLeftSquare(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeCaseKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeCaseKeyword` to replace the node's + /// current `unexpectedBeforeCaseKeyword`, if present. + public func withUnexpectedBeforeCaseKeyword(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } - public var leftSquare: TokenSyntax { + public var caseKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftSquare(value) + self = withCaseKeyword(value) } } - /// Returns a copy of the receiver with its `leftSquare` replaced. - /// - param newChild: The new `leftSquare` to replace the node's - /// current `leftSquare`, if present. - public func withLeftSquare(_ newChild: TokenSyntax) -> ClosureCaptureSignatureSyntax { + /// Returns a copy of the receiver with its `caseKeyword` replaced. + /// - param newChild: The new `caseKeyword` to replace the node's + /// current `caseKeyword`, if present. + public func withCaseKeyword(_ newChild: TokenSyntax) -> SwitchCaseLabelSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } - public var unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftSquareAndItems(value) + self = withUnexpectedBetweenCaseKeywordAndCaseItems(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftSquareAndItems` replaced. - /// - param newChild: The new `unexpectedBetweenLeftSquareAndItems` to replace the node's - /// current `unexpectedBetweenLeftSquareAndItems`, if present. - public func withUnexpectedBetweenLeftSquareAndItems(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCaseKeywordAndCaseItems` replaced. + /// - param newChild: The new `unexpectedBetweenCaseKeywordAndCaseItems` to replace the node's + /// current `unexpectedBetweenCaseKeywordAndCaseItems`, if present. + public func withUnexpectedBetweenCaseKeywordAndCaseItems(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } - public var items: ClosureCaptureItemListSyntax? { + public var caseItems: CaseItemListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return ClosureCaptureItemListSyntax(childData!) + return CaseItemListSyntax(childData!) } set(value) { - self = withItems(value) + self = withCaseItems(value) } } - /// Adds the provided `Item` to the node's `items` + /// Adds the provided `CaseItem` to the node's `caseItems` /// collection. - /// - param element: The new `Item` to add to the node's - /// `items` collection. - /// - returns: A copy of the receiver with the provided `Item` - /// appended to its `items` collection. - public func addItem(_ element: ClosureCaptureItemSyntax) -> ClosureCaptureSignatureSyntax { + /// - param element: The new `CaseItem` to add to the node's + /// `caseItems` collection. + /// - returns: A copy of the receiver with the provided `CaseItem` + /// appended to its `caseItems` collection. + public func addCaseItem(_ element: CaseItemSyntax) -> SwitchCaseLabelSyntax { 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.closureCaptureItemList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.caseItemList, from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } - /// Returns a copy of the receiver with its `items` replaced. - /// - param newChild: The new `items` to replace the node's - /// current `items`, if present. - public func withItems(_ newChild: ClosureCaptureItemListSyntax?) -> ClosureCaptureSignatureSyntax { + /// Returns a copy of the receiver with its `caseItems` replaced. + /// - param newChild: The new `caseItems` to replace the node's + /// current `caseItems`, if present. + public func withCaseItems(_ newChild: CaseItemListSyntax) -> SwitchCaseLabelSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } - public var unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenItemsAndRightSquare(value) + self = withUnexpectedBetweenCaseItemsAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenItemsAndRightSquare` replaced. - /// - param newChild: The new `unexpectedBetweenItemsAndRightSquare` to replace the node's - /// current `unexpectedBetweenItemsAndRightSquare`, if present. - public func withUnexpectedBetweenItemsAndRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCaseItemsAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenCaseItemsAndColon` to replace the node's + /// current `unexpectedBetweenCaseItemsAndColon`, if present. + public func withUnexpectedBetweenCaseItemsAndColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } - public var rightSquare: TokenSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withRightSquare(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `rightSquare` replaced. - /// - param newChild: The new `rightSquare` to replace the node's - /// current `rightSquare`, if present. - public func withRightSquare(_ newChild: TokenSyntax) -> ClosureCaptureSignatureSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> SwitchCaseLabelSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } - public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { + public var unexpectedAfterColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightSquare(value) + self = withUnexpectedAfterColon(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightSquare` replaced. - /// - param newChild: The new `unexpectedAfterRightSquare` to replace the node's - /// current `unexpectedAfterRightSquare`, if present. - public func withUnexpectedAfterRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterColon` replaced. + /// - param newChild: The new `unexpectedAfterColon` to replace the node's + /// current `unexpectedAfterColon`, if present. + public func withUnexpectedAfterColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ClosureCaptureSignatureSyntax(newData) + return SwitchCaseLabelSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftSquare, - \Self.leftSquare, - \Self.unexpectedBetweenLeftSquareAndItems, - \Self.items, - \Self.unexpectedBetweenItemsAndRightSquare, - \Self.rightSquare, - \Self.unexpectedAfterRightSquare, + \Self.unexpectedBeforeCaseKeyword, + \Self.caseKeyword, + \Self.unexpectedBetweenCaseKeywordAndCaseItems, + \Self.caseItems, + \Self.unexpectedBetweenCaseItemsAndColon, + \Self.colon, + \Self.unexpectedAfterColon, ]) } @@ -2508,176 +2434,175 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { } } -extension ClosureCaptureSignatureSyntax: CustomReflectable { +extension SwitchCaseLabelSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeftSquare": unexpectedBeforeLeftSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftSquare": Syntax(leftSquare).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftSquareAndItems": unexpectedBetweenLeftSquareAndItems.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "items": items.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenItemsAndRightSquare": unexpectedBetweenItemsAndRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightSquare": Syntax(rightSquare).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightSquare": unexpectedAfterRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeCaseKeyword": unexpectedBeforeCaseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "caseKeyword": Syntax(caseKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCaseKeywordAndCaseItems": unexpectedBetweenCaseKeywordAndCaseItems.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "caseItems": Syntax(caseItems).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCaseItemsAndColon": unexpectedBetweenCaseItemsAndColon.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: - ClosureParamSyntax +// MARK: - SwitchDefaultLabelSyntax -public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { +public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureParam else { return nil } + guard node.raw.kind == .switchDefaultLabel else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureParamSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `SwitchDefaultLabelSyntax` 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) { - assert(data.raw.kind == .closureParam) + assert(data.raw.kind == .switchDefaultLabel) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, + defaultKeyword: TokenSyntax = .keyword(.default), + _ unexpectedBetweenDefaultKeywordAndColon: 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(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDefaultKeyword, defaultKeyword, unexpectedBetweenDefaultKeywordAndColon, colon, unexpectedAfterColon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeDefaultKeyword?.raw, + defaultKeyword.raw, + unexpectedBetweenDefaultKeywordAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureParam, from: layout, arena: arena, + kind: SyntaxKind.switchDefaultLabel, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeName(value) + self = withUnexpectedBeforeDefaultKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. - /// - param newChild: The new `unexpectedBeforeName` to replace the node's - /// current `unexpectedBeforeName`, if present. - public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> ClosureParamSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeDefaultKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeDefaultKeyword` to replace the node's + /// current `unexpectedBeforeDefaultKeyword`, if present. + public func withUnexpectedBeforeDefaultKeyword(_ newChild: UnexpectedNodesSyntax?) -> SwitchDefaultLabelSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ClosureParamSyntax(newData) + return SwitchDefaultLabelSyntax(newData) } - public var name: TokenSyntax { + public var defaultKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withDefaultKeyword(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax) -> ClosureParamSyntax { + /// Returns a copy of the receiver with its `defaultKeyword` replaced. + /// - param newChild: The new `defaultKeyword` to replace the node's + /// current `defaultKeyword`, if present. + public func withDefaultKeyword(_ newChild: TokenSyntax) -> SwitchDefaultLabelSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ClosureParamSyntax(newData) + return SwitchDefaultLabelSyntax(newData) } - public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndTrailingComma(value) + self = withUnexpectedBetweenDefaultKeywordAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndTrailingComma` to replace the node's - /// current `unexpectedBetweenNameAndTrailingComma`, if present. - public func withUnexpectedBetweenNameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureParamSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDefaultKeywordAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenDefaultKeywordAndColon` to replace the node's + /// current `unexpectedBetweenDefaultKeywordAndColon`, if present. + public func withUnexpectedBetweenDefaultKeywordAndColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchDefaultLabelSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ClosureParamSyntax(newData) + return SwitchDefaultLabelSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> ClosureParamSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> SwitchDefaultLabelSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ClosureParamSyntax(newData) + return SwitchDefaultLabelSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedAfterColon(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureParamSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterColon` replaced. + /// - param newChild: The new `unexpectedAfterColon` to replace the node's + /// current `unexpectedAfterColon`, if present. + public func withUnexpectedAfterColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchDefaultLabelSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ClosureParamSyntax(newData) + return SwitchDefaultLabelSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeDefaultKeyword, + \Self.defaultKeyword, + \Self.unexpectedBetweenDefaultKeywordAndColon, + \Self.colon, + \Self.unexpectedAfterColon, ]) } @@ -2686,7 +2611,7 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: @@ -2699,734 +2624,580 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { } } -extension ClosureParamSyntax: CustomReflectable { +extension SwitchDefaultLabelSyntax: 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), - "unexpectedBetweenNameAndTrailingComma": unexpectedBetweenNameAndTrailingComma.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, + "unexpectedBeforeDefaultKeyword": unexpectedBeforeDefaultKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "defaultKeyword": Syntax(defaultKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDefaultKeywordAndColon": unexpectedBetweenDefaultKeywordAndColon.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: - ClosureSignatureSyntax - -public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { - public enum Input: SyntaxChildChoices { - case `simpleInput`(ClosureParamListSyntax) - case `input`(ParameterClauseSyntax) - 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: ParameterClauseSyntax) { - self = .input(node) - } - public init?(_ node: S) { - if let node = node.as(ClosureParamListSyntax.self) { - self = .simpleInput(node) - return - } - if let node = node.as(ParameterClauseSyntax.self) { - self = .input(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(ClosureParamListSyntax.self), - .node(ParameterClauseSyntax.self), - ]) - } - } +// MARK: - CaseItemSyntax +public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureSignature else { return nil } + guard node.raw.kind == .caseItem else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureSignatureSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `CaseItemSyntax` 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) { - assert(data.raw.kind == .closureSignature) + assert(data.raw.kind == .caseItem) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? = nil, - capture: ClosureCaptureSignatureSyntax? = nil, - _ unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? = nil, - input: Input? = nil, - _ unexpectedBetweenInputAndAsyncKeyword: UnexpectedNodesSyntax? = nil, - asyncKeyword: TokenSyntax? = nil, - _ unexpectedBetweenAsyncKeywordAndThrowsTok: UnexpectedNodesSyntax? = nil, - throwsTok: TokenSyntax? = nil, - _ unexpectedBetweenThrowsTokAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax? = nil, - _ unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? = nil, - inTok: TokenSyntax = .keyword(.in), - _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndTrailingComma: 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, unexpectedBetweenAttributesAndCapture, capture, unexpectedBetweenCaptureAndInput, input, unexpectedBetweenInputAndAsyncKeyword, asyncKeyword, unexpectedBetweenAsyncKeywordAndThrowsTok, throwsTok, unexpectedBetweenThrowsTokAndOutput, output, unexpectedBetweenOutputAndInTok, inTok, unexpectedAfterInTok))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndWhereClause, whereClause, unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes?.raw, - unexpectedBetweenAttributesAndCapture?.raw, - capture?.raw, - unexpectedBetweenCaptureAndInput?.raw, - input?.raw, - unexpectedBetweenInputAndAsyncKeyword?.raw, - asyncKeyword?.raw, - unexpectedBetweenAsyncKeywordAndThrowsTok?.raw, - throwsTok?.raw, - unexpectedBetweenThrowsTokAndOutput?.raw, - output?.raw, - unexpectedBetweenOutputAndInTok?.raw, - inTok.raw, - unexpectedAfterInTok?.raw, + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndWhereClause?.raw, + whereClause?.raw, + unexpectedBetweenWhereClauseAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureSignature, from: layout, arena: arena, + kind: SyntaxKind.caseItem, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + public var unexpectedBeforePattern: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeAttributes(value) + self = withUnexpectedBeforePattern(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeAttributes` replaced. - /// - param newChild: The new `unexpectedBeforeAttributes` to replace the node's - /// current `unexpectedBeforeAttributes`, if present. - public func withUnexpectedBeforeAttributes(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. + /// - param newChild: The new `unexpectedBeforePattern` to replace the node's + /// current `unexpectedBeforePattern`, if present. + public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + return CaseItemSyntax(newData) } - public var attributes: AttributeListSyntax? { + public var pattern: PatternSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } - return AttributeListSyntax(childData!) + return PatternSyntax(childData!) } set(value) { - self = withAttributes(value) - } - } - - /// 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 = withPattern(value) } - let newData = data.replacingChild(at: 1, with: collection, arena: arena) - return ClosureSignatureSyntax(newData) } - /// Returns a copy of the receiver with its `attributes` replaced. - /// - param newChild: The new `attributes` to replace the node's - /// current `attributes`, if present. - public func withAttributes(_ newChild: AttributeListSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `pattern` replaced. + /// - param newChild: The new `pattern` to replace the node's + /// current `pattern`, if present. + public func withPattern(_ newChild: PatternSyntax) -> CaseItemSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + return CaseItemSyntax(newData) } - public var unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAttributesAndCapture(value) + self = withUnexpectedBetweenPatternAndWhereClause(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAttributesAndCapture` replaced. - /// - param newChild: The new `unexpectedBetweenAttributesAndCapture` to replace the node's - /// current `unexpectedBetweenAttributesAndCapture`, if present. - public func withUnexpectedBetweenAttributesAndCapture(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndWhereClause` replaced. + /// - param newChild: The new `unexpectedBetweenPatternAndWhereClause` to replace the node's + /// current `unexpectedBetweenPatternAndWhereClause`, if present. + public func withUnexpectedBetweenPatternAndWhereClause(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + return CaseItemSyntax(newData) } - public var capture: ClosureCaptureSignatureSyntax? { + public var whereClause: WhereClauseSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return ClosureCaptureSignatureSyntax(childData!) + return WhereClauseSyntax(childData!) } set(value) { - self = withCapture(value) + self = withWhereClause(value) } } - /// Returns a copy of the receiver with its `capture` replaced. - /// - param newChild: The new `capture` to replace the node's - /// current `capture`, if present. - public func withCapture(_ newChild: ClosureCaptureSignatureSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `whereClause` replaced. + /// - param newChild: The new `whereClause` to replace the node's + /// current `whereClause`, if present. + public func withWhereClause(_ newChild: WhereClauseSyntax?) -> CaseItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + return CaseItemSyntax(newData) } - public var unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? { + public var unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCaptureAndInput(value) + self = withUnexpectedBetweenWhereClauseAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCaptureAndInput` replaced. - /// - param newChild: The new `unexpectedBetweenCaptureAndInput` to replace the node's - /// current `unexpectedBetweenCaptureAndInput`, if present. - public func withUnexpectedBetweenCaptureAndInput(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenWhereClauseAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenWhereClauseAndTrailingComma` to replace the node's + /// current `unexpectedBetweenWhereClauseAndTrailingComma`, if present. + public func withUnexpectedBetweenWhereClauseAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + return CaseItemSyntax(newData) } - public var input: Input? { + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) if childData == nil { return nil } - return Input(childData!) + return TokenSyntax(childData!) } set(value) { - self = withInput(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `input` replaced. - /// - param newChild: The new `input` to replace the node's - /// current `input`, if present. - public func withInput(_ newChild: Input?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> CaseItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + return CaseItemSyntax(newData) } - public var unexpectedBetweenInputAndAsyncKeyword: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenInputAndAsyncKeyword(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenInputAndAsyncKeyword` replaced. - /// - param newChild: The new `unexpectedBetweenInputAndAsyncKeyword` to replace the node's - /// current `unexpectedBetweenInputAndAsyncKeyword`, if present. - public func withUnexpectedBetweenInputAndAsyncKeyword(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) - } - - public var asyncKeyword: TokenSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withAsyncKeyword(value) - } + return CaseItemSyntax(newData) } - /// Returns a copy of the receiver with its `asyncKeyword` replaced. - /// - param newChild: The new `asyncKeyword` to replace the node's - /// current `asyncKeyword`, if present. - public func withAsyncKeyword(_ newChild: TokenSyntax?) -> ClosureSignatureSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforePattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndWhereClause, + \Self.whereClause, + \Self.unexpectedBetweenWhereClauseAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, + ]) } - public var unexpectedBetweenAsyncKeywordAndThrowsTok: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenAsyncKeywordAndThrowsTok(value) + 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 + case 5: + return nil + case 6: + return nil + default: + fatalError("Invalid index") } } +} - /// Returns a copy of the receiver with its `unexpectedBetweenAsyncKeywordAndThrowsTok` replaced. - /// - param newChild: The new `unexpectedBetweenAsyncKeywordAndThrowsTok` to replace the node's - /// current `unexpectedBetweenAsyncKeywordAndThrowsTok`, if present. - public func withUnexpectedBetweenAsyncKeywordAndThrowsTok(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) +extension CaseItemSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPatternAndWhereClause": unexpectedBetweenPatternAndWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "whereClause": whereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenWhereClauseAndTrailingComma": unexpectedBetweenWhereClauseAndTrailingComma.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, + ]) } +} - public var throwsTok: TokenSyntax? { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withThrowsTok(value) - } +// MARK: - ClosureCaptureItemSyntax + +public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .closureCaptureItem else { return nil } + self._syntaxNode = node._syntaxNode } - /// Returns a copy of the receiver with its `throwsTok` replaced. - /// - param newChild: The new `throwsTok` to replace the node's - /// current `throwsTok`, if present. - public func withThrowsTok(_ newChild: TokenSyntax?) -> ClosureSignatureSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + /// Creates a `ClosureCaptureItemSyntax` 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) { + assert(data.raw.kind == .closureCaptureItem) + self._syntaxNode = Syntax(data) } - public var unexpectedBetweenThrowsTokAndOutput: UnexpectedNodesSyntax? { + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, + specifier: TokenListSyntax? = nil, + _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax? = nil, + _ unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? = nil, + assignToken: TokenSyntax? = nil, + _ unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndTrailingComma: 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(), (unexpectedBeforeSpecifier, specifier, unexpectedBetweenSpecifierAndName, name, unexpectedBetweenNameAndAssignToken, assignToken, unexpectedBetweenAssignTokenAndExpression, expression, unexpectedBetweenExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeSpecifier?.raw, + specifier?.raw, + unexpectedBetweenSpecifierAndName?.raw, + name?.raw, + unexpectedBetweenNameAndAssignToken?.raw, + assignToken?.raw, + unexpectedBetweenAssignTokenAndExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.closureCaptureItem, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenThrowsTokAndOutput(value) + self = withUnexpectedBeforeSpecifier(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenThrowsTokAndOutput` replaced. - /// - param newChild: The new `unexpectedBetweenThrowsTokAndOutput` to replace the node's - /// current `unexpectedBetweenThrowsTokAndOutput`, if present. - public func withUnexpectedBetweenThrowsTokAndOutput(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeSpecifier` replaced. + /// - param newChild: The new `unexpectedBeforeSpecifier` to replace the node's + /// current `unexpectedBeforeSpecifier`, if present. + public func withUnexpectedBeforeSpecifier(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var output: ReturnClauseSyntax? { + public var specifier: TokenListSyntax? { get { - let childData = data.child(at: 11, parent: Syntax(self)) + let childData = data.child(at: 1, parent: Syntax(self)) if childData == nil { return nil } - return ReturnClauseSyntax(childData!) + return TokenListSyntax(childData!) } set(value) { - self = withOutput(value) + self = withSpecifier(value) } } - /// Returns a copy of the receiver with its `output` replaced. - /// - param newChild: The new `output` to replace the node's - /// current `output`, if present. - public func withOutput(_ newChild: ReturnClauseSyntax?) -> ClosureSignatureSyntax { + /// Adds the provided `SpecifierToken` to the node's `specifier` + /// collection. + /// - param element: The new `SpecifierToken` to add to the node's + /// `specifier` collection. + /// - returns: A copy of the receiver with the provided `SpecifierToken` + /// appended to its `specifier` collection. + public func addSpecifierToken(_ element: TokenSyntax) -> ClosureCaptureItemSyntax { + 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.tokenList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return ClosureCaptureItemSyntax(newData) + } + + /// Returns a copy of the receiver with its `specifier` replaced. + /// - param newChild: The new `specifier` to replace the node's + /// current `specifier`, if present. + public func withSpecifier(_ newChild: TokenListSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 11, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? { + public var unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 12, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenOutputAndInTok(value) + self = withUnexpectedBetweenSpecifierAndName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenOutputAndInTok` replaced. - /// - param newChild: The new `unexpectedBetweenOutputAndInTok` to replace the node's - /// current `unexpectedBetweenOutputAndInTok`, if present. - public func withUnexpectedBetweenOutputAndInTok(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenSpecifierAndName` replaced. + /// - param newChild: The new `unexpectedBetweenSpecifierAndName` to replace the node's + /// current `unexpectedBetweenSpecifierAndName`, if present. + public func withUnexpectedBetweenSpecifierAndName(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 12, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var inTok: TokenSyntax { + public var name: TokenSyntax? { get { - let childData = data.child(at: 13, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withInTok(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `inTok` replaced. - /// - param newChild: The new `inTok` to replace the node's - /// current `inTok`, if present. - public func withInTok(_ newChild: TokenSyntax) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 13, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var unexpectedAfterInTok: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 14, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterInTok(value) + self = withUnexpectedBetweenNameAndAssignToken(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterInTok` replaced. - /// - param newChild: The new `unexpectedAfterInTok` to replace the node's - /// current `unexpectedAfterInTok`, if present. - public func withUnexpectedAfterInTok(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndAssignToken` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndAssignToken` to replace the node's + /// current `unexpectedBetweenNameAndAssignToken`, if present. + public func withUnexpectedBetweenNameAndAssignToken(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 14, with: raw, arena: arena) - return ClosureSignatureSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndCapture, - \Self.capture, - \Self.unexpectedBetweenCaptureAndInput, - \Self.input, - \Self.unexpectedBetweenInputAndAsyncKeyword, - \Self.asyncKeyword, - \Self.unexpectedBetweenAsyncKeywordAndThrowsTok, - \Self.throwsTok, - \Self.unexpectedBetweenThrowsTokAndOutput, - \Self.output, - \Self.unexpectedBetweenOutputAndInTok, - \Self.inTok, - \Self.unexpectedAfterInTok, - ]) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - 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 - case 13: - return nil - case 14: - return nil - default: - fatalError("Invalid index") + public var assignToken: TokenSyntax? { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withAssignToken(value) } } -} -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, - "unexpectedBetweenInputAndAsyncKeyword": unexpectedBetweenInputAndAsyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "asyncKeyword": asyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAsyncKeywordAndThrowsTok": unexpectedBetweenAsyncKeywordAndThrowsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "throwsTok": throwsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenThrowsTokAndOutput": unexpectedBetweenThrowsTokAndOutput.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, - ]) + /// Returns a copy of the receiver with its `assignToken` replaced. + /// - param newChild: The new `assignToken` to replace the node's + /// current `assignToken`, if present. + public func withAssignToken(_ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } -} -// MARK: - MultipleTrailingClosureElementSyntax + public var unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenAssignTokenAndExpression(value) + } + } -public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .multipleTrailingClosureElement else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `MultipleTrailingClosureElementSyntax` 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) { - assert(data.raw.kind == .multipleTrailingClosureElement) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? = nil, - closure: ClosureExprSyntax, - _ unexpectedAfterClosure: 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, unexpectedBetweenColonAndClosure, closure, unexpectedAfterClosure))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndClosure?.raw, - closure.raw, - unexpectedAfterClosure?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.multipleTrailingClosureElement, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeLabel(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. - /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's - /// current `unexpectedBeforeLabel`, if present. - public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAssignTokenAndExpression` replaced. + /// - param newChild: The new `unexpectedBetweenAssignTokenAndExpression` to replace the node's + /// current `unexpectedBetweenAssignTokenAndExpression`, if present. + public func withUnexpectedBetweenAssignTokenAndExpression(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var label: TokenSyntax { + public var expression: ExprSyntax { get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 7, parent: Syntax(self)) + return ExprSyntax(childData!) } set(value) { - self = withLabel(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `label` replaced. - /// - param newChild: The new `label` to replace the node's - /// current `label`, if present. - public func withLabel(_ newChild: TokenSyntax) -> MultipleTrailingClosureElementSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLabelAndColon(value) + self = withUnexpectedBetweenExpressionAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's - /// current `unexpectedBetweenLabelAndColon`, if present. - public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndTrailingComma` to replace the node's + /// current `unexpectedBetweenExpressionAndTrailingComma`, if present. + public func withUnexpectedBetweenExpressionAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) - } - - public var colon: TokenSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withColon(value) - } - } - - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> MultipleTrailingClosureElementSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? { + public var trailingComma: TokenSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 9, parent: Syntax(self)) if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndClosure(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndClosure` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndClosure` to replace the node's - /// current `unexpectedBetweenColonAndClosure`, if present. - public func withUnexpectedBetweenColonAndClosure(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) - } - - public var closure: ClosureExprSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return ClosureExprSyntax(childData!) - } - set(value) { - self = withClosure(value) - } - } - - /// Returns a copy of the receiver with its `closure` replaced. - /// - param newChild: The new `closure` to replace the node's - /// current `closure`, if present. - public func withClosure(_ newChild: ClosureExprSyntax) -> MultipleTrailingClosureElementSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } - public var unexpectedAfterClosure: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterClosure(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterClosure` replaced. - /// - param newChild: The new `unexpectedAfterClosure` to replace the node's - /// current `unexpectedAfterClosure`, if present. - public func withUnexpectedAfterClosure(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return ClosureCaptureItemSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndClosure, - \Self.closure, - \Self.unexpectedAfterClosure, + \Self.unexpectedBeforeSpecifier, + \Self.specifier, + \Self.unexpectedBetweenSpecifierAndName, + \Self.name, + \Self.unexpectedBetweenNameAndAssignToken, + \Self.assignToken, + \Self.unexpectedBetweenAssignTokenAndExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -3435,7 +3206,7 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -3446,134 +3217,260 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab 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 MultipleTrailingClosureElementSyntax: CustomReflectable { +extension ClosureCaptureItemSyntax: 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), - "unexpectedBetweenColonAndClosure": unexpectedBetweenColonAndClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "closure": Syntax(closure).asProtocol(SyntaxProtocol.self), - "unexpectedAfterClosure": unexpectedAfterClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeSpecifier": unexpectedBeforeSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "specifier": specifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenSpecifierAndName": unexpectedBetweenSpecifierAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": name.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenNameAndAssignToken": unexpectedBetweenNameAndAssignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "assignToken": assignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenAssignTokenAndExpression": unexpectedBetweenAssignTokenAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndTrailingComma": unexpectedBetweenExpressionAndTrailingComma.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: - StringSegmentSyntax +// MARK: - ClosureCaptureSignatureSyntax -public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { +public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .stringSegment else { return nil } + guard node.raw.kind == .closureCaptureSignature else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `StringSegmentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ClosureCaptureSignatureSyntax` 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) { - assert(data.raw.kind == .stringSegment) + assert(data.raw.kind == .closureCaptureSignature) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeContent: UnexpectedNodesSyntax? = nil, - content: TokenSyntax, - _ unexpectedAfterContent: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? = nil, + items: ClosureCaptureItemListSyntax? = nil, + _ unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightSquare: 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(), (unexpectedBeforeContent, content, unexpectedAfterContent))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftSquare, leftSquare, unexpectedBetweenLeftSquareAndItems, items, unexpectedBetweenItemsAndRightSquare, rightSquare, unexpectedAfterRightSquare))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeContent?.raw, - content.raw, - unexpectedAfterContent?.raw, + unexpectedBeforeLeftSquare?.raw, + leftSquare.raw, + unexpectedBetweenLeftSquareAndItems?.raw, + items?.raw, + unexpectedBetweenItemsAndRightSquare?.raw, + rightSquare.raw, + unexpectedAfterRightSquare?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.stringSegment, from: layout, arena: arena, + kind: SyntaxKind.closureCaptureSignature, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeContent: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeContent(value) + self = withUnexpectedBeforeLeftSquare(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeContent` replaced. - /// - param newChild: The new `unexpectedBeforeContent` to replace the node's - /// current `unexpectedBeforeContent`, if present. - public func withUnexpectedBeforeContent(_ newChild: UnexpectedNodesSyntax?) -> StringSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftSquare` replaced. + /// - param newChild: The new `unexpectedBeforeLeftSquare` to replace the node's + /// current `unexpectedBeforeLeftSquare`, if present. + public func withUnexpectedBeforeLeftSquare(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return StringSegmentSyntax(newData) + return ClosureCaptureSignatureSyntax(newData) } - public var content: TokenSyntax { + public var leftSquare: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withContent(value) + self = withLeftSquare(value) } } - /// Returns a copy of the receiver with its `content` replaced. - /// - param newChild: The new `content` to replace the node's - /// current `content`, if present. - public func withContent(_ newChild: TokenSyntax) -> StringSegmentSyntax { + /// Returns a copy of the receiver with its `leftSquare` replaced. + /// - param newChild: The new `leftSquare` to replace the node's + /// current `leftSquare`, if present. + public func withLeftSquare(_ newChild: TokenSyntax) -> ClosureCaptureSignatureSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return StringSegmentSyntax(newData) + return ClosureCaptureSignatureSyntax(newData) } - public var unexpectedAfterContent: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterContent(value) + self = withUnexpectedBetweenLeftSquareAndItems(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterContent` replaced. - /// - param newChild: The new `unexpectedAfterContent` to replace the node's - /// current `unexpectedAfterContent`, if present. - public func withUnexpectedAfterContent(_ newChild: UnexpectedNodesSyntax?) -> StringSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftSquareAndItems` replaced. + /// - param newChild: The new `unexpectedBetweenLeftSquareAndItems` to replace the node's + /// current `unexpectedBetweenLeftSquareAndItems`, if present. + public func withUnexpectedBetweenLeftSquareAndItems(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return StringSegmentSyntax(newData) + return ClosureCaptureSignatureSyntax(newData) + } + + public var items: ClosureCaptureItemListSyntax? { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return ClosureCaptureItemListSyntax(childData!) + } + set(value) { + self = withItems(value) + } + } + + /// Adds the provided `Item` to the node's `items` + /// collection. + /// - param element: The new `Item` to add to the node's + /// `items` collection. + /// - returns: A copy of the receiver with the provided `Item` + /// appended to its `items` collection. + public func addItem(_ element: ClosureCaptureItemSyntax) -> ClosureCaptureSignatureSyntax { + 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.closureCaptureItemList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return ClosureCaptureSignatureSyntax(newData) + } + + /// Returns a copy of the receiver with its `items` replaced. + /// - param newChild: The new `items` to replace the node's + /// current `items`, if present. + public func withItems(_ newChild: ClosureCaptureItemListSyntax?) -> ClosureCaptureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ClosureCaptureSignatureSyntax(newData) + } + + public var unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenItemsAndRightSquare(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenItemsAndRightSquare` replaced. + /// - param newChild: The new `unexpectedBetweenItemsAndRightSquare` to replace the node's + /// current `unexpectedBetweenItemsAndRightSquare`, if present. + public func withUnexpectedBetweenItemsAndRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ClosureCaptureSignatureSyntax(newData) + } + + public var rightSquare: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withRightSquare(value) + } + } + + /// Returns a copy of the receiver with its `rightSquare` replaced. + /// - param newChild: The new `rightSquare` to replace the node's + /// current `rightSquare`, if present. + public func withRightSquare(_ newChild: TokenSyntax) -> ClosureCaptureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return ClosureCaptureSignatureSyntax(newData) + } + + public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightSquare(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightSquare` replaced. + /// - param newChild: The new `unexpectedAfterRightSquare` to replace the node's + /// current `unexpectedAfterRightSquare`, if present. + public func withUnexpectedAfterRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ClosureCaptureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return ClosureCaptureSignatureSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeContent, - \Self.content, - \Self.unexpectedAfterContent, + \Self.unexpectedBeforeLeftSquare, + \Self.leftSquare, + \Self.unexpectedBetweenLeftSquareAndItems, + \Self.items, + \Self.unexpectedBetweenItemsAndRightSquare, + \Self.rightSquare, + \Self.unexpectedAfterRightSquare, ]) } @@ -3585,591 +3482,674 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { return nil case 2: return nil + case 3: + return nil + case 4: + return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension StringSegmentSyntax: CustomReflectable { +extension ClosureCaptureSignatureSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeContent": unexpectedBeforeContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "content": Syntax(content).asProtocol(SyntaxProtocol.self), - "unexpectedAfterContent": unexpectedAfterContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLeftSquare": unexpectedBeforeLeftSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftSquare": Syntax(leftSquare).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftSquareAndItems": unexpectedBetweenLeftSquareAndItems.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "items": items.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenItemsAndRightSquare": unexpectedBetweenItemsAndRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightSquare": Syntax(rightSquare).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightSquare": unexpectedAfterRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ExpressionSegmentSyntax +// MARK: - ClosureParamSyntax -public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { +public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .expressionSegment else { return nil } + guard node.raw.kind == .closureParam else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ExpressionSegmentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ClosureParamSyntax` 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) { - assert(data.raw.kind == .expressionSegment) + assert(data.raw.kind == .closureParam) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, - backslash: TokenSyntax = .backslashToken(), - _ unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? = nil, - delimiter: TokenSyntax? = nil, - _ unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? = nil, - expressions: TupleExprElementListSyntax, - _ unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: 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(), (unexpectedBeforeBackslash, backslash, unexpectedBetweenBackslashAndDelimiter, delimiter, unexpectedBetweenDelimiterAndLeftParen, leftParen, unexpectedBetweenLeftParenAndExpressions, expressions, unexpectedBetweenExpressionsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeBackslash?.raw, - backslash.raw, - unexpectedBetweenBackslashAndDelimiter?.raw, - delimiter?.raw, - unexpectedBetweenDelimiterAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndExpressions?.raw, - expressions.raw, - unexpectedBetweenExpressionsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.expressionSegment, from: layout, arena: arena, + kind: SyntaxKind.closureParam, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeBackslash(value) + self = withUnexpectedBeforeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeBackslash` replaced. - /// - param newChild: The new `unexpectedBeforeBackslash` to replace the node's - /// current `unexpectedBeforeBackslash`, if present. - public func withUnexpectedBeforeBackslash(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. + /// - param newChild: The new `unexpectedBeforeName` to replace the node's + /// current `unexpectedBeforeName`, if present. + public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> ClosureParamSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + return ClosureParamSyntax(newData) } - public var backslash: TokenSyntax { + public var name: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withBackslash(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `backslash` replaced. - /// - param newChild: The new `backslash` to replace the node's - /// current `backslash`, if present. - public func withBackslash(_ newChild: TokenSyntax) -> ExpressionSegmentSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax) -> ClosureParamSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return ClosureParamSyntax(newData) } - public var unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenBackslashAndDelimiter(value) + self = withUnexpectedBetweenNameAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenBackslashAndDelimiter` replaced. - /// - param newChild: The new `unexpectedBetweenBackslashAndDelimiter` to replace the node's - /// current `unexpectedBetweenBackslashAndDelimiter`, if present. - public func withUnexpectedBetweenBackslashAndDelimiter(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndTrailingComma` to replace the node's + /// current `unexpectedBetweenNameAndTrailingComma`, if present. + public func withUnexpectedBetweenNameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureParamSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + return ClosureParamSyntax(newData) } - public var delimiter: TokenSyntax? { + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withDelimiter(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `delimiter` replaced. - /// - param newChild: The new `delimiter` to replace the node's - /// current `delimiter`, if present. - public func withDelimiter(_ newChild: TokenSyntax?) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> ClosureParamSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + return ClosureParamSyntax(newData) } - public var unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDelimiterAndLeftParen(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDelimiterAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenDelimiterAndLeftParen` to replace the node's - /// current `unexpectedBetweenDelimiterAndLeftParen`, if present. - public func withUnexpectedBetweenDelimiterAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ClosureParamSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + return ClosureParamSyntax(newData) } - public var leftParen: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return "name" + case 2: + return nil + case 3: + return nil + case 4: + return nil + default: + fatalError("Invalid index") } - set(value) { - self = withLeftParen(value) + } +} + +extension ClosureParamSyntax: 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), + "unexpectedBetweenNameAndTrailingComma": unexpectedBetweenNameAndTrailingComma.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 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: ParameterClauseSyntax) { + self = .input(node) + } + public init?(_ node: S) { + if let node = node.as(ClosureParamListSyntax.self) { + self = .simpleInput(node) + return + } + if let node = node.as(ParameterClauseSyntax.self) { + self = .input(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(ClosureParamListSyntax.self), + .node(ParameterClauseSyntax.self), + ]) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> ExpressionSegmentSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .closureSignature else { return nil } + self._syntaxNode = node._syntaxNode } - public var unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? { + /// 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) { + assert(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, + _ unexpectedBetweenInputAndAsyncKeyword: UnexpectedNodesSyntax? = nil, + asyncKeyword: TokenSyntax? = nil, + _ unexpectedBetweenAsyncKeywordAndThrowsTok: UnexpectedNodesSyntax? = nil, + throwsTok: TokenSyntax? = nil, + _ unexpectedBetweenThrowsTokAndOutput: 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, unexpectedBetweenInputAndAsyncKeyword, asyncKeyword, unexpectedBetweenAsyncKeywordAndThrowsTok, throwsTok, unexpectedBetweenThrowsTokAndOutput, output, unexpectedBetweenOutputAndInTok, inTok, unexpectedAfterInTok))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeAttributes?.raw, + attributes?.raw, + unexpectedBetweenAttributesAndCapture?.raw, + capture?.raw, + unexpectedBetweenCaptureAndInput?.raw, + input?.raw, + unexpectedBetweenInputAndAsyncKeyword?.raw, + asyncKeyword?.raw, + unexpectedBetweenAsyncKeywordAndThrowsTok?.raw, + throwsTok?.raw, + unexpectedBetweenThrowsTokAndOutput?.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 { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndExpressions(value) + self = withUnexpectedBeforeAttributes(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndExpressions` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndExpressions` to replace the node's - /// current `unexpectedBetweenLeftParenAndExpressions`, if present. - public func withUnexpectedBetweenLeftParenAndExpressions(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAttributes` replaced. + /// - param newChild: The new `unexpectedBeforeAttributes` to replace the node's + /// current `unexpectedBeforeAttributes`, if present. + public func withUnexpectedBeforeAttributes(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var expressions: TupleExprElementListSyntax { + public var attributes: AttributeListSyntax? { get { - let childData = data.child(at: 7, parent: Syntax(self)) - return TupleExprElementListSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } + return AttributeListSyntax(childData!) } set(value) { - self = withExpressions(value) + self = withAttributes(value) } } - /// Adds the provided `Expression` to the node's `expressions` + /// Adds the provided `Attribute` to the node's `attributes` /// collection. - /// - param element: The new `Expression` to add to the node's - /// `expressions` collection. - /// - returns: A copy of the receiver with the provided `Expression` - /// appended to its `expressions` collection. - public func addExpression(_ element: TupleExprElementSyntax) -> ExpressionSegmentSyntax { + /// - 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[7] { + if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, from: [element.raw], arena: arena) } - let newData = data.replacingChild(at: 7, with: collection, arena: arena) - return ExpressionSegmentSyntax(newData) + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return ClosureSignatureSyntax(newData) } - /// Returns a copy of the receiver with its `expressions` replaced. - /// - param newChild: The new `expressions` to replace the node's - /// current `expressions`, if present. - public func withExpressions(_ newChild: TupleExprElementListSyntax) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `attributes` replaced. + /// - param newChild: The new `attributes` to replace the node's + /// current `attributes`, if present. + public func withAttributes(_ newChild: AttributeListSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionsAndRightParen(value) + self = withUnexpectedBetweenAttributesAndCapture(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionsAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionsAndRightParen` to replace the node's - /// current `unexpectedBetweenExpressionsAndRightParen`, if present. - public func withUnexpectedBetweenExpressionsAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAttributesAndCapture` replaced. + /// - param newChild: The new `unexpectedBetweenAttributesAndCapture` to replace the node's + /// current `unexpectedBetweenAttributesAndCapture`, if present. + public func withUnexpectedBetweenAttributesAndCapture(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var rightParen: TokenSyntax { + public var capture: ClosureCaptureSignatureSyntax? { get { - let childData = data.child(at: 9, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return ClosureCaptureSignatureSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withCapture(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `capture` replaced. + /// - param newChild: The new `capture` to replace the node's + /// current `capture`, if present. + public func withCapture(_ newChild: ClosureCaptureSignatureSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedBetweenCaptureAndInput(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCaptureAndInput` replaced. + /// - param newChild: The new `unexpectedBetweenCaptureAndInput` to replace the node's + /// current `unexpectedBetweenCaptureAndInput`, if present. + public func withUnexpectedBetweenCaptureAndInput(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return ExpressionSegmentSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeBackslash, - \Self.backslash, - \Self.unexpectedBetweenBackslashAndDelimiter, - \Self.delimiter, - \Self.unexpectedBetweenDelimiterAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndExpressions, - \Self.expressions, - \Self.unexpectedBetweenExpressionsAndRightParen, - \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 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 ExpressionSegmentSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeBackslash": unexpectedBeforeBackslash.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "backslash": Syntax(backslash).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenBackslashAndDelimiter": unexpectedBetweenBackslashAndDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "delimiter": delimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenDelimiterAndLeftParen": unexpectedBetweenDelimiterAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndExpressions": unexpectedBetweenLeftParenAndExpressions.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "expressions": Syntax(expressions).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenExpressionsAndRightParen": unexpectedBetweenExpressionsAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } -} -// MARK: - KeyPathComponentSyntax - -public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { - public enum Component: SyntaxChildChoices { - case `property`(KeyPathPropertyComponentSyntax) - case `subscript`(KeyPathSubscriptComponentSyntax) - case `optional`(KeyPathOptionalComponentSyntax) - public var _syntaxNode: Syntax { - switch self { - case .property(let node): return node._syntaxNode - case .subscript(let node): return node._syntaxNode - case .optional(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: KeyPathPropertyComponentSyntax) { - self = .property(node) - } - public init(_ node: KeyPathSubscriptComponentSyntax) { - self = .subscript(node) - } - public init(_ node: KeyPathOptionalComponentSyntax) { - self = .optional(node) - } - public init?(_ node: S) { - if let node = node.as(KeyPathPropertyComponentSyntax.self) { - self = .property(node) - return - } - if let node = node.as(KeyPathSubscriptComponentSyntax.self) { - self = .subscript(node) - return - } - if let node = node.as(KeyPathOptionalComponentSyntax.self) { - self = .optional(node) - return - } - return nil + public var input: Input? { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } + return Input(childData!) } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(KeyPathPropertyComponentSyntax.self), - .node(KeyPathSubscriptComponentSyntax.self), - .node(KeyPathOptionalComponentSyntax.self), - ]) + set(value) { + self = withInput(value) } } - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .keyPathComponent else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `KeyPathComponentSyntax` 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) { - assert(data.raw.kind == .keyPathComponent) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePeriod: UnexpectedNodesSyntax? = nil, - period: TokenSyntax? = nil, - _ unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? = nil, - component: Component, - _ unexpectedAfterComponent: 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(), (unexpectedBeforePeriod, period, unexpectedBetweenPeriodAndComponent, component, unexpectedAfterComponent))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndComponent?.raw, - component.raw, - unexpectedAfterComponent?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathComponent, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) + /// Returns a copy of the receiver with its `input` replaced. + /// - param newChild: The new `input` to replace the node's + /// current `input`, if present. + public func withInput(_ newChild: Input?) -> ClosureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var unexpectedBeforePeriod: UnexpectedNodesSyntax? { + public var unexpectedBetweenInputAndAsyncKeyword: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePeriod(value) + self = withUnexpectedBetweenInputAndAsyncKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePeriod` replaced. - /// - param newChild: The new `unexpectedBeforePeriod` to replace the node's - /// current `unexpectedBeforePeriod`, if present. - public func withUnexpectedBeforePeriod(_ newChild: UnexpectedNodesSyntax?) -> KeyPathComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenInputAndAsyncKeyword` replaced. + /// - param newChild: The new `unexpectedBetweenInputAndAsyncKeyword` to replace the node's + /// current `unexpectedBetweenInputAndAsyncKeyword`, if present. + public func withUnexpectedBetweenInputAndAsyncKeyword(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return KeyPathComponentSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var period: TokenSyntax? { + public var asyncKeyword: TokenSyntax? { get { - let childData = data.child(at: 1, parent: Syntax(self)) + let childData = data.child(at: 7, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withPeriod(value) + self = withAsyncKeyword(value) } } - /// Returns a copy of the receiver with its `period` replaced. - /// - param newChild: The new `period` to replace the node's - /// current `period`, if present. - public func withPeriod(_ newChild: TokenSyntax?) -> KeyPathComponentSyntax { + /// Returns a copy of the receiver with its `asyncKeyword` replaced. + /// - param newChild: The new `asyncKeyword` to replace the node's + /// current `asyncKeyword`, if present. + public func withAsyncKeyword(_ newChild: TokenSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return KeyPathComponentSyntax(newData) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncKeywordAndThrowsTok: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPeriodAndComponent(value) + self = withUnexpectedBetweenAsyncKeywordAndThrowsTok(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPeriodAndComponent` replaced. - /// - param newChild: The new `unexpectedBetweenPeriodAndComponent` to replace the node's - /// current `unexpectedBetweenPeriodAndComponent`, if present. - public func withUnexpectedBetweenPeriodAndComponent(_ newChild: UnexpectedNodesSyntax?) -> KeyPathComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAsyncKeywordAndThrowsTok` replaced. + /// - param newChild: The new `unexpectedBetweenAsyncKeywordAndThrowsTok` to replace the node's + /// current `unexpectedBetweenAsyncKeywordAndThrowsTok`, if present. + public func withUnexpectedBetweenAsyncKeywordAndThrowsTok(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return KeyPathComponentSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var component: Component { + public var throwsTok: TokenSyntax? { get { - let childData = data.child(at: 3, parent: Syntax(self)) - return Component(childData!) + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withComponent(value) + self = withThrowsTok(value) } } - /// Returns a copy of the receiver with its `component` replaced. - /// - param newChild: The new `component` to replace the node's - /// current `component`, if present. - public func withComponent(_ newChild: Component) -> KeyPathComponentSyntax { + /// Returns a copy of the receiver with its `throwsTok` replaced. + /// - param newChild: The new `throwsTok` to replace the node's + /// current `throwsTok`, if present. + public func withThrowsTok(_ newChild: TokenSyntax?) -> ClosureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) + } + + public var unexpectedBetweenThrowsTokAndOutput: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 10, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenThrowsTokAndOutput(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenThrowsTokAndOutput` replaced. + /// - param newChild: The new `unexpectedBetweenThrowsTokAndOutput` to replace the node's + /// current `unexpectedBetweenThrowsTokAndOutput`, if present. + public func withUnexpectedBetweenThrowsTokAndOutput(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) + } + + public var output: ReturnClauseSyntax? { + get { + let childData = data.child(at: 11, parent: Syntax(self)) + if childData == nil { return nil } + return ReturnClauseSyntax(childData!) + } + set(value) { + self = withOutput(value) + } + } + + /// Returns a copy of the receiver with its `output` replaced. + /// - param newChild: The new `output` to replace the node's + /// current `output`, if present. + public func withOutput(_ newChild: ReturnClauseSyntax?) -> ClosureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 11, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) + } + + public var unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 12, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenOutputAndInTok(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenOutputAndInTok` replaced. + /// - param newChild: The new `unexpectedBetweenOutputAndInTok` to replace the node's + /// current `unexpectedBetweenOutputAndInTok`, if present. + public func withUnexpectedBetweenOutputAndInTok(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 12, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) + } + + public var inTok: TokenSyntax { + get { + let childData = data.child(at: 13, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withInTok(value) + } + } + + /// Returns a copy of the receiver with its `inTok` replaced. + /// - param newChild: The new `inTok` to replace the node's + /// current `inTok`, if present. + public func withInTok(_ newChild: TokenSyntax) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return KeyPathComponentSyntax(newData) + let newData = data.replacingChild(at: 13, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var unexpectedAfterComponent: UnexpectedNodesSyntax? { + public var unexpectedAfterInTok: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 14, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterComponent(value) + self = withUnexpectedAfterInTok(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterComponent` replaced. - /// - param newChild: The new `unexpectedAfterComponent` to replace the node's - /// current `unexpectedAfterComponent`, if present. - public func withUnexpectedAfterComponent(_ newChild: UnexpectedNodesSyntax?) -> KeyPathComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterInTok` replaced. + /// - param newChild: The new `unexpectedAfterInTok` to replace the node's + /// current `unexpectedAfterInTok`, if present. + public func withUnexpectedAfterInTok(_ newChild: UnexpectedNodesSyntax?) -> ClosureSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return KeyPathComponentSyntax(newData) + let newData = data.replacingChild(at: 14, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePeriod, - \Self.period, - \Self.unexpectedBetweenPeriodAndComponent, - \Self.component, - \Self.unexpectedAfterComponent, + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndCapture, + \Self.capture, + \Self.unexpectedBetweenCaptureAndInput, + \Self.input, + \Self.unexpectedBetweenInputAndAsyncKeyword, + \Self.asyncKeyword, + \Self.unexpectedBetweenAsyncKeywordAndThrowsTok, + \Self.throwsTok, + \Self.unexpectedBetweenThrowsTokAndOutput, + \Self.output, + \Self.unexpectedBetweenOutputAndInTok, + \Self.inTok, + \Self.unexpectedAfterInTok, ]) } @@ -4178,235 +4158,263 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + 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 + case 13: + return nil + case 14: + return nil default: fatalError("Invalid index") } } } -extension KeyPathComponentSyntax: CustomReflectable { +extension ClosureSignatureSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePeriod": unexpectedBeforePeriod.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenPeriodAndComponent": unexpectedBetweenPeriodAndComponent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "component": Syntax(component).asProtocol(SyntaxProtocol.self), - "unexpectedAfterComponent": unexpectedAfterComponent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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, + "unexpectedBetweenInputAndAsyncKeyword": unexpectedBetweenInputAndAsyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "asyncKeyword": asyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenAsyncKeywordAndThrowsTok": unexpectedBetweenAsyncKeywordAndThrowsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "throwsTok": throwsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenThrowsTokAndOutput": unexpectedBetweenThrowsTokAndOutput.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: - KeyPathPropertyComponentSyntax +// MARK: - MultipleTrailingClosureElementSyntax -public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { +public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathPropertyComponent else { return nil } + guard node.raw.kind == .multipleTrailingClosureElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `KeyPathPropertyComponentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `MultipleTrailingClosureElementSyntax` 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) { - assert(data.raw.kind == .keyPathPropertyComponent) + assert(data.raw.kind == .multipleTrailingClosureElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, - genericArgumentClause: GenericArgumentClauseSyntax? = nil, - _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? = nil, + closure: ClosureExprSyntax, + _ unexpectedAfterClosure: 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(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndDeclNameArguments, declNameArguments, unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndClosure, closure, unexpectedAfterClosure))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndDeclNameArguments?.raw, - declNameArguments?.raw, - unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedAfterGenericArgumentClause?.raw, + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndClosure?.raw, + closure.raw, + unexpectedAfterClosure?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathPropertyComponent, from: layout, arena: arena, + kind: SyntaxKind.multipleTrailingClosureElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeIdentifier(value) + self = withUnexpectedBeforeLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeIdentifier` replaced. - /// - param newChild: The new `unexpectedBeforeIdentifier` to replace the node's - /// current `unexpectedBeforeIdentifier`, if present. - public func withUnexpectedBeforeIdentifier(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. + /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's + /// current `unexpectedBeforeLabel`, if present. + public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return KeyPathPropertyComponentSyntax(newData) + return MultipleTrailingClosureElementSyntax(newData) } - public var identifier: TokenSyntax { + public var label: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withIdentifier(value) + self = withLabel(value) } } - /// Returns a copy of the receiver with its `identifier` replaced. - /// - param newChild: The new `identifier` to replace the node's - /// current `identifier`, if present. - public func withIdentifier(_ newChild: TokenSyntax) -> KeyPathPropertyComponentSyntax { + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel(_ newChild: TokenSyntax) -> MultipleTrailingClosureElementSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return KeyPathPropertyComponentSyntax(newData) + return MultipleTrailingClosureElementSyntax(newData) } - public var unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenIdentifierAndDeclNameArguments(value) + self = withUnexpectedBetweenLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenIdentifierAndDeclNameArguments` replaced. - /// - param newChild: The new `unexpectedBetweenIdentifierAndDeclNameArguments` to replace the node's - /// current `unexpectedBetweenIdentifierAndDeclNameArguments`, if present. - public func withUnexpectedBetweenIdentifierAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's + /// current `unexpectedBetweenLabelAndColon`, if present. + public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return KeyPathPropertyComponentSyntax(newData) + return MultipleTrailingClosureElementSyntax(newData) } - public var declNameArguments: DeclNameArgumentsSyntax? { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDeclNameArguments(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `declNameArguments` replaced. - /// - param newChild: The new `declNameArguments` to replace the node's - /// current `declNameArguments`, if present. - public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> KeyPathPropertyComponentSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> MultipleTrailingClosureElementSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return KeyPathPropertyComponentSyntax(newData) + return MultipleTrailingClosureElementSyntax(newData) } - public var unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDeclNameArgumentsAndGenericArgumentClause(value) + self = withUnexpectedBetweenColonAndClosure(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause` replaced. - /// - param newChild: The new `unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause` to replace the node's - /// current `unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause`, if present. - public func withUnexpectedBetweenDeclNameArgumentsAndGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndClosure` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndClosure` to replace the node's + /// current `unexpectedBetweenColonAndClosure`, if present. + public func withUnexpectedBetweenColonAndClosure(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return KeyPathPropertyComponentSyntax(newData) + return MultipleTrailingClosureElementSyntax(newData) } - public var genericArgumentClause: GenericArgumentClauseSyntax? { + public var closure: ClosureExprSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return GenericArgumentClauseSyntax(childData!) + return ClosureExprSyntax(childData!) } set(value) { - self = withGenericArgumentClause(value) + self = withClosure(value) } } - /// Returns a copy of the receiver with its `genericArgumentClause` replaced. - /// - param newChild: The new `genericArgumentClause` to replace the node's - /// current `genericArgumentClause`, if present. - public func withGenericArgumentClause(_ newChild: GenericArgumentClauseSyntax?) -> KeyPathPropertyComponentSyntax { + /// Returns a copy of the receiver with its `closure` replaced. + /// - param newChild: The new `closure` to replace the node's + /// current `closure`, if present. + public func withClosure(_ newChild: ClosureExprSyntax) -> MultipleTrailingClosureElementSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return KeyPathPropertyComponentSyntax(newData) + return MultipleTrailingClosureElementSyntax(newData) } - public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedAfterClosure: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterGenericArgumentClause(value) + self = withUnexpectedAfterClosure(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterGenericArgumentClause` replaced. - /// - param newChild: The new `unexpectedAfterGenericArgumentClause` to replace the node's - /// current `unexpectedAfterGenericArgumentClause`, if present. - public func withUnexpectedAfterGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterClosure` replaced. + /// - param newChild: The new `unexpectedAfterClosure` to replace the node's + /// current `unexpectedAfterClosure`, if present. + public func withUnexpectedAfterClosure(_ newChild: UnexpectedNodesSyntax?) -> MultipleTrailingClosureElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return KeyPathPropertyComponentSyntax(newData) + return MultipleTrailingClosureElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIdentifier, - \Self.identifier, - \Self.unexpectedBetweenIdentifierAndDeclNameArguments, - \Self.declNameArguments, - \Self.unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, - \Self.genericArgumentClause, - \Self.unexpectedAfterGenericArgumentClause, + \Self.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndClosure, + \Self.closure, + \Self.unexpectedAfterClosure, ]) } @@ -4415,7 +4423,7 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: @@ -4432,571 +4440,471 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { } } -extension KeyPathPropertyComponentSyntax: CustomReflectable { +extension MultipleTrailingClosureElementSyntax: 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), - "unexpectedBetweenIdentifierAndDeclNameArguments": unexpectedBetweenIdentifierAndDeclNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "declNameArguments": declNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause": unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "genericArgumentClause": genericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterGenericArgumentClause": unexpectedAfterGenericArgumentClause.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), + "unexpectedBetweenColonAndClosure": unexpectedBetweenColonAndClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "closure": Syntax(closure).asProtocol(SyntaxProtocol.self), + "unexpectedAfterClosure": unexpectedAfterClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - KeyPathSubscriptComponentSyntax +// MARK: - StringSegmentSyntax -public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { +public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathSubscriptComponent else { return nil } + guard node.raw.kind == .stringSegment else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `KeyPathSubscriptComponentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `StringSegmentSyntax` 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) { - assert(data.raw.kind == .keyPathSubscriptComponent) + assert(data.raw.kind == .stringSegment) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? = nil, - leftBracket: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, - rightBracket: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightBracket: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeContent: UnexpectedNodesSyntax? = nil, + content: TokenSyntax, + _ unexpectedAfterContent: 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(), (unexpectedBeforeLeftBracket, leftBracket, unexpectedBetweenLeftBracketAndArgumentList, argumentList, unexpectedBetweenArgumentListAndRightBracket, rightBracket, unexpectedAfterRightBracket))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeContent, content, unexpectedAfterContent))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBracket?.raw, - leftBracket.raw, - unexpectedBetweenLeftBracketAndArgumentList?.raw, - argumentList.raw, - unexpectedBetweenArgumentListAndRightBracket?.raw, - rightBracket.raw, - unexpectedAfterRightBracket?.raw, + unexpectedBeforeContent?.raw, + content.raw, + unexpectedAfterContent?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathSubscriptComponent, from: layout, arena: arena, + kind: SyntaxKind.stringSegment, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? { + public var unexpectedBeforeContent: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftBracket(value) + self = withUnexpectedBeforeContent(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftBracket` replaced. - /// - param newChild: The new `unexpectedBeforeLeftBracket` to replace the node's - /// current `unexpectedBeforeLeftBracket`, if present. - public func withUnexpectedBeforeLeftBracket(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeContent` replaced. + /// - param newChild: The new `unexpectedBeforeContent` to replace the node's + /// current `unexpectedBeforeContent`, if present. + public func withUnexpectedBeforeContent(_ newChild: UnexpectedNodesSyntax?) -> StringSegmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) + return StringSegmentSyntax(newData) } - public var leftBracket: TokenSyntax { + public var content: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftBracket(value) + self = withContent(value) } } - /// Returns a copy of the receiver with its `leftBracket` replaced. - /// - param newChild: The new `leftBracket` to replace the node's - /// current `leftBracket`, if present. - public func withLeftBracket(_ newChild: TokenSyntax) -> KeyPathSubscriptComponentSyntax { + /// Returns a copy of the receiver with its `content` replaced. + /// - param newChild: The new `content` to replace the node's + /// current `content`, if present. + public func withContent(_ newChild: TokenSyntax) -> StringSegmentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) + return StringSegmentSyntax(newData) } - public var unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? { + public var unexpectedAfterContent: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftBracketAndArgumentList(value) + self = withUnexpectedAfterContent(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftBracketAndArgumentList` replaced. - /// - param newChild: The new `unexpectedBetweenLeftBracketAndArgumentList` to replace the node's - /// current `unexpectedBetweenLeftBracketAndArgumentList`, if present. - public func withUnexpectedBetweenLeftBracketAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterContent` replaced. + /// - param newChild: The new `unexpectedAfterContent` to replace the node's + /// current `unexpectedAfterContent`, if present. + public func withUnexpectedAfterContent(_ newChild: UnexpectedNodesSyntax?) -> StringSegmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) + return StringSegmentSyntax(newData) } - public var argumentList: TupleExprElementListSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TupleExprElementListSyntax(childData!) - } - set(value) { - self = withArgumentList(value) - } + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeContent, + \Self.content, + \Self.unexpectedAfterContent, + ]) } - /// Adds the provided `Argument` to the node's `argumentList` - /// collection. - /// - param element: The new `Argument` to add to the node's - /// `argumentList` collection. - /// - returns: A copy of the receiver with the provided `Argument` - /// appended to its `argumentList` collection. - public func addArgument(_ element: TupleExprElementSyntax) -> KeyPathSubscriptComponentSyntax { - 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.tupleExprElementList, - from: [element.raw], arena: arena) + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + default: + fatalError("Invalid index") } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) } +} - /// Returns a copy of the receiver with its `argumentList` replaced. - /// - param newChild: The new `argumentList` to replace the node's - /// current `argumentList`, if present. - public func withArgumentList(_ newChild: TupleExprElementListSyntax) -> KeyPathSubscriptComponentSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) - } - - public var unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenArgumentListAndRightBracket(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenArgumentListAndRightBracket` replaced. - /// - param newChild: The new `unexpectedBetweenArgumentListAndRightBracket` to replace the node's - /// current `unexpectedBetweenArgumentListAndRightBracket`, if present. - public func withUnexpectedBetweenArgumentListAndRightBracket(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) - } - - public var rightBracket: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withRightBracket(value) - } - } - - /// Returns a copy of the receiver with its `rightBracket` replaced. - /// - param newChild: The new `rightBracket` to replace the node's - /// current `rightBracket`, if present. - public func withRightBracket(_ newChild: TokenSyntax) -> KeyPathSubscriptComponentSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) - } - - public var unexpectedAfterRightBracket: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterRightBracket(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterRightBracket` replaced. - /// - param newChild: The new `unexpectedAfterRightBracket` to replace the node's - /// current `unexpectedAfterRightBracket`, if present. - public func withUnexpectedAfterRightBracket(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeLeftBracket, - \Self.leftBracket, - \Self.unexpectedBetweenLeftBracketAndArgumentList, - \Self.argumentList, - \Self.unexpectedBetweenArgumentListAndRightBracket, - \Self.rightBracket, - \Self.unexpectedAfterRightBracket, - ]) - } - - 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 "arguments" - case 4: - return nil - case 5: - return nil - case 6: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension KeyPathSubscriptComponentSyntax: CustomReflectable { +extension StringSegmentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeftBracket": unexpectedBeforeLeftBracket.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftBracket": Syntax(leftBracket).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftBracketAndArgumentList": unexpectedBetweenLeftBracketAndArgumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "argumentList": Syntax(argumentList).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenArgumentListAndRightBracket": unexpectedBetweenArgumentListAndRightBracket.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightBracket": Syntax(rightBracket).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightBracket": unexpectedAfterRightBracket.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeContent": unexpectedBeforeContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "content": Syntax(content).asProtocol(SyntaxProtocol.self), + "unexpectedAfterContent": unexpectedAfterContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - KeyPathOptionalComponentSyntax +// MARK: - ExpressionSegmentSyntax -public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable { +public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathOptionalComponent else { return nil } + guard node.raw.kind == .expressionSegment else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `KeyPathOptionalComponentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ExpressionSegmentSyntax` 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) { - assert(data.raw.kind == .keyPathOptionalComponent) + assert(data.raw.kind == .expressionSegment) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax, - _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, + backslash: TokenSyntax = .backslashToken(), + _ unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? = nil, + delimiter: TokenSyntax? = nil, + _ unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? = nil, + expressions: TupleExprElementListSyntax, + _ unexpectedBetweenExpressionsAndRightParen: 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(), (unexpectedBeforeQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBackslash, backslash, unexpectedBetweenBackslashAndDelimiter, delimiter, unexpectedBetweenDelimiterAndLeftParen, leftParen, unexpectedBetweenLeftParenAndExpressions, expressions, unexpectedBetweenExpressionsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeQuestionOrExclamationMark?.raw, - questionOrExclamationMark.raw, - unexpectedAfterQuestionOrExclamationMark?.raw, + unexpectedBeforeBackslash?.raw, + backslash.raw, + unexpectedBetweenBackslashAndDelimiter?.raw, + delimiter?.raw, + unexpectedBetweenDelimiterAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndExpressions?.raw, + expressions.raw, + unexpectedBetweenExpressionsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathOptionalComponent, from: layout, arena: arena, + kind: SyntaxKind.expressionSegment, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeQuestionOrExclamationMark(value) + self = withUnexpectedBeforeBackslash(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeQuestionOrExclamationMark` replaced. - /// - param newChild: The new `unexpectedBeforeQuestionOrExclamationMark` to replace the node's - /// current `unexpectedBeforeQuestionOrExclamationMark`, if present. - public func withUnexpectedBeforeQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> KeyPathOptionalComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeBackslash` replaced. + /// - param newChild: The new `unexpectedBeforeBackslash` to replace the node's + /// current `unexpectedBeforeBackslash`, if present. + public func withUnexpectedBeforeBackslash(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return KeyPathOptionalComponentSyntax(newData) + return ExpressionSegmentSyntax(newData) } - public var questionOrExclamationMark: TokenSyntax { + public var backslash: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withQuestionOrExclamationMark(value) + self = withBackslash(value) } } - /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced. - /// - param newChild: The new `questionOrExclamationMark` to replace the node's - /// current `questionOrExclamationMark`, if present. - public func withQuestionOrExclamationMark(_ newChild: TokenSyntax) -> KeyPathOptionalComponentSyntax { + /// Returns a copy of the receiver with its `backslash` replaced. + /// - param newChild: The new `backslash` to replace the node's + /// current `backslash`, if present. + public func withBackslash(_ newChild: TokenSyntax) -> ExpressionSegmentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return KeyPathOptionalComponentSyntax(newData) + return ExpressionSegmentSyntax(newData) } - public var unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterQuestionOrExclamationMark(value) + self = withUnexpectedBetweenBackslashAndDelimiter(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterQuestionOrExclamationMark` replaced. - /// - param newChild: The new `unexpectedAfterQuestionOrExclamationMark` to replace the node's - /// current `unexpectedAfterQuestionOrExclamationMark`, if present. - public func withUnexpectedAfterQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> KeyPathOptionalComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenBackslashAndDelimiter` replaced. + /// - param newChild: The new `unexpectedBetweenBackslashAndDelimiter` to replace the node's + /// current `unexpectedBetweenBackslashAndDelimiter`, if present. + public func withUnexpectedBetweenBackslashAndDelimiter(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return KeyPathOptionalComponentSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeQuestionOrExclamationMark, - \Self.questionOrExclamationMark, - \Self.unexpectedAfterQuestionOrExclamationMark, - ]) + return ExpressionSegmentSyntax(newData) } - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - default: - fatalError("Invalid index") + public var delimiter: TokenSyntax? { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withDelimiter(value) } } -} -extension KeyPathOptionalComponentSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeQuestionOrExclamationMark": unexpectedBeforeQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "questionOrExclamationMark": Syntax(questionOrExclamationMark).asProtocol(SyntaxProtocol.self), - "unexpectedAfterQuestionOrExclamationMark": unexpectedAfterQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) + /// Returns a copy of the receiver with its `delimiter` replaced. + /// - param newChild: The new `delimiter` to replace the node's + /// current `delimiter`, if present. + public func withDelimiter(_ newChild: TokenSyntax?) -> ExpressionSegmentSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } -} -// MARK: - YieldExprListElementSyntax + public var unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenDelimiterAndLeftParen(value) + } + } -public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .yieldExprListElement else { return nil } - self._syntaxNode = node._syntaxNode + /// Returns a copy of the receiver with its `unexpectedBetweenDelimiterAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenDelimiterAndLeftParen` to replace the node's + /// current `unexpectedBetweenDelimiterAndLeftParen`, if present. + public func withUnexpectedBetweenDelimiterAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } - /// Creates a `YieldExprListElementSyntax` 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) { - assert(data.raw.kind == .yieldExprListElement) - self._syntaxNode = Syntax(data) + public var leftParen: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withLeftParen(value) + } } - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedAfterComma: 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(), (unexpectedBeforeExpression, expression, unexpectedBetweenExpressionAndComma, comma, unexpectedAfterComma))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndComma?.raw, - comma?.raw, - unexpectedAfterComma?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldExprListElement, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> ExpressionSegmentSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } - public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeExpression(value) + self = withUnexpectedBetweenLeftParenAndExpressions(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. - /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's - /// current `unexpectedBeforeExpression`, if present. - public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> YieldExprListElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndExpressions` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndExpressions` to replace the node's + /// current `unexpectedBetweenLeftParenAndExpressions`, if present. + public func withUnexpectedBetweenLeftParenAndExpressions(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return YieldExprListElementSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } - public var expression: ExprSyntax { + public var expressions: TupleExprElementListSyntax { get { - let childData = data.child(at: 1, parent: Syntax(self)) - return ExprSyntax(childData!) + let childData = data.child(at: 7, parent: Syntax(self)) + return TupleExprElementListSyntax(childData!) } set(value) { - self = withExpression(value) + self = withExpressions(value) } } - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax) -> YieldExprListElementSyntax { + /// Adds the provided `Expression` to the node's `expressions` + /// collection. + /// - param element: The new `Expression` to add to the node's + /// `expressions` collection. + /// - returns: A copy of the receiver with the provided `Expression` + /// appended to its `expressions` collection. + public func addExpression(_ element: TupleExprElementSyntax) -> ExpressionSegmentSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[7] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 7, with: collection, arena: arena) + return ExpressionSegmentSyntax(newData) + } + + /// Returns a copy of the receiver with its `expressions` replaced. + /// - param newChild: The new `expressions` to replace the node's + /// current `expressions`, if present. + public func withExpressions(_ newChild: TupleExprElementListSyntax) -> ExpressionSegmentSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return YieldExprListElementSyntax(newData) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } - public var unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionAndComma(value) + self = withUnexpectedBetweenExpressionsAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndComma` to replace the node's - /// current `unexpectedBetweenExpressionAndComma`, if present. - public func withUnexpectedBetweenExpressionAndComma(_ newChild: UnexpectedNodesSyntax?) -> YieldExprListElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionsAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionsAndRightParen` to replace the node's + /// current `unexpectedBetweenExpressionsAndRightParen`, if present. + public func withUnexpectedBetweenExpressionsAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return YieldExprListElementSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } - public var comma: TokenSyntax? { + public var rightParen: TokenSyntax { get { - let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 9, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withComma(value) + self = withRightParen(value) } } - /// Returns a copy of the receiver with its `comma` replaced. - /// - param newChild: The new `comma` to replace the node's - /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax?) -> YieldExprListElementSyntax { + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> ExpressionSegmentSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return YieldExprListElementSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } - public var unexpectedAfterComma: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterComma(value) + self = withUnexpectedAfterRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterComma` replaced. - /// - param newChild: The new `unexpectedAfterComma` to replace the node's - /// current `unexpectedAfterComma`, if present. - public func withUnexpectedAfterComma(_ newChild: UnexpectedNodesSyntax?) -> YieldExprListElementSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> ExpressionSegmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return YieldExprListElementSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndComma, - \Self.comma, - \Self.unexpectedAfterComma, + \Self.unexpectedBeforeBackslash, + \Self.backslash, + \Self.unexpectedBetweenBackslashAndDelimiter, + \Self.delimiter, + \Self.unexpectedBetweenDelimiterAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndExpressions, + \Self.expressions, + \Self.unexpectedBetweenExpressionsAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -5012,179 +4920,244 @@ public struct YieldExprListElementSyntax: 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 YieldExprListElementSyntax: CustomReflectable { +extension ExpressionSegmentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeExpression": unexpectedBeforeExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenExpressionAndComma": unexpectedBetweenExpressionAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterComma": unexpectedAfterComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeBackslash": unexpectedBeforeBackslash.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "backslash": Syntax(backslash).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenBackslashAndDelimiter": unexpectedBetweenBackslashAndDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "delimiter": delimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenDelimiterAndLeftParen": unexpectedBetweenDelimiterAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndExpressions": unexpectedBetweenLeftParenAndExpressions.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expressions": Syntax(expressions).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionsAndRightParen": unexpectedBetweenExpressionsAndRightParen.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: - TypeInitializerClauseSyntax - -public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .typeInitializerClause else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `TypeInitializerClauseSyntax` 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) { - assert(data.raw.kind == .typeInitializerClause) - self._syntaxNode = Syntax(data) - } +// MARK: - KeyPathComponentSyntax - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, - equal: TokenSyntax = .equalToken(), - _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, - value: V, - _ unexpectedAfterValue: 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(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, +public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { + public enum Component: SyntaxChildChoices { + case `property`(KeyPathPropertyComponentSyntax) + case `subscript`(KeyPathSubscriptComponentSyntax) + case `optional`(KeyPathOptionalComponentSyntax) + public var _syntaxNode: Syntax { + switch self { + case .property(let node): return node._syntaxNode + case .subscript(let node): return node._syntaxNode + case .optional(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: KeyPathPropertyComponentSyntax) { + self = .property(node) + } + public init(_ node: KeyPathSubscriptComponentSyntax) { + self = .subscript(node) + } + public init(_ node: KeyPathOptionalComponentSyntax) { + self = .optional(node) + } + public init?(_ node: S) { + if let node = node.as(KeyPathPropertyComponentSyntax.self) { + self = .property(node) + return + } + if let node = node.as(KeyPathSubscriptComponentSyntax.self) { + self = .subscript(node) + return + } + if let node = node.as(KeyPathOptionalComponentSyntax.self) { + self = .optional(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(KeyPathPropertyComponentSyntax.self), + .node(KeyPathSubscriptComponentSyntax.self), + .node(KeyPathOptionalComponentSyntax.self), + ]) + } + } + + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .keyPathComponent else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `KeyPathComponentSyntax` 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) { + assert(data.raw.kind == .keyPathComponent) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax? = nil, + _ unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? = nil, + component: Component, + _ unexpectedAfterComponent: 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(), (unexpectedBeforePeriod, period, unexpectedBetweenPeriodAndComponent, component, unexpectedAfterComponent))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforePeriod?.raw, + period?.raw, + unexpectedBetweenPeriodAndComponent?.raw, + component.raw, + unexpectedAfterComponent?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeInitializerClause, from: layout, arena: arena, + kind: SyntaxKind.keyPathComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { + public var unexpectedBeforePeriod: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeEqual(value) + self = withUnexpectedBeforePeriod(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeEqual` replaced. - /// - param newChild: The new `unexpectedBeforeEqual` to replace the node's - /// current `unexpectedBeforeEqual`, if present. - public func withUnexpectedBeforeEqual(_ newChild: UnexpectedNodesSyntax?) -> TypeInitializerClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforePeriod` replaced. + /// - param newChild: The new `unexpectedBeforePeriod` to replace the node's + /// current `unexpectedBeforePeriod`, if present. + public func withUnexpectedBeforePeriod(_ newChild: UnexpectedNodesSyntax?) -> KeyPathComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return TypeInitializerClauseSyntax(newData) + return KeyPathComponentSyntax(newData) } - public var equal: TokenSyntax { + public var period: TokenSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withEqual(value) + self = withPeriod(value) } } - /// Returns a copy of the receiver with its `equal` replaced. - /// - param newChild: The new `equal` to replace the node's - /// current `equal`, if present. - public func withEqual(_ newChild: TokenSyntax) -> TypeInitializerClauseSyntax { + /// Returns a copy of the receiver with its `period` replaced. + /// - param newChild: The new `period` to replace the node's + /// current `period`, if present. + public func withPeriod(_ newChild: TokenSyntax?) -> KeyPathComponentSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TypeInitializerClauseSyntax(newData) + return KeyPathComponentSyntax(newData) } - public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenEqualAndValue(value) + self = withUnexpectedBetweenPeriodAndComponent(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenEqualAndValue` replaced. - /// - param newChild: The new `unexpectedBetweenEqualAndValue` to replace the node's - /// current `unexpectedBetweenEqualAndValue`, if present. - public func withUnexpectedBetweenEqualAndValue(_ newChild: UnexpectedNodesSyntax?) -> TypeInitializerClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPeriodAndComponent` replaced. + /// - param newChild: The new `unexpectedBetweenPeriodAndComponent` to replace the node's + /// current `unexpectedBetweenPeriodAndComponent`, if present. + public func withUnexpectedBetweenPeriodAndComponent(_ newChild: UnexpectedNodesSyntax?) -> KeyPathComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return TypeInitializerClauseSyntax(newData) + return KeyPathComponentSyntax(newData) } - public var value: TypeSyntax { + public var component: Component { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TypeSyntax(childData!) + return Component(childData!) } set(value) { - self = withValue(value) + self = withComponent(value) } } - /// Returns a copy of the receiver with its `value` replaced. - /// - param newChild: The new `value` to replace the node's - /// current `value`, if present. - public func withValue(_ newChild: TypeSyntax) -> TypeInitializerClauseSyntax { + /// Returns a copy of the receiver with its `component` replaced. + /// - param newChild: The new `component` to replace the node's + /// current `component`, if present. + public func withComponent(_ newChild: Component) -> KeyPathComponentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return TypeInitializerClauseSyntax(newData) + return KeyPathComponentSyntax(newData) } - public var unexpectedAfterValue: UnexpectedNodesSyntax? { + public var unexpectedAfterComponent: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterValue(value) + self = withUnexpectedAfterComponent(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterValue` replaced. - /// - param newChild: The new `unexpectedAfterValue` to replace the node's - /// current `unexpectedAfterValue`, if present. - public func withUnexpectedAfterValue(_ newChild: UnexpectedNodesSyntax?) -> TypeInitializerClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterComponent` replaced. + /// - param newChild: The new `unexpectedAfterComponent` to replace the node's + /// current `unexpectedAfterComponent`, if present. + public func withUnexpectedAfterComponent(_ newChild: UnexpectedNodesSyntax?) -> KeyPathComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return TypeInitializerClauseSyntax(newData) + return KeyPathComponentSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeEqual, - \Self.equal, - \Self.unexpectedBetweenEqualAndValue, - \Self.value, - \Self.unexpectedAfterValue, + \Self.unexpectedBeforePeriod, + \Self.period, + \Self.unexpectedBetweenPeriodAndComponent, + \Self.component, + \Self.unexpectedAfterComponent, ]) } @@ -5197,7 +5170,7 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "type" + return nil case 4: return nil default: @@ -5206,239 +5179,222 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { } } -extension TypeInitializerClauseSyntax: CustomReflectable { +extension KeyPathComponentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeEqual": unexpectedBeforeEqual.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "equal": Syntax(equal).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenEqualAndValue": unexpectedBetweenEqualAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "value": Syntax(value).asProtocol(SyntaxProtocol.self), - "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforePeriod": unexpectedBeforePeriod.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenPeriodAndComponent": unexpectedBetweenPeriodAndComponent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "component": Syntax(component).asProtocol(SyntaxProtocol.self), + "unexpectedAfterComponent": unexpectedAfterComponent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ParameterClauseSyntax +// MARK: - KeyPathPropertyComponentSyntax -public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { +public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .parameterClause else { return nil } + guard node.raw.kind == .keyPathPropertyComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ParameterClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `KeyPathPropertyComponentSyntax` 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) { - assert(data.raw.kind == .parameterClause) + assert(data.raw.kind == .keyPathPropertyComponent) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, - parameterList: FunctionParameterListSyntax, - _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax? = nil, + _ unexpectedAfterGenericArgumentClause: 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 data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndDeclNameArguments, declNameArguments, unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndParameterList?.raw, - parameterList.raw, - unexpectedBetweenParameterListAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeIdentifier?.raw, + identifier.raw, + unexpectedBetweenIdentifierAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause?.raw, + genericArgumentClause?.raw, + unexpectedAfterGenericArgumentClause?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.parameterClause, from: layout, arena: arena, + kind: SyntaxKind.keyPathPropertyComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftParen(value) + self = withUnexpectedBeforeIdentifier(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. - /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's - /// current `unexpectedBeforeLeftParen`, if present. - public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeIdentifier` replaced. + /// - param newChild: The new `unexpectedBeforeIdentifier` to replace the node's + /// current `unexpectedBeforeIdentifier`, if present. + public func withUnexpectedBeforeIdentifier(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ParameterClauseSyntax(newData) + return KeyPathPropertyComponentSyntax(newData) } - public var leftParen: TokenSyntax { + public var identifier: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withIdentifier(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> ParameterClauseSyntax { + /// Returns a copy of the receiver with its `identifier` replaced. + /// - param newChild: The new `identifier` to replace the node's + /// current `identifier`, if present. + public func withIdentifier(_ newChild: TokenSyntax) -> KeyPathPropertyComponentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ParameterClauseSyntax(newData) + return KeyPathPropertyComponentSyntax(newData) } - public var unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndParameterList(value) + self = withUnexpectedBetweenIdentifierAndDeclNameArguments(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndParameterList` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndParameterList` to replace the node's - /// current `unexpectedBetweenLeftParenAndParameterList`, if present. - public func withUnexpectedBetweenLeftParenAndParameterList(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenIdentifierAndDeclNameArguments` replaced. + /// - param newChild: The new `unexpectedBetweenIdentifierAndDeclNameArguments` to replace the node's + /// current `unexpectedBetweenIdentifierAndDeclNameArguments`, if present. + public func withUnexpectedBetweenIdentifierAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ParameterClauseSyntax(newData) + return KeyPathPropertyComponentSyntax(newData) } - public var parameterList: FunctionParameterListSyntax { + public var declNameArguments: DeclNameArgumentsSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return FunctionParameterListSyntax(childData!) + if childData == nil { return nil } + return DeclNameArgumentsSyntax(childData!) } set(value) { - self = withParameterList(value) - } - } - - /// 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: FunctionParameterSyntax) -> ParameterClauseSyntax { - 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.functionParameterList, - from: [element.raw], arena: arena) + self = withDeclNameArguments(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return ParameterClauseSyntax(newData) } - /// Returns a copy of the receiver with its `parameterList` replaced. - /// - param newChild: The new `parameterList` to replace the node's - /// current `parameterList`, if present. - public func withParameterList(_ newChild: FunctionParameterListSyntax) -> ParameterClauseSyntax { + /// Returns a copy of the receiver with its `declNameArguments` replaced. + /// - param newChild: The new `declNameArguments` to replace the node's + /// current `declNameArguments`, if present. + public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> KeyPathPropertyComponentSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ParameterClauseSyntax(newData) + return KeyPathPropertyComponentSyntax(newData) } - public var unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenParameterListAndRightParen(value) + self = withUnexpectedBetweenDeclNameArgumentsAndGenericArgumentClause(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenParameterListAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenParameterListAndRightParen` to replace the node's - /// current `unexpectedBetweenParameterListAndRightParen`, if present. - public func withUnexpectedBetweenParameterListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause` replaced. + /// - param newChild: The new `unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause` to replace the node's + /// current `unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause`, if present. + public func withUnexpectedBetweenDeclNameArgumentsAndGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ParameterClauseSyntax(newData) + return KeyPathPropertyComponentSyntax(newData) } - public var rightParen: TokenSyntax { + public var genericArgumentClause: GenericArgumentClauseSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return GenericArgumentClauseSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withGenericArgumentClause(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> ParameterClauseSyntax { + /// Returns a copy of the receiver with its `genericArgumentClause` replaced. + /// - param newChild: The new `genericArgumentClause` to replace the node's + /// current `genericArgumentClause`, if present. + public func withGenericArgumentClause(_ newChild: GenericArgumentClauseSyntax?) -> KeyPathPropertyComponentSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ParameterClauseSyntax(newData) + return KeyPathPropertyComponentSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedAfterGenericArgumentClause(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterGenericArgumentClause` replaced. + /// - param newChild: The new `unexpectedAfterGenericArgumentClause` to replace the node's + /// current `unexpectedAfterGenericArgumentClause`, if present. + public func withUnexpectedAfterGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> KeyPathPropertyComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ParameterClauseSyntax(newData) + return KeyPathPropertyComponentSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndParameterList, - \Self.parameterList, - \Self.unexpectedBetweenParameterListAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeIdentifier, + \Self.identifier, + \Self.unexpectedBetweenIdentifierAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, + \Self.genericArgumentClause, + \Self.unexpectedAfterGenericArgumentClause, ]) } @@ -5451,7 +5407,7 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "parameters" + return nil case 4: return nil case 5: @@ -5464,175 +5420,241 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } } -extension ParameterClauseSyntax: CustomReflectable { +extension KeyPathPropertyComponentSyntax: 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, + "unexpectedBeforeIdentifier": unexpectedBeforeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "identifier": Syntax(identifier).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenIdentifierAndDeclNameArguments": unexpectedBetweenIdentifierAndDeclNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "declNameArguments": declNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause": unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "genericArgumentClause": genericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterGenericArgumentClause": unexpectedAfterGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ReturnClauseSyntax +// MARK: - KeyPathSubscriptComponentSyntax -public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { +public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .returnClause else { return nil } + guard node.raw.kind == .keyPathSubscriptComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ReturnClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `KeyPathSubscriptComponentSyntax` 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) { - assert(data.raw.kind == .returnClause) + assert(data.raw.kind == .keyPathSubscriptComponent) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeArrow: UnexpectedNodesSyntax? = nil, - arrow: TokenSyntax = .arrowToken(), - _ unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? = nil, - returnType: R, - _ unexpectedAfterReturnType: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? = nil, + leftBracket: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, + rightBracket: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightBracket: 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(), (unexpectedBeforeArrow, arrow, unexpectedBetweenArrowAndReturnType, returnType, unexpectedAfterReturnType))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBracket, leftBracket, unexpectedBetweenLeftBracketAndArgumentList, argumentList, unexpectedBetweenArgumentListAndRightBracket, rightBracket, unexpectedAfterRightBracket))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeArrow?.raw, - arrow.raw, - unexpectedBetweenArrowAndReturnType?.raw, - returnType.raw, - unexpectedAfterReturnType?.raw, + unexpectedBeforeLeftBracket?.raw, + leftBracket.raw, + unexpectedBetweenLeftBracketAndArgumentList?.raw, + argumentList.raw, + unexpectedBetweenArgumentListAndRightBracket?.raw, + rightBracket.raw, + unexpectedAfterRightBracket?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.returnClause, from: layout, arena: arena, + kind: SyntaxKind.keyPathSubscriptComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeArrow: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeArrow(value) + self = withUnexpectedBeforeLeftBracket(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeArrow` replaced. - /// - param newChild: The new `unexpectedBeforeArrow` to replace the node's - /// current `unexpectedBeforeArrow`, if present. - public func withUnexpectedBeforeArrow(_ newChild: UnexpectedNodesSyntax?) -> ReturnClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftBracket` replaced. + /// - param newChild: The new `unexpectedBeforeLeftBracket` to replace the node's + /// current `unexpectedBeforeLeftBracket`, if present. + public func withUnexpectedBeforeLeftBracket(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ReturnClauseSyntax(newData) + return KeyPathSubscriptComponentSyntax(newData) } - public var arrow: TokenSyntax { + public var leftBracket: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withArrow(value) + self = withLeftBracket(value) } } - /// Returns a copy of the receiver with its `arrow` replaced. - /// - param newChild: The new `arrow` to replace the node's - /// current `arrow`, if present. - public func withArrow(_ newChild: TokenSyntax) -> ReturnClauseSyntax { + /// Returns a copy of the receiver with its `leftBracket` replaced. + /// - param newChild: The new `leftBracket` to replace the node's + /// current `leftBracket`, if present. + public func withLeftBracket(_ newChild: TokenSyntax) -> KeyPathSubscriptComponentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ReturnClauseSyntax(newData) + return KeyPathSubscriptComponentSyntax(newData) } - public var unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenArrowAndReturnType(value) + self = withUnexpectedBetweenLeftBracketAndArgumentList(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenArrowAndReturnType` replaced. - /// - param newChild: The new `unexpectedBetweenArrowAndReturnType` to replace the node's - /// current `unexpectedBetweenArrowAndReturnType`, if present. - public func withUnexpectedBetweenArrowAndReturnType(_ newChild: UnexpectedNodesSyntax?) -> ReturnClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftBracketAndArgumentList` replaced. + /// - param newChild: The new `unexpectedBetweenLeftBracketAndArgumentList` to replace the node's + /// current `unexpectedBetweenLeftBracketAndArgumentList`, if present. + public func withUnexpectedBetweenLeftBracketAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ReturnClauseSyntax(newData) + return KeyPathSubscriptComponentSyntax(newData) } - public var returnType: TypeSyntax { + public var argumentList: TupleExprElementListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TypeSyntax(childData!) + return TupleExprElementListSyntax(childData!) } set(value) { - self = withReturnType(value) + self = withArgumentList(value) } } - /// Returns a copy of the receiver with its `returnType` replaced. - /// - param newChild: The new `returnType` to replace the node's - /// current `returnType`, if present. - public func withReturnType(_ newChild: TypeSyntax) -> ReturnClauseSyntax { + /// Adds the provided `Argument` to the node's `argumentList` + /// collection. + /// - param element: The new `Argument` to add to the node's + /// `argumentList` collection. + /// - returns: A copy of the receiver with the provided `Argument` + /// appended to its `argumentList` collection. + public func addArgument(_ element: TupleExprElementSyntax) -> KeyPathSubscriptComponentSyntax { + 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.tupleExprElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return KeyPathSubscriptComponentSyntax(newData) + } + + /// Returns a copy of the receiver with its `argumentList` replaced. + /// - param newChild: The new `argumentList` to replace the node's + /// current `argumentList`, if present. + public func withArgumentList(_ newChild: TupleExprElementListSyntax) -> KeyPathSubscriptComponentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ReturnClauseSyntax(newData) + return KeyPathSubscriptComponentSyntax(newData) } - public var unexpectedAfterReturnType: UnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterReturnType(value) + self = withUnexpectedBetweenArgumentListAndRightBracket(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterReturnType` replaced. - /// - param newChild: The new `unexpectedAfterReturnType` to replace the node's - /// current `unexpectedAfterReturnType`, if present. - public func withUnexpectedAfterReturnType(_ newChild: UnexpectedNodesSyntax?) -> ReturnClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenArgumentListAndRightBracket` replaced. + /// - param newChild: The new `unexpectedBetweenArgumentListAndRightBracket` to replace the node's + /// current `unexpectedBetweenArgumentListAndRightBracket`, if present. + public func withUnexpectedBetweenArgumentListAndRightBracket(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ReturnClauseSyntax(newData) + return KeyPathSubscriptComponentSyntax(newData) + } + + public var rightBracket: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withRightBracket(value) + } + } + + /// Returns a copy of the receiver with its `rightBracket` replaced. + /// - param newChild: The new `rightBracket` to replace the node's + /// current `rightBracket`, if present. + public func withRightBracket(_ newChild: TokenSyntax) -> KeyPathSubscriptComponentSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return KeyPathSubscriptComponentSyntax(newData) + } + + public var unexpectedAfterRightBracket: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightBracket(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightBracket` replaced. + /// - param newChild: The new `unexpectedAfterRightBracket` to replace the node's + /// current `unexpectedAfterRightBracket`, if present. + public func withUnexpectedAfterRightBracket(_ newChild: UnexpectedNodesSyntax?) -> KeyPathSubscriptComponentSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return KeyPathSubscriptComponentSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeArrow, - \Self.arrow, - \Self.unexpectedBetweenArrowAndReturnType, - \Self.returnType, - \Self.unexpectedAfterReturnType, + \Self.unexpectedBeforeLeftBracket, + \Self.leftBracket, + \Self.unexpectedBetweenLeftBracketAndArgumentList, + \Self.argumentList, + \Self.unexpectedBetweenArgumentListAndRightBracket, + \Self.rightBracket, + \Self.unexpectedAfterRightBracket, ]) } @@ -5645,279 +5667,324 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "return type" + return "arguments" case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension ReturnClauseSyntax: CustomReflectable { +extension KeyPathSubscriptComponentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeArrow": unexpectedBeforeArrow.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "arrow": Syntax(arrow).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenArrowAndReturnType": unexpectedBetweenArrowAndReturnType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "returnType": Syntax(returnType).asProtocol(SyntaxProtocol.self), - "unexpectedAfterReturnType": unexpectedAfterReturnType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLeftBracket": unexpectedBeforeLeftBracket.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftBracket": Syntax(leftBracket).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftBracketAndArgumentList": unexpectedBetweenLeftBracketAndArgumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "argumentList": Syntax(argumentList).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenArgumentListAndRightBracket": unexpectedBetweenArgumentListAndRightBracket.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightBracket": Syntax(rightBracket).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightBracket": unexpectedAfterRightBracket.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - FunctionSignatureSyntax +// MARK: - KeyPathOptionalComponentSyntax -public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { +public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionSignature else { return nil } + guard node.raw.kind == .keyPathOptionalComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `FunctionSignatureSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `KeyPathOptionalComponentSyntax` 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) { - assert(data.raw.kind == .functionSignature) + assert(data.raw.kind == .keyPathOptionalComponent) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeInput: UnexpectedNodesSyntax? = nil, - input: ParameterClauseSyntax, - _ unexpectedBetweenInputAndAsyncOrReasyncKeyword: UnexpectedNodesSyntax? = nil, - asyncOrReasyncKeyword: TokenSyntax? = nil, - _ unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: UnexpectedNodesSyntax? = nil, - throwsOrRethrowsKeyword: TokenSyntax? = nil, - _ unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax? = nil, - _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax, + _ unexpectedAfterQuestionOrExclamationMark: 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(), (unexpectedBeforeInput, input, unexpectedBetweenInputAndAsyncOrReasyncKeyword, asyncOrReasyncKeyword, unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword, throwsOrRethrowsKeyword, unexpectedBetweenThrowsOrRethrowsKeywordAndOutput, output, unexpectedAfterOutput))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeInput?.raw, - input.raw, - unexpectedBetweenInputAndAsyncOrReasyncKeyword?.raw, - asyncOrReasyncKeyword?.raw, - unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword?.raw, - throwsOrRethrowsKeyword?.raw, - unexpectedBetweenThrowsOrRethrowsKeywordAndOutput?.raw, - output?.raw, - unexpectedAfterOutput?.raw, + unexpectedBeforeQuestionOrExclamationMark?.raw, + questionOrExclamationMark.raw, + unexpectedAfterQuestionOrExclamationMark?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionSignature, from: layout, arena: arena, + kind: SyntaxKind.keyPathOptionalComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeInput: UnexpectedNodesSyntax? { + public var unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeInput(value) + self = withUnexpectedBeforeQuestionOrExclamationMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeInput` replaced. - /// - param newChild: The new `unexpectedBeforeInput` to replace the node's - /// current `unexpectedBeforeInput`, if present. - public func withUnexpectedBeforeInput(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeQuestionOrExclamationMark` replaced. + /// - param newChild: The new `unexpectedBeforeQuestionOrExclamationMark` to replace the node's + /// current `unexpectedBeforeQuestionOrExclamationMark`, if present. + public func withUnexpectedBeforeQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> KeyPathOptionalComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + return KeyPathOptionalComponentSyntax(newData) } - public var input: ParameterClauseSyntax { + public var questionOrExclamationMark: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return ParameterClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withInput(value) + self = withQuestionOrExclamationMark(value) } } - /// Returns a copy of the receiver with its `input` replaced. - /// - param newChild: The new `input` to replace the node's - /// current `input`, if present. - public func withInput(_ newChild: ParameterClauseSyntax) -> FunctionSignatureSyntax { + /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced. + /// - param newChild: The new `questionOrExclamationMark` to replace the node's + /// current `questionOrExclamationMark`, if present. + public func withQuestionOrExclamationMark(_ newChild: TokenSyntax) -> KeyPathOptionalComponentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + return KeyPathOptionalComponentSyntax(newData) } - public var unexpectedBetweenInputAndAsyncOrReasyncKeyword: UnexpectedNodesSyntax? { + public var unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenInputAndAsyncOrReasyncKeyword(value) + self = withUnexpectedAfterQuestionOrExclamationMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenInputAndAsyncOrReasyncKeyword` replaced. - /// - param newChild: The new `unexpectedBetweenInputAndAsyncOrReasyncKeyword` to replace the node's - /// current `unexpectedBetweenInputAndAsyncOrReasyncKeyword`, if present. - public func withUnexpectedBetweenInputAndAsyncOrReasyncKeyword(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterQuestionOrExclamationMark` replaced. + /// - param newChild: The new `unexpectedAfterQuestionOrExclamationMark` to replace the node's + /// current `unexpectedAfterQuestionOrExclamationMark`, if present. + public func withUnexpectedAfterQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> KeyPathOptionalComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + return KeyPathOptionalComponentSyntax(newData) } - public var asyncOrReasyncKeyword: TokenSyntax? { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withAsyncOrReasyncKeyword(value) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeQuestionOrExclamationMark, + \Self.questionOrExclamationMark, + \Self.unexpectedAfterQuestionOrExclamationMark, + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + default: + fatalError("Invalid index") } } +} - /// Returns a copy of the receiver with its `asyncOrReasyncKeyword` replaced. - /// - param newChild: The new `asyncOrReasyncKeyword` to replace the node's - /// current `asyncOrReasyncKeyword`, if present. - public func withAsyncOrReasyncKeyword(_ newChild: TokenSyntax?) -> FunctionSignatureSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) +extension KeyPathOptionalComponentSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeQuestionOrExclamationMark": unexpectedBeforeQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "questionOrExclamationMark": Syntax(questionOrExclamationMark).asProtocol(SyntaxProtocol.self), + "unexpectedAfterQuestionOrExclamationMark": unexpectedAfterQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) } +} - public var unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: UnexpectedNodesSyntax? { +// MARK: - YieldExprListElementSyntax + +public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .yieldExprListElement else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `YieldExprListElementSyntax` 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) { + assert(data.raw.kind == .yieldExprListElement) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedAfterComma: 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(), (unexpectedBeforeExpression, expression, unexpectedBetweenExpressionAndComma, comma, unexpectedAfterComma))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndComma?.raw, + comma?.raw, + unexpectedAfterComma?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.yieldExprListElement, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword(value) + self = withUnexpectedBeforeExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword` replaced. - /// - param newChild: The new `unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword` to replace the node's - /// current `unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword`, if present. - public func withUnexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. + /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's + /// current `unexpectedBeforeExpression`, if present. + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> YieldExprListElementSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return YieldExprListElementSyntax(newData) } - public var throwsOrRethrowsKeyword: TokenSyntax? { + public var expression: ExprSyntax { get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + return ExprSyntax(childData!) } set(value) { - self = withThrowsOrRethrowsKeyword(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `throwsOrRethrowsKeyword` replaced. - /// - param newChild: The new `throwsOrRethrowsKeyword` to replace the node's - /// current `throwsOrRethrowsKeyword`, if present. - public func withThrowsOrRethrowsKeyword(_ newChild: TokenSyntax?) -> FunctionSignatureSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax) -> YieldExprListElementSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return YieldExprListElementSyntax(newData) } - public var unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenThrowsOrRethrowsKeywordAndOutput(value) + self = withUnexpectedBetweenExpressionAndComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenThrowsOrRethrowsKeywordAndOutput` replaced. - /// - param newChild: The new `unexpectedBetweenThrowsOrRethrowsKeywordAndOutput` to replace the node's - /// current `unexpectedBetweenThrowsOrRethrowsKeywordAndOutput`, if present. - public func withUnexpectedBetweenThrowsOrRethrowsKeywordAndOutput(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndComma` to replace the node's + /// current `unexpectedBetweenExpressionAndComma`, if present. + public func withUnexpectedBetweenExpressionAndComma(_ newChild: UnexpectedNodesSyntax?) -> YieldExprListElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return YieldExprListElementSyntax(newData) } - public var output: ReturnClauseSyntax? { + public var comma: TokenSyntax? { get { - let childData = data.child(at: 7, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return ReturnClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withOutput(value) + self = withComma(value) } } - /// Returns a copy of the receiver with its `output` replaced. - /// - param newChild: The new `output` to replace the node's - /// current `output`, if present. - public func withOutput(_ newChild: ReturnClauseSyntax?) -> FunctionSignatureSyntax { + /// Returns a copy of the receiver with its `comma` replaced. + /// - param newChild: The new `comma` to replace the node's + /// current `comma`, if present. + public func withComma(_ newChild: TokenSyntax?) -> YieldExprListElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return YieldExprListElementSyntax(newData) } - public var unexpectedAfterOutput: UnexpectedNodesSyntax? { + public var unexpectedAfterComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterOutput(value) + self = withUnexpectedAfterComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterOutput` replaced. - /// - param newChild: The new `unexpectedAfterOutput` to replace the node's - /// current `unexpectedAfterOutput`, if present. - public func withUnexpectedAfterOutput(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterComma` replaced. + /// - param newChild: The new `unexpectedAfterComma` to replace the node's + /// current `unexpectedAfterComma`, if present. + public func withUnexpectedAfterComma(_ newChild: UnexpectedNodesSyntax?) -> YieldExprListElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return YieldExprListElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeInput, - \Self.input, - \Self.unexpectedBetweenInputAndAsyncOrReasyncKeyword, - \Self.asyncOrReasyncKeyword, - \Self.unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword, - \Self.throwsOrRethrowsKeyword, - \Self.unexpectedBetweenThrowsOrRethrowsKeywordAndOutput, - \Self.output, - \Self.unexpectedAfterOutput, + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndComma, + \Self.comma, + \Self.unexpectedAfterComma, ]) } @@ -5933,340 +6000,179 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension FunctionSignatureSyntax: CustomReflectable { +extension YieldExprListElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeInput": unexpectedBeforeInput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "input": Syntax(input).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenInputAndAsyncOrReasyncKeyword": unexpectedBetweenInputAndAsyncOrReasyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "asyncOrReasyncKeyword": asyncOrReasyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword": unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "throwsOrRethrowsKeyword": throwsOrRethrowsKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenThrowsOrRethrowsKeywordAndOutput": unexpectedBetweenThrowsOrRethrowsKeywordAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterOutput": unexpectedAfterOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeExpression": unexpectedBeforeExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndComma": unexpectedBetweenExpressionAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterComma": unexpectedAfterComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - IfConfigClauseSyntax - -public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { - public enum Elements: SyntaxChildChoices { - case `statements`(CodeBlockItemListSyntax) - case `switchCases`(SwitchCaseListSyntax) - case `decls`(MemberDeclListSyntax) - case `postfixExpression`(ExprSyntax) - case `attributes`(AttributeListSyntax) - public var _syntaxNode: Syntax { - switch self { - case .statements(let node): return node._syntaxNode - case .switchCases(let node): return node._syntaxNode - case .decls(let node): return node._syntaxNode - case .postfixExpression(let node): return node._syntaxNode - case .attributes(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: CodeBlockItemListSyntax) { - self = .statements(node) - } - public init(_ node: SwitchCaseListSyntax) { - self = .switchCases(node) - } - public init(_ node: MemberDeclListSyntax) { - self = .decls(node) - } - public init(_ node: Node) { - self = .postfixExpression(ExprSyntax(node)) - } - public init(_ node: AttributeListSyntax) { - self = .attributes(node) - } - public init?(_ node: S) { - if let node = node.as(CodeBlockItemListSyntax.self) { - self = .statements(node) - return - } - if let node = node.as(SwitchCaseListSyntax.self) { - self = .switchCases(node) - return - } - if let node = node.as(MemberDeclListSyntax.self) { - self = .decls(node) - return - } - if let node = node.as(ExprSyntax.self) { - self = .postfixExpression(node) - return - } - if let node = node.as(AttributeListSyntax.self) { - self = .attributes(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(CodeBlockItemListSyntax.self), - .node(SwitchCaseListSyntax.self), - .node(MemberDeclListSyntax.self), - .node(ExprSyntax.self), - .node(AttributeListSyntax.self), - ]) - } - } +// MARK: - TypeInitializerClauseSyntax +public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .ifConfigClause else { return nil } + guard node.raw.kind == .typeInitializerClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `IfConfigClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `TypeInitializerClauseSyntax` 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) { - assert(data.raw.kind == .ifConfigClause) + assert(data.raw.kind == .typeInitializerClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, - poundKeyword: TokenSyntax, - _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, - condition: C? = nil, - _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, - elements: Elements? = nil, - _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, + equal: TokenSyntax = .equalToken(), + _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, + value: V, + _ unexpectedAfterValue: 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(), (unexpectedBeforePoundKeyword, poundKeyword, unexpectedBetweenPoundKeywordAndCondition, condition, unexpectedBetweenConditionAndElements, elements, unexpectedAfterElements))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforePoundKeyword?.raw, - poundKeyword.raw, - unexpectedBetweenPoundKeywordAndCondition?.raw, - condition?.raw, - unexpectedBetweenConditionAndElements?.raw, - elements?.raw, - unexpectedAfterElements?.raw, + unexpectedBeforeEqual?.raw, + equal.raw, + unexpectedBetweenEqualAndValue?.raw, + value.raw, + unexpectedAfterValue?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifConfigClause, from: layout, arena: arena, + kind: SyntaxKind.typeInitializerClause, 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, - _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, - poundKeyword: TokenSyntax, - _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, - condition: MissingExprSyntax? = nil, - _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, - elements: Elements? = nil, - _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforePoundKeyword, - poundKeyword: poundKeyword, - unexpectedBetweenPoundKeywordAndCondition, - condition: Optional.none, - unexpectedBetweenConditionAndElements, - elements: elements, - unexpectedAfterElements, - trailingTrivia: trailingTrivia - ) - } - - public var unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundKeyword(value) + self = withUnexpectedBeforeEqual(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundKeyword` replaced. - /// - param newChild: The new `unexpectedBeforePoundKeyword` to replace the node's - /// current `unexpectedBeforePoundKeyword`, if present. - public func withUnexpectedBeforePoundKeyword(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeEqual` replaced. + /// - param newChild: The new `unexpectedBeforeEqual` to replace the node's + /// current `unexpectedBeforeEqual`, if present. + public func withUnexpectedBeforeEqual(_ newChild: UnexpectedNodesSyntax?) -> TypeInitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return IfConfigClauseSyntax(newData) + return TypeInitializerClauseSyntax(newData) } - public var poundKeyword: TokenSyntax { + public var equal: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withPoundKeyword(value) + self = withEqual(value) } } - /// Returns a copy of the receiver with its `poundKeyword` replaced. - /// - param newChild: The new `poundKeyword` to replace the node's - /// current `poundKeyword`, if present. - public func withPoundKeyword(_ newChild: TokenSyntax) -> IfConfigClauseSyntax { + /// Returns a copy of the receiver with its `equal` replaced. + /// - param newChild: The new `equal` to replace the node's + /// current `equal`, if present. + public func withEqual(_ newChild: TokenSyntax) -> TypeInitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return IfConfigClauseSyntax(newData) + return TypeInitializerClauseSyntax(newData) } - public var unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? { + public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPoundKeywordAndCondition(value) + self = withUnexpectedBetweenEqualAndValue(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPoundKeywordAndCondition` replaced. - /// - param newChild: The new `unexpectedBetweenPoundKeywordAndCondition` to replace the node's - /// current `unexpectedBetweenPoundKeywordAndCondition`, if present. - public func withUnexpectedBetweenPoundKeywordAndCondition(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenEqualAndValue` replaced. + /// - param newChild: The new `unexpectedBetweenEqualAndValue` to replace the node's + /// current `unexpectedBetweenEqualAndValue`, if present. + public func withUnexpectedBetweenEqualAndValue(_ newChild: UnexpectedNodesSyntax?) -> TypeInitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return IfConfigClauseSyntax(newData) + return TypeInitializerClauseSyntax(newData) } - public var condition: ExprSyntax? { + public var value: TypeSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return ExprSyntax(childData!) + return TypeSyntax(childData!) } set(value) { - self = withCondition(value) + self = withValue(value) } } - /// Returns a copy of the receiver with its `condition` replaced. - /// - param newChild: The new `condition` to replace the node's - /// current `condition`, if present. - public func withCondition(_ newChild: ExprSyntax?) -> IfConfigClauseSyntax { + /// Returns a copy of the receiver with its `value` replaced. + /// - param newChild: The new `value` to replace the node's + /// current `value`, if present. + public func withValue(_ newChild: TypeSyntax) -> TypeInitializerClauseSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return IfConfigClauseSyntax(newData) + return TypeInitializerClauseSyntax(newData) } - public var unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? { + public var unexpectedAfterValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenConditionAndElements(value) + self = withUnexpectedAfterValue(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenConditionAndElements` replaced. - /// - param newChild: The new `unexpectedBetweenConditionAndElements` to replace the node's - /// current `unexpectedBetweenConditionAndElements`, if present. - public func withUnexpectedBetweenConditionAndElements(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterValue` replaced. + /// - param newChild: The new `unexpectedAfterValue` to replace the node's + /// current `unexpectedAfterValue`, if present. + public func withUnexpectedAfterValue(_ newChild: UnexpectedNodesSyntax?) -> TypeInitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return IfConfigClauseSyntax(newData) - } - - public var elements: Elements? { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return Elements(childData!) - } - set(value) { - self = withElements(value) - } - } - - /// Returns a copy of the receiver with its `elements` replaced. - /// - param newChild: The new `elements` to replace the node's - /// current `elements`, if present. - public func withElements(_ newChild: Elements?) -> IfConfigClauseSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return IfConfigClauseSyntax(newData) - } - - public var unexpectedAfterElements: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterElements(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterElements` replaced. - /// - param newChild: The new `unexpectedAfterElements` to replace the node's - /// current `unexpectedAfterElements`, if present. - public func withUnexpectedAfterElements(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return IfConfigClauseSyntax(newData) + return TypeInitializerClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundKeyword, - \Self.poundKeyword, - \Self.unexpectedBetweenPoundKeywordAndCondition, - \Self.condition, - \Self.unexpectedBetweenConditionAndElements, - \Self.elements, - \Self.unexpectedAfterElements, + \Self.unexpectedBeforeEqual, + \Self.equal, + \Self.unexpectedBetweenEqualAndValue, + \Self.value, + \Self.unexpectedAfterValue, ]) } @@ -6279,423 +6185,442 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "condition" + return "type" case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension IfConfigClauseSyntax: CustomReflectable { +extension TypeInitializerClauseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundKeyword": unexpectedBeforePoundKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundKeyword": Syntax(poundKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPoundKeywordAndCondition": unexpectedBetweenPoundKeywordAndCondition.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "condition": condition.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenConditionAndElements": unexpectedBetweenConditionAndElements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "elements": elements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterElements": unexpectedAfterElements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeEqual": unexpectedBeforeEqual.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "equal": Syntax(equal).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenEqualAndValue": unexpectedBetweenEqualAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "value": Syntax(value).asProtocol(SyntaxProtocol.self), + "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - PoundSourceLocationArgsSyntax +// MARK: - ParameterClauseSyntax -public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundSourceLocationArgs else { return nil } + guard node.raw.kind == .parameterClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PoundSourceLocationArgsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ParameterClauseSyntax` 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) { - assert(data.raw.kind == .poundSourceLocationArgs) + assert(data.raw.kind == .parameterClause) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? = nil, - fileArgLabel: TokenSyntax = .identifier("file"), - _ unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? = nil, - fileArgColon: TokenSyntax = .colonToken(), - _ unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? = nil, - fileName: TokenSyntax, - _ unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? = nil, - lineArgLabel: TokenSyntax = .identifier("line"), - _ unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? = nil, - lineArgColon: TokenSyntax = .colonToken(), - _ unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? = nil, - lineNumber: TokenSyntax, - _ unexpectedAfterLineNumber: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, + parameterList: FunctionParameterListSyntax, + _ 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(), (unexpectedBeforeFileArgLabel, fileArgLabel, unexpectedBetweenFileArgLabelAndFileArgColon, fileArgColon, unexpectedBetweenFileArgColonAndFileName, fileName, unexpectedBetweenFileNameAndComma, comma, unexpectedBetweenCommaAndLineArgLabel, lineArgLabel, unexpectedBetweenLineArgLabelAndLineArgColon, lineArgColon, unexpectedBetweenLineArgColonAndLineNumber, lineNumber, unexpectedAfterLineNumber))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndParameterList, parameterList, unexpectedBetweenParameterListAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeFileArgLabel?.raw, - fileArgLabel.raw, - unexpectedBetweenFileArgLabelAndFileArgColon?.raw, - fileArgColon.raw, - unexpectedBetweenFileArgColonAndFileName?.raw, - fileName.raw, - unexpectedBetweenFileNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndLineArgLabel?.raw, - lineArgLabel.raw, - unexpectedBetweenLineArgLabelAndLineArgColon?.raw, - lineArgColon.raw, - unexpectedBetweenLineArgColonAndLineNumber?.raw, - lineNumber.raw, - unexpectedAfterLineNumber?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndParameterList?.raw, + parameterList.raw, + unexpectedBetweenParameterListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.poundSourceLocationArgs, from: layout, arena: arena, + kind: SyntaxKind.parameterClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeFileArgLabel(value) + self = withUnexpectedBeforeLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeFileArgLabel` replaced. - /// - param newChild: The new `unexpectedBeforeFileArgLabel` to replace the node's - /// current `unexpectedBeforeFileArgLabel`, if present. - public func withUnexpectedBeforeFileArgLabel(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. + /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's + /// current `unexpectedBeforeLeftParen`, if present. + public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + return ParameterClauseSyntax(newData) } - public var fileArgLabel: TokenSyntax { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withFileArgLabel(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `fileArgLabel` replaced. - /// - param newChild: The new `fileArgLabel` to replace the node's - /// current `fileArgLabel`, if present. - public func withFileArgLabel(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> ParameterClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + return ParameterClauseSyntax(newData) } - public var unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenFileArgLabelAndFileArgColon(value) + self = withUnexpectedBetweenLeftParenAndParameterList(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenFileArgLabelAndFileArgColon` replaced. - /// - param newChild: The new `unexpectedBetweenFileArgLabelAndFileArgColon` to replace the node's - /// current `unexpectedBetweenFileArgLabelAndFileArgColon`, if present. - public func withUnexpectedBetweenFileArgLabelAndFileArgColon(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndParameterList` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndParameterList` to replace the node's + /// current `unexpectedBetweenLeftParenAndParameterList`, if present. + public func withUnexpectedBetweenLeftParenAndParameterList(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + return ParameterClauseSyntax(newData) } - public var fileArgColon: TokenSyntax { + public var parameterList: FunctionParameterListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + return FunctionParameterListSyntax(childData!) } set(value) { - self = withFileArgColon(value) + self = withParameterList(value) } } - /// Returns a copy of the receiver with its `fileArgColon` replaced. - /// - param newChild: The new `fileArgColon` to replace the node's - /// current `fileArgColon`, if present. - public func withFileArgColon(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + /// 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: FunctionParameterSyntax) -> ParameterClauseSyntax { + 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.functionParameterList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return ParameterClauseSyntax(newData) + } + + /// Returns a copy of the receiver with its `parameterList` replaced. + /// - param newChild: The new `parameterList` to replace the node's + /// current `parameterList`, if present. + public func withParameterList(_ newChild: FunctionParameterListSyntax) -> ParameterClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + return ParameterClauseSyntax(newData) } - public var unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? { + public var unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenFileArgColonAndFileName(value) + self = withUnexpectedBetweenParameterListAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenFileArgColonAndFileName` replaced. - /// - param newChild: The new `unexpectedBetweenFileArgColonAndFileName` to replace the node's - /// current `unexpectedBetweenFileArgColonAndFileName`, if present. - public func withUnexpectedBetweenFileArgColonAndFileName(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenParameterListAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenParameterListAndRightParen` to replace the node's + /// current `unexpectedBetweenParameterListAndRightParen`, if present. + public func withUnexpectedBetweenParameterListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + return ParameterClauseSyntax(newData) } - public var fileName: TokenSyntax { + public var rightParen: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withFileName(value) + self = withRightParen(value) } } - /// Returns a copy of the receiver with its `fileName` replaced. - /// - param newChild: The new `fileName` to replace the node's - /// current `fileName`, if present. - public func withFileName(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> ParameterClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + return ParameterClauseSyntax(newData) } - public var unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenFileNameAndComma(value) + self = withUnexpectedAfterRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenFileNameAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenFileNameAndComma` to replace the node's - /// current `unexpectedBetweenFileNameAndComma`, if present. - public func withUnexpectedBetweenFileNameAndComma(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> ParameterClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + return ParameterClauseSyntax(newData) } - public var comma: TokenSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withComma(value) + 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") } } +} - /// Returns a copy of the receiver with its `comma` replaced. - /// - param newChild: The new `comma` to replace the node's - /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) +extension ParameterClauseSyntax: 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, + ]) } +} - public var unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? { +// MARK: - ReturnClauseSyntax + +public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .returnClause else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `ReturnClauseSyntax` 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) { + assert(data.raw.kind == .returnClause) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeArrow: UnexpectedNodesSyntax? = nil, + arrow: TokenSyntax = .arrowToken(), + _ unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? = nil, + returnType: R, + _ unexpectedAfterReturnType: 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(), (unexpectedBeforeArrow, arrow, unexpectedBetweenArrowAndReturnType, returnType, unexpectedAfterReturnType))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeArrow?.raw, + arrow.raw, + unexpectedBetweenArrowAndReturnType?.raw, + returnType.raw, + unexpectedAfterReturnType?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.returnClause, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeArrow: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndLineArgLabel(value) + self = withUnexpectedBeforeArrow(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndLineArgLabel` replaced. - /// - param newChild: The new `unexpectedBetweenCommaAndLineArgLabel` to replace the node's - /// current `unexpectedBetweenCommaAndLineArgLabel`, if present. - public func withUnexpectedBetweenCommaAndLineArgLabel(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeArrow` replaced. + /// - param newChild: The new `unexpectedBeforeArrow` to replace the node's + /// current `unexpectedBeforeArrow`, if present. + public func withUnexpectedBeforeArrow(_ newChild: UnexpectedNodesSyntax?) -> ReturnClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return ReturnClauseSyntax(newData) } - public var lineArgLabel: TokenSyntax { + public var arrow: TokenSyntax { get { - let childData = data.child(at: 9, parent: Syntax(self)) + let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLineArgLabel(value) + self = withArrow(value) } } - /// Returns a copy of the receiver with its `lineArgLabel` replaced. - /// - param newChild: The new `lineArgLabel` to replace the node's - /// current `lineArgLabel`, if present. - public func withLineArgLabel(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `arrow` replaced. + /// - param newChild: The new `arrow` to replace the node's + /// current `arrow`, if present. + public func withArrow(_ newChild: TokenSyntax) -> ReturnClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return ReturnClauseSyntax(newData) } - public var unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLineArgLabelAndLineArgColon(value) + self = withUnexpectedBetweenArrowAndReturnType(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLineArgLabelAndLineArgColon` replaced. - /// - param newChild: The new `unexpectedBetweenLineArgLabelAndLineArgColon` to replace the node's - /// current `unexpectedBetweenLineArgLabelAndLineArgColon`, if present. - public func withUnexpectedBetweenLineArgLabelAndLineArgColon(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenArrowAndReturnType` replaced. + /// - param newChild: The new `unexpectedBetweenArrowAndReturnType` to replace the node's + /// current `unexpectedBetweenArrowAndReturnType`, if present. + public func withUnexpectedBetweenArrowAndReturnType(_ newChild: UnexpectedNodesSyntax?) -> ReturnClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return ReturnClauseSyntax(newData) } - public var lineArgColon: TokenSyntax { + public var returnType: TypeSyntax { get { - let childData = data.child(at: 11, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 3, parent: Syntax(self)) + return TypeSyntax(childData!) } set(value) { - self = withLineArgColon(value) + self = withReturnType(value) } } - /// Returns a copy of the receiver with its `lineArgColon` replaced. - /// - param newChild: The new `lineArgColon` to replace the node's - /// current `lineArgColon`, if present. - public func withLineArgColon(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 11, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) - } - - public var unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 12, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLineArgColonAndLineNumber(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLineArgColonAndLineNumber` replaced. - /// - param newChild: The new `unexpectedBetweenLineArgColonAndLineNumber` to replace the node's - /// current `unexpectedBetweenLineArgColonAndLineNumber`, if present. - public func withUnexpectedBetweenLineArgColonAndLineNumber(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 12, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) - } - - public var lineNumber: TokenSyntax { - get { - let childData = data.child(at: 13, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withLineNumber(value) - } - } - - /// Returns a copy of the receiver with its `lineNumber` replaced. - /// - param newChild: The new `lineNumber` to replace the node's - /// current `lineNumber`, if present. - public func withLineNumber(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `returnType` replaced. + /// - param newChild: The new `returnType` to replace the node's + /// current `returnType`, if present. + public func withReturnType(_ newChild: TypeSyntax) -> ReturnClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 13, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ReturnClauseSyntax(newData) } - public var unexpectedAfterLineNumber: UnexpectedNodesSyntax? { + public var unexpectedAfterReturnType: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 14, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterLineNumber(value) + self = withUnexpectedAfterReturnType(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterLineNumber` replaced. - /// - param newChild: The new `unexpectedAfterLineNumber` to replace the node's - /// current `unexpectedAfterLineNumber`, if present. - public func withUnexpectedAfterLineNumber(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterReturnType` replaced. + /// - param newChild: The new `unexpectedAfterReturnType` to replace the node's + /// current `unexpectedAfterReturnType`, if present. + public func withUnexpectedAfterReturnType(_ newChild: UnexpectedNodesSyntax?) -> ReturnClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 14, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ReturnClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeFileArgLabel, - \Self.fileArgLabel, - \Self.unexpectedBetweenFileArgLabelAndFileArgColon, - \Self.fileArgColon, - \Self.unexpectedBetweenFileArgColonAndFileName, - \Self.fileName, - \Self.unexpectedBetweenFileNameAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndLineArgLabel, - \Self.lineArgLabel, - \Self.unexpectedBetweenLineArgLabelAndLineArgColon, - \Self.lineArgColon, - \Self.unexpectedBetweenLineArgColonAndLineNumber, - \Self.lineNumber, - \Self.unexpectedAfterLineNumber, + \Self.unexpectedBeforeArrow, + \Self.arrow, + \Self.unexpectedBetweenArrowAndReturnType, + \Self.returnType, + \Self.unexpectedAfterReturnType, ]) } @@ -6708,259 +6633,279 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "return type" case 4: return nil - case 5: - return "file name" - 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 "line number" - case 14: - return nil default: fatalError("Invalid index") } } } -extension PoundSourceLocationArgsSyntax: CustomReflectable { +extension ReturnClauseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeFileArgLabel": unexpectedBeforeFileArgLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "fileArgLabel": Syntax(fileArgLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenFileArgLabelAndFileArgColon": unexpectedBetweenFileArgLabelAndFileArgColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "fileArgColon": Syntax(fileArgColon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenFileArgColonAndFileName": unexpectedBetweenFileArgColonAndFileName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "fileName": Syntax(fileName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenFileNameAndComma": unexpectedBetweenFileNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCommaAndLineArgLabel": unexpectedBetweenCommaAndLineArgLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "lineArgLabel": Syntax(lineArgLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLineArgLabelAndLineArgColon": unexpectedBetweenLineArgLabelAndLineArgColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "lineArgColon": Syntax(lineArgColon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLineArgColonAndLineNumber": unexpectedBetweenLineArgColonAndLineNumber.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "lineNumber": Syntax(lineNumber).asProtocol(SyntaxProtocol.self), - "unexpectedAfterLineNumber": unexpectedAfterLineNumber.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeArrow": unexpectedBeforeArrow.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "arrow": Syntax(arrow).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenArrowAndReturnType": unexpectedBetweenArrowAndReturnType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "returnType": Syntax(returnType).asProtocol(SyntaxProtocol.self), + "unexpectedAfterReturnType": unexpectedAfterReturnType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DeclModifierDetailSyntax +// MARK: - FunctionSignatureSyntax -public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { +public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifierDetail else { return nil } + guard node.raw.kind == .functionSignature else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclModifierDetailSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `FunctionSignatureSyntax` 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) { - assert(data.raw.kind == .declModifierDetail) + assert(data.raw.kind == .functionSignature) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, - detail: TokenSyntax, - _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeInput: UnexpectedNodesSyntax? = nil, + input: ParameterClauseSyntax, + _ unexpectedBetweenInputAndAsyncOrReasyncKeyword: UnexpectedNodesSyntax? = nil, + asyncOrReasyncKeyword: TokenSyntax? = nil, + _ unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: UnexpectedNodesSyntax? = nil, + throwsOrRethrowsKeyword: TokenSyntax? = nil, + _ unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: UnexpectedNodesSyntax? = nil, + output: ReturnClauseSyntax? = nil, + _ unexpectedAfterOutput: 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, unexpectedBetweenLeftParenAndDetail, detail, unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeInput, input, unexpectedBetweenInputAndAsyncOrReasyncKeyword, asyncOrReasyncKeyword, unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword, throwsOrRethrowsKeyword, unexpectedBetweenThrowsOrRethrowsKeywordAndOutput, output, unexpectedAfterOutput))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndDetail?.raw, - detail.raw, - unexpectedBetweenDetailAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeInput?.raw, + input.raw, + unexpectedBetweenInputAndAsyncOrReasyncKeyword?.raw, + asyncOrReasyncKeyword?.raw, + unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword?.raw, + throwsOrRethrowsKeyword?.raw, + unexpectedBetweenThrowsOrRethrowsKeywordAndOutput?.raw, + output?.raw, + unexpectedAfterOutput?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifierDetail, from: layout, arena: arena, + kind: SyntaxKind.functionSignature, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeInput: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftParen(value) + self = withUnexpectedBeforeInput(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. - /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's - /// current `unexpectedBeforeLeftParen`, if present. - public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeInput` replaced. + /// - param newChild: The new `unexpectedBeforeInput` to replace the node's + /// current `unexpectedBeforeInput`, if present. + public func withUnexpectedBeforeInput(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DeclModifierDetailSyntax(newData) + return FunctionSignatureSyntax(newData) } - public var leftParen: TokenSyntax { + public var input: ParameterClauseSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return ParameterClauseSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withInput(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> DeclModifierDetailSyntax { + /// Returns a copy of the receiver with its `input` replaced. + /// - param newChild: The new `input` to replace the node's + /// current `input`, if present. + public func withInput(_ newChild: ParameterClauseSyntax) -> FunctionSignatureSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DeclModifierDetailSyntax(newData) + return FunctionSignatureSyntax(newData) } - public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenInputAndAsyncOrReasyncKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndDetail(value) + self = withUnexpectedBetweenInputAndAsyncOrReasyncKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndDetail` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndDetail` to replace the node's - /// current `unexpectedBetweenLeftParenAndDetail`, if present. - public func withUnexpectedBetweenLeftParenAndDetail(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenInputAndAsyncOrReasyncKeyword` replaced. + /// - param newChild: The new `unexpectedBetweenInputAndAsyncOrReasyncKeyword` to replace the node's + /// current `unexpectedBetweenInputAndAsyncOrReasyncKeyword`, if present. + public func withUnexpectedBetweenInputAndAsyncOrReasyncKeyword(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DeclModifierDetailSyntax(newData) + return FunctionSignatureSyntax(newData) } - public var detail: TokenSyntax { + public var asyncOrReasyncKeyword: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withDetail(value) + self = withAsyncOrReasyncKeyword(value) } } - /// Returns a copy of the receiver with its `detail` replaced. - /// - param newChild: The new `detail` to replace the node's - /// current `detail`, if present. - public func withDetail(_ newChild: TokenSyntax) -> DeclModifierDetailSyntax { + /// Returns a copy of the receiver with its `asyncOrReasyncKeyword` replaced. + /// - param newChild: The new `asyncOrReasyncKeyword` to replace the node's + /// current `asyncOrReasyncKeyword`, if present. + public func withAsyncOrReasyncKeyword(_ newChild: TokenSyntax?) -> FunctionSignatureSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DeclModifierDetailSyntax(newData) + return FunctionSignatureSyntax(newData) } - public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDetailAndRightParen(value) + self = withUnexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDetailAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenDetailAndRightParen` to replace the node's - /// current `unexpectedBetweenDetailAndRightParen`, if present. - public func withUnexpectedBetweenDetailAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword` replaced. + /// - param newChild: The new `unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword` to replace the node's + /// current `unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword`, if present. + public func withUnexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DeclModifierDetailSyntax(newData) + return FunctionSignatureSyntax(newData) } - public var rightParen: TokenSyntax { + public var throwsOrRethrowsKeyword: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withThrowsOrRethrowsKeyword(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> DeclModifierDetailSyntax { + /// Returns a copy of the receiver with its `throwsOrRethrowsKeyword` replaced. + /// - param newChild: The new `throwsOrRethrowsKeyword` to replace the node's + /// current `throwsOrRethrowsKeyword`, if present. + public func withThrowsOrRethrowsKeyword(_ newChild: TokenSyntax?) -> FunctionSignatureSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DeclModifierDetailSyntax(newData) + return FunctionSignatureSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedBetweenThrowsOrRethrowsKeywordAndOutput(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenThrowsOrRethrowsKeywordAndOutput` replaced. + /// - param newChild: The new `unexpectedBetweenThrowsOrRethrowsKeywordAndOutput` to replace the node's + /// current `unexpectedBetweenThrowsOrRethrowsKeywordAndOutput`, if present. + public func withUnexpectedBetweenThrowsOrRethrowsKeywordAndOutput(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DeclModifierDetailSyntax(newData) + return FunctionSignatureSyntax(newData) + } + + public var output: ReturnClauseSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return ReturnClauseSyntax(childData!) + } + set(value) { + self = withOutput(value) + } + } + + /// Returns a copy of the receiver with its `output` replaced. + /// - param newChild: The new `output` to replace the node's + /// current `output`, if present. + public func withOutput(_ newChild: ReturnClauseSyntax?) -> FunctionSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return FunctionSignatureSyntax(newData) + } + + public var unexpectedAfterOutput: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterOutput(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterOutput` replaced. + /// - param newChild: The new `unexpectedAfterOutput` to replace the node's + /// current `unexpectedAfterOutput`, if present. + public func withUnexpectedAfterOutput(_ newChild: UnexpectedNodesSyntax?) -> FunctionSignatureSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return FunctionSignatureSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndDetail, - \Self.detail, - \Self.unexpectedBetweenDetailAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeInput, + \Self.input, + \Self.unexpectedBetweenInputAndAsyncOrReasyncKeyword, + \Self.asyncOrReasyncKeyword, + \Self.unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword, + \Self.throwsOrRethrowsKeyword, + \Self.unexpectedBetweenThrowsOrRethrowsKeywordAndOutput, + \Self.output, + \Self.unexpectedAfterOutput, ]) } @@ -6980,182 +6925,336 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension DeclModifierDetailSyntax: CustomReflectable { +extension FunctionSignatureSyntax: 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, - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeInput": unexpectedBeforeInput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "input": Syntax(input).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenInputAndAsyncOrReasyncKeyword": unexpectedBetweenInputAndAsyncOrReasyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "asyncOrReasyncKeyword": asyncOrReasyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword": unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "throwsOrRethrowsKeyword": throwsOrRethrowsKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenThrowsOrRethrowsKeywordAndOutput": unexpectedBetweenThrowsOrRethrowsKeywordAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterOutput": unexpectedAfterOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DeclModifierSyntax +// MARK: - IfConfigClauseSyntax + +public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { + public enum Elements: SyntaxChildChoices { + case `statements`(CodeBlockItemListSyntax) + case `switchCases`(SwitchCaseListSyntax) + case `decls`(MemberDeclListSyntax) + case `postfixExpression`(ExprSyntax) + case `attributes`(AttributeListSyntax) + public var _syntaxNode: Syntax { + switch self { + case .statements(let node): return node._syntaxNode + case .switchCases(let node): return node._syntaxNode + case .decls(let node): return node._syntaxNode + case .postfixExpression(let node): return node._syntaxNode + case .attributes(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: CodeBlockItemListSyntax) { + self = .statements(node) + } + public init(_ node: SwitchCaseListSyntax) { + self = .switchCases(node) + } + public init(_ node: MemberDeclListSyntax) { + self = .decls(node) + } + public init(_ node: Node) { + self = .postfixExpression(ExprSyntax(node)) + } + public init(_ node: AttributeListSyntax) { + self = .attributes(node) + } + public init?(_ node: S) { + if let node = node.as(CodeBlockItemListSyntax.self) { + self = .statements(node) + return + } + if let node = node.as(SwitchCaseListSyntax.self) { + self = .switchCases(node) + return + } + if let node = node.as(MemberDeclListSyntax.self) { + self = .decls(node) + return + } + if let node = node.as(ExprSyntax.self) { + self = .postfixExpression(node) + return + } + if let node = node.as(AttributeListSyntax.self) { + self = .attributes(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(CodeBlockItemListSyntax.self), + .node(SwitchCaseListSyntax.self), + .node(MemberDeclListSyntax.self), + .node(ExprSyntax.self), + .node(AttributeListSyntax.self), + ]) + } + } -public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifier else { return nil } + guard node.raw.kind == .ifConfigClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclModifierSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `IfConfigClauseSyntax` 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) { - assert(data.raw.kind == .declModifier) + assert(data.raw.kind == .ifConfigClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? = nil, - detail: DeclModifierDetailSyntax? = nil, - _ unexpectedAfterDetail: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, + poundKeyword: TokenSyntax, + _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, + condition: C? = nil, + _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, + elements: Elements? = nil, + _ unexpectedAfterElements: 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))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePoundKeyword, poundKeyword, unexpectedBetweenPoundKeywordAndCondition, condition, unexpectedBetweenConditionAndElements, elements, unexpectedAfterElements))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndDetail?.raw, - detail?.raw, - unexpectedAfterDetail?.raw, + unexpectedBeforePoundKeyword?.raw, + poundKeyword.raw, + unexpectedBetweenPoundKeywordAndCondition?.raw, + condition?.raw, + unexpectedBetweenConditionAndElements?.raw, + elements?.raw, + unexpectedAfterElements?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifier, from: layout, arena: arena, + kind: SyntaxKind.ifConfigClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + /// 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, + _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, + poundKeyword: TokenSyntax, + _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, + condition: MissingExprSyntax? = nil, + _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, + elements: Elements? = nil, + _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforePoundKeyword, + poundKeyword: poundKeyword, + unexpectedBetweenPoundKeywordAndCondition, + condition: Optional.none, + unexpectedBetweenConditionAndElements, + elements: elements, + unexpectedAfterElements, + trailingTrivia: trailingTrivia + ) + } + + public var unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeName(value) + self = withUnexpectedBeforePoundKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. - /// - param newChild: The new `unexpectedBeforeName` to replace the node's - /// current `unexpectedBeforeName`, if present. - public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DeclModifierSyntax(newData) + /// Returns a copy of the receiver with its `unexpectedBeforePoundKeyword` replaced. + /// - param newChild: The new `unexpectedBeforePoundKeyword` to replace the node's + /// current `unexpectedBeforePoundKeyword`, if present. + public func withUnexpectedBeforePoundKeyword(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return IfConfigClauseSyntax(newData) } - public var name: TokenSyntax { + public var poundKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withPoundKeyword(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax) -> DeclModifierSyntax { + /// Returns a copy of the receiver with its `poundKeyword` replaced. + /// - param newChild: The new `poundKeyword` to replace the node's + /// current `poundKeyword`, if present. + public func withPoundKeyword(_ newChild: TokenSyntax) -> IfConfigClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DeclModifierSyntax(newData) + return IfConfigClauseSyntax(newData) } - public var unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndDetail(value) + self = withUnexpectedBetweenPoundKeywordAndCondition(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndDetail` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndDetail` to replace the node's - /// current `unexpectedBetweenNameAndDetail`, if present. - public func withUnexpectedBetweenNameAndDetail(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPoundKeywordAndCondition` replaced. + /// - param newChild: The new `unexpectedBetweenPoundKeywordAndCondition` to replace the node's + /// current `unexpectedBetweenPoundKeywordAndCondition`, if present. + public func withUnexpectedBetweenPoundKeywordAndCondition(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DeclModifierSyntax(newData) + return IfConfigClauseSyntax(newData) } - public var detail: DeclModifierDetailSyntax? { + public var condition: ExprSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return DeclModifierDetailSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withDetail(value) + self = withCondition(value) } } - /// Returns a copy of the receiver with its `detail` replaced. - /// - param newChild: The new `detail` to replace the node's - /// current `detail`, if present. - public func withDetail(_ newChild: DeclModifierDetailSyntax?) -> DeclModifierSyntax { + /// Returns a copy of the receiver with its `condition` replaced. + /// - param newChild: The new `condition` to replace the node's + /// current `condition`, if present. + public func withCondition(_ newChild: ExprSyntax?) -> IfConfigClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DeclModifierSyntax(newData) + return IfConfigClauseSyntax(newData) } - public var unexpectedAfterDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterDetail(value) + self = withUnexpectedBetweenConditionAndElements(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterDetail` replaced. - /// - param newChild: The new `unexpectedAfterDetail` to replace the node's - /// current `unexpectedAfterDetail`, if present. - public func withUnexpectedAfterDetail(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenConditionAndElements` replaced. + /// - param newChild: The new `unexpectedBetweenConditionAndElements` to replace the node's + /// current `unexpectedBetweenConditionAndElements`, if present. + public func withUnexpectedBetweenConditionAndElements(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DeclModifierSyntax(newData) + return IfConfigClauseSyntax(newData) + } + + public var elements: Elements? { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } + return Elements(childData!) + } + set(value) { + self = withElements(value) + } + } + + /// Returns a copy of the receiver with its `elements` replaced. + /// - param newChild: The new `elements` to replace the node's + /// current `elements`, if present. + public func withElements(_ newChild: Elements?) -> IfConfigClauseSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return IfConfigClauseSyntax(newData) + } + + public var unexpectedAfterElements: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterElements(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterElements` replaced. + /// - param newChild: The new `unexpectedAfterElements` to replace the node's + /// current `unexpectedAfterElements`, if present. + public func withUnexpectedAfterElements(_ newChild: UnexpectedNodesSyntax?) -> IfConfigClauseSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return IfConfigClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndDetail, - \Self.detail, - \Self.unexpectedAfterDetail, + \Self.unexpectedBeforePoundKeyword, + \Self.poundKeyword, + \Self.unexpectedBetweenPoundKeywordAndCondition, + \Self.condition, + \Self.unexpectedBetweenConditionAndElements, + \Self.elements, + \Self.unexpectedAfterElements, ]) } @@ -7168,390 +7267,423 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "condition" case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension DeclModifierSyntax: CustomReflectable { +extension IfConfigClauseSyntax: 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, + "unexpectedBeforePoundKeyword": unexpectedBeforePoundKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "poundKeyword": Syntax(poundKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPoundKeywordAndCondition": unexpectedBetweenPoundKeywordAndCondition.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "condition": condition.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenConditionAndElements": unexpectedBetweenConditionAndElements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "elements": elements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterElements": unexpectedAfterElements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - InheritedTypeSyntax +// MARK: - PoundSourceLocationArgsSyntax -public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { +public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .inheritedType else { return nil } + guard node.raw.kind == .poundSourceLocationArgs else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `InheritedTypeSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `PoundSourceLocationArgsSyntax` 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) { - assert(data.raw.kind == .inheritedType) + assert(data.raw.kind == .poundSourceLocationArgs) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeTypeName: UnexpectedNodesSyntax? = nil, - typeName: T, - _ unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? = nil, + fileArgLabel: TokenSyntax = .identifier("file"), + _ unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? = nil, + fileArgColon: TokenSyntax = .colonToken(), + _ unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? = nil, + fileName: TokenSyntax, + _ unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? = nil, + lineArgLabel: TokenSyntax = .identifier("line"), + _ unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? = nil, + lineArgColon: TokenSyntax = .colonToken(), + _ unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? = nil, + lineNumber: TokenSyntax, + _ unexpectedAfterLineNumber: 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(), (unexpectedBeforeTypeName, typeName, unexpectedBetweenTypeNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFileArgLabel, fileArgLabel, unexpectedBetweenFileArgLabelAndFileArgColon, fileArgColon, unexpectedBetweenFileArgColonAndFileName, fileName, unexpectedBetweenFileNameAndComma, comma, unexpectedBetweenCommaAndLineArgLabel, lineArgLabel, unexpectedBetweenLineArgLabelAndLineArgColon, lineArgColon, unexpectedBetweenLineArgColonAndLineNumber, lineNumber, unexpectedAfterLineNumber))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeTypeName?.raw, - typeName.raw, - unexpectedBetweenTypeNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeFileArgLabel?.raw, + fileArgLabel.raw, + unexpectedBetweenFileArgLabelAndFileArgColon?.raw, + fileArgColon.raw, + unexpectedBetweenFileArgColonAndFileName?.raw, + fileName.raw, + unexpectedBetweenFileNameAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndLineArgLabel?.raw, + lineArgLabel.raw, + unexpectedBetweenLineArgLabelAndLineArgColon?.raw, + lineArgColon.raw, + unexpectedBetweenLineArgColonAndLineNumber?.raw, + lineNumber.raw, + unexpectedAfterLineNumber?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.inheritedType, from: layout, arena: arena, + kind: SyntaxKind.poundSourceLocationArgs, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeTypeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeTypeName(value) + self = withUnexpectedBeforeFileArgLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeTypeName` replaced. - /// - param newChild: The new `unexpectedBeforeTypeName` to replace the node's - /// current `unexpectedBeforeTypeName`, if present. - public func withUnexpectedBeforeTypeName(_ newChild: UnexpectedNodesSyntax?) -> InheritedTypeSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeFileArgLabel` replaced. + /// - param newChild: The new `unexpectedBeforeFileArgLabel` to replace the node's + /// current `unexpectedBeforeFileArgLabel`, if present. + public func withUnexpectedBeforeFileArgLabel(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return InheritedTypeSyntax(newData) + return PoundSourceLocationArgsSyntax(newData) } - public var typeName: TypeSyntax { + public var fileArgLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TypeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withTypeName(value) + self = withFileArgLabel(value) } } - /// Returns a copy of the receiver with its `typeName` replaced. - /// - param newChild: The new `typeName` to replace the node's - /// current `typeName`, if present. - public func withTypeName(_ newChild: TypeSyntax) -> InheritedTypeSyntax { + /// Returns a copy of the receiver with its `fileArgLabel` replaced. + /// - param newChild: The new `fileArgLabel` to replace the node's + /// current `fileArgLabel`, if present. + public func withFileArgLabel(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return InheritedTypeSyntax(newData) + return PoundSourceLocationArgsSyntax(newData) } - public var unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenTypeNameAndTrailingComma(value) + self = withUnexpectedBetweenFileArgLabelAndFileArgColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenTypeNameAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenTypeNameAndTrailingComma` to replace the node's - /// current `unexpectedBetweenTypeNameAndTrailingComma`, if present. - public func withUnexpectedBetweenTypeNameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> InheritedTypeSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenFileArgLabelAndFileArgColon` replaced. + /// - param newChild: The new `unexpectedBetweenFileArgLabelAndFileArgColon` to replace the node's + /// current `unexpectedBetweenFileArgLabelAndFileArgColon`, if present. + public func withUnexpectedBetweenFileArgLabelAndFileArgColon(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return InheritedTypeSyntax(newData) + return PoundSourceLocationArgsSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var fileArgColon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withFileArgColon(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> InheritedTypeSyntax { + /// Returns a copy of the receiver with its `fileArgColon` replaced. + /// - param newChild: The new `fileArgColon` to replace the node's + /// current `fileArgColon`, if present. + public func withFileArgColon(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return InheritedTypeSyntax(newData) + return PoundSourceLocationArgsSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenFileArgColonAndFileName(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> InheritedTypeSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenFileArgColonAndFileName` replaced. + /// - param newChild: The new `unexpectedBetweenFileArgColonAndFileName` to replace the node's + /// current `unexpectedBetweenFileArgColonAndFileName`, if present. + public func withUnexpectedBetweenFileArgColonAndFileName(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return InheritedTypeSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeTypeName, - \Self.typeName, - \Self.unexpectedBetweenTypeNameAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, - ]) + return PoundSourceLocationArgsSyntax(newData) } - 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") + public var fileName: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withFileName(value) } } -} -extension InheritedTypeSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeTypeName": unexpectedBeforeTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "typeName": Syntax(typeName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenTypeNameAndTrailingComma": unexpectedBetweenTypeNameAndTrailingComma.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, - ]) + /// Returns a copy of the receiver with its `fileName` replaced. + /// - param newChild: The new `fileName` to replace the node's + /// current `fileName`, if present. + public func withFileName(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) } -} - -// MARK: - TypeInheritanceClauseSyntax -public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .typeInheritanceClause else { return nil } - self._syntaxNode = node._syntaxNode + public var unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenFileNameAndComma(value) + } } - /// Creates a `TypeInheritanceClauseSyntax` 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) { - assert(data.raw.kind == .typeInheritanceClause) - self._syntaxNode = Syntax(data) + /// Returns a copy of the receiver with its `unexpectedBetweenFileNameAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenFileNameAndComma` to replace the node's + /// current `unexpectedBetweenFileNameAndComma`, if present. + public func withUnexpectedBetweenFileNameAndComma(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) } - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? = nil, - inheritedTypeCollection: InheritedTypeListSyntax, - _ unexpectedAfterInheritedTypeCollection: 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(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndInheritedTypeCollection, inheritedTypeCollection, unexpectedAfterInheritedTypeCollection))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndInheritedTypeCollection?.raw, - inheritedTypeCollection.raw, - unexpectedAfterInheritedTypeCollection?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeInheritanceClause, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) + public var comma: TokenSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withComma(value) } - self.init(data) } - public var unexpectedBeforeColon: UnexpectedNodesSyntax? { + /// Returns a copy of the receiver with its `comma` replaced. + /// - param newChild: The new `comma` to replace the node's + /// current `comma`, if present. + public func withComma(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) + } + + public var unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeColon(value) + self = withUnexpectedBetweenCommaAndLineArgLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeColon` replaced. - /// - param newChild: The new `unexpectedBeforeColon` to replace the node's - /// current `unexpectedBeforeColon`, if present. - public func withUnexpectedBeforeColon(_ newChild: UnexpectedNodesSyntax?) -> TypeInheritanceClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndLineArgLabel` replaced. + /// - param newChild: The new `unexpectedBetweenCommaAndLineArgLabel` to replace the node's + /// current `unexpectedBetweenCommaAndLineArgLabel`, if present. + public func withUnexpectedBetweenCommaAndLineArgLabel(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return TypeInheritanceClauseSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) } - public var colon: TokenSyntax { + public var lineArgLabel: TokenSyntax { get { - let childData = data.child(at: 1, parent: Syntax(self)) + let childData = data.child(at: 9, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withLineArgLabel(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> TypeInheritanceClauseSyntax { + /// Returns a copy of the receiver with its `lineArgLabel` replaced. + /// - param newChild: The new `lineArgLabel` to replace the node's + /// current `lineArgLabel`, if present. + public func withLineArgLabel(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TypeInheritanceClauseSyntax(newData) + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) } - public var unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? { + public var unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndInheritedTypeCollection(value) + self = withUnexpectedBetweenLineArgLabelAndLineArgColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndInheritedTypeCollection` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndInheritedTypeCollection` to replace the node's - /// current `unexpectedBetweenColonAndInheritedTypeCollection`, if present. - public func withUnexpectedBetweenColonAndInheritedTypeCollection(_ newChild: UnexpectedNodesSyntax?) -> TypeInheritanceClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLineArgLabelAndLineArgColon` replaced. + /// - param newChild: The new `unexpectedBetweenLineArgLabelAndLineArgColon` to replace the node's + /// current `unexpectedBetweenLineArgLabelAndLineArgColon`, if present. + public func withUnexpectedBetweenLineArgLabelAndLineArgColon(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return TypeInheritanceClauseSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) } - public var inheritedTypeCollection: InheritedTypeListSyntax { + public var lineArgColon: TokenSyntax { get { - let childData = data.child(at: 3, parent: Syntax(self)) - return InheritedTypeListSyntax(childData!) + let childData = data.child(at: 11, parent: Syntax(self)) + return TokenSyntax(childData!) } set(value) { - self = withInheritedTypeCollection(value) - } - } - - /// Adds the provided `InheritedType` to the node's `inheritedTypeCollection` - /// collection. - /// - param element: The new `InheritedType` to add to the node's - /// `inheritedTypeCollection` collection. - /// - returns: A copy of the receiver with the provided `InheritedType` - /// appended to its `inheritedTypeCollection` collection. - public func addInheritedType(_ element: InheritedTypeSyntax) -> TypeInheritanceClauseSyntax { - 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.inheritedTypeList, - from: [element.raw], arena: arena) + self = withLineArgColon(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return TypeInheritanceClauseSyntax(newData) } - /// Returns a copy of the receiver with its `inheritedTypeCollection` replaced. - /// - param newChild: The new `inheritedTypeCollection` to replace the node's - /// current `inheritedTypeCollection`, if present. - public func withInheritedTypeCollection(_ newChild: InheritedTypeListSyntax) -> TypeInheritanceClauseSyntax { + /// Returns a copy of the receiver with its `lineArgColon` replaced. + /// - param newChild: The new `lineArgColon` to replace the node's + /// current `lineArgColon`, if present. + public func withLineArgColon(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return TypeInheritanceClauseSyntax(newData) + let newData = data.replacingChild(at: 11, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) } - public var unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? { + public var unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 12, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterInheritedTypeCollection(value) + self = withUnexpectedBetweenLineArgColonAndLineNumber(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterInheritedTypeCollection` replaced. - /// - param newChild: The new `unexpectedAfterInheritedTypeCollection` to replace the node's - /// current `unexpectedAfterInheritedTypeCollection`, if present. - public func withUnexpectedAfterInheritedTypeCollection(_ newChild: UnexpectedNodesSyntax?) -> TypeInheritanceClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLineArgColonAndLineNumber` replaced. + /// - param newChild: The new `unexpectedBetweenLineArgColonAndLineNumber` to replace the node's + /// current `unexpectedBetweenLineArgColonAndLineNumber`, if present. + public func withUnexpectedBetweenLineArgColonAndLineNumber(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return TypeInheritanceClauseSyntax(newData) + let newData = data.replacingChild(at: 12, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeColon, - \Self.colon, - \Self.unexpectedBetweenColonAndInheritedTypeCollection, - \Self.inheritedTypeCollection, - \Self.unexpectedAfterInheritedTypeCollection, + public var lineNumber: TokenSyntax { + get { + let childData = data.child(at: 13, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withLineNumber(value) + } + } + + /// Returns a copy of the receiver with its `lineNumber` replaced. + /// - param newChild: The new `lineNumber` to replace the node's + /// current `lineNumber`, if present. + public func withLineNumber(_ newChild: TokenSyntax) -> PoundSourceLocationArgsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 13, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) + } + + public var unexpectedAfterLineNumber: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 14, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterLineNumber(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterLineNumber` replaced. + /// - param newChild: The new `unexpectedAfterLineNumber` to replace the node's + /// current `unexpectedAfterLineNumber`, if present. + public func withUnexpectedAfterLineNumber(_ newChild: UnexpectedNodesSyntax?) -> PoundSourceLocationArgsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 14, with: raw, arena: arena) + return PoundSourceLocationArgsSyntax(newData) + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeFileArgLabel, + \Self.fileArgLabel, + \Self.unexpectedBetweenFileArgLabelAndFileArgColon, + \Self.fileArgColon, + \Self.unexpectedBetweenFileArgColonAndFileName, + \Self.fileName, + \Self.unexpectedBetweenFileNameAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndLineArgLabel, + \Self.lineArgLabel, + \Self.unexpectedBetweenLineArgLabelAndLineArgColon, + \Self.lineArgColon, + \Self.unexpectedBetweenLineArgColonAndLineNumber, + \Self.lineNumber, + \Self.unexpectedAfterLineNumber, ]) } @@ -7567,245 +7699,256 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return "file name" + 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 "line number" + case 14: + return nil default: fatalError("Invalid index") } } } -extension TypeInheritanceClauseSyntax: CustomReflectable { +extension PoundSourceLocationArgsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeColon": unexpectedBeforeColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndInheritedTypeCollection": unexpectedBetweenColonAndInheritedTypeCollection.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "inheritedTypeCollection": Syntax(inheritedTypeCollection).asProtocol(SyntaxProtocol.self), - "unexpectedAfterInheritedTypeCollection": unexpectedAfterInheritedTypeCollection.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeFileArgLabel": unexpectedBeforeFileArgLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "fileArgLabel": Syntax(fileArgLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenFileArgLabelAndFileArgColon": unexpectedBetweenFileArgLabelAndFileArgColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "fileArgColon": Syntax(fileArgColon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenFileArgColonAndFileName": unexpectedBetweenFileArgColonAndFileName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "fileName": Syntax(fileName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenFileNameAndComma": unexpectedBetweenFileNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCommaAndLineArgLabel": unexpectedBetweenCommaAndLineArgLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "lineArgLabel": Syntax(lineArgLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLineArgLabelAndLineArgColon": unexpectedBetweenLineArgLabelAndLineArgColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "lineArgColon": Syntax(lineArgColon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLineArgColonAndLineNumber": unexpectedBetweenLineArgColonAndLineNumber.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "lineNumber": Syntax(lineNumber).asProtocol(SyntaxProtocol.self), + "unexpectedAfterLineNumber": unexpectedAfterLineNumber.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - MemberDeclBlockSyntax +// MARK: - DeclModifierDetailSyntax -public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .memberDeclBlock else { return nil } + guard node.raw.kind == .declModifierDetail else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `MemberDeclBlockSyntax` 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) { - assert(data.raw.kind == .memberDeclBlock) + assert(data.raw.kind == .declModifierDetail) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? = nil, - members: MemberDeclListSyntax, - _ unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: 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(), (unexpectedBeforeLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndMembers, members, unexpectedBetweenMembersAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndDetail, detail, unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndMembers?.raw, - members.raw, - unexpectedBetweenMembersAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndDetail?.raw, + detail.raw, + unexpectedBetweenDetailAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberDeclBlock, from: layout, arena: arena, + kind: SyntaxKind.declModifierDetail, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftBrace(value) + self = withUnexpectedBeforeLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftBrace` replaced. - /// - param newChild: The new `unexpectedBeforeLeftBrace` to replace the node's - /// current `unexpectedBeforeLeftBrace`, if present. - public func withUnexpectedBeforeLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. + /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's + /// current `unexpectedBeforeLeftParen`, if present. + public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return MemberDeclBlockSyntax(newData) + return DeclModifierDetailSyntax(newData) } - public var leftBrace: TokenSyntax { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftBrace(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `leftBrace` replaced. - /// - param newChild: The new `leftBrace` to replace the node's - /// current `leftBrace`, if present. - public func withLeftBrace(_ newChild: TokenSyntax) -> MemberDeclBlockSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> DeclModifierDetailSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return MemberDeclBlockSyntax(newData) + return DeclModifierDetailSyntax(newData) } - public var unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftBraceAndMembers(value) + self = withUnexpectedBetweenLeftParenAndDetail(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndMembers` replaced. - /// - param newChild: The new `unexpectedBetweenLeftBraceAndMembers` to replace the node's - /// current `unexpectedBetweenLeftBraceAndMembers`, if present. - public func withUnexpectedBetweenLeftBraceAndMembers(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndDetail` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndDetail` to replace the node's + /// current `unexpectedBetweenLeftParenAndDetail`, if present. + public func withUnexpectedBetweenLeftParenAndDetail(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return MemberDeclBlockSyntax(newData) + return DeclModifierDetailSyntax(newData) } - public var members: MemberDeclListSyntax { + public var detail: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return MemberDeclListSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withMembers(value) - } - } - - /// Adds the provided `Member` to the node's `members` - /// collection. - /// - param element: The new `Member` to add to the node's - /// `members` collection. - /// - returns: A copy of the receiver with the provided `Member` - /// appended to its `members` collection. - public func addMember(_ element: MemberDeclListItemSyntax) -> MemberDeclBlockSyntax { - 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.memberDeclList, - from: [element.raw], arena: arena) + self = withDetail(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return MemberDeclBlockSyntax(newData) } - /// Returns a copy of the receiver with its `members` replaced. - /// - param newChild: The new `members` to replace the node's - /// current `members`, if present. - public func withMembers(_ newChild: MemberDeclListSyntax) -> MemberDeclBlockSyntax { + /// Returns a copy of the receiver with its `detail` replaced. + /// - param newChild: The new `detail` to replace the node's + /// current `detail`, if present. + public func withDetail(_ newChild: TokenSyntax) -> DeclModifierDetailSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return MemberDeclBlockSyntax(newData) + return DeclModifierDetailSyntax(newData) } - public var unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenMembersAndRightBrace(value) + self = withUnexpectedBetweenDetailAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenMembersAndRightBrace` replaced. - /// - param newChild: The new `unexpectedBetweenMembersAndRightBrace` to replace the node's - /// current `unexpectedBetweenMembersAndRightBrace`, if present. - public func withUnexpectedBetweenMembersAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDetailAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenDetailAndRightParen` to replace the node's + /// current `unexpectedBetweenDetailAndRightParen`, if present. + public func withUnexpectedBetweenDetailAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return MemberDeclBlockSyntax(newData) + return DeclModifierDetailSyntax(newData) } - public var rightBrace: TokenSyntax { + public var rightParen: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withRightBrace(value) + self = withRightParen(value) } } - /// Returns a copy of the receiver with its `rightBrace` replaced. - /// - param newChild: The new `rightBrace` to replace the node's - /// current `rightBrace`, if present. - public func withRightBrace(_ newChild: TokenSyntax) -> MemberDeclBlockSyntax { + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> DeclModifierDetailSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return MemberDeclBlockSyntax(newData) + return DeclModifierDetailSyntax(newData) } - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightBrace(value) + self = withUnexpectedAfterRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. - /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's - /// current `unexpectedAfterRightBrace`, if present. - public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { - let arena = SyntaxArena() + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierDetailSyntax { + let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return MemberDeclBlockSyntax(newData) + return DeclModifierDetailSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftBrace, - \Self.leftBrace, - \Self.unexpectedBetweenLeftBraceAndMembers, - \Self.members, - \Self.unexpectedBetweenMembersAndRightBrace, - \Self.rightBrace, - \Self.unexpectedAfterRightBrace, + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDetail, + \Self.detail, + \Self.unexpectedBetweenDetailAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -7831,182 +7974,176 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { } } -extension MemberDeclBlockSyntax: CustomReflectable { +extension DeclModifierDetailSyntax: 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), - "unexpectedBetweenLeftBraceAndMembers": unexpectedBetweenLeftBraceAndMembers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "members": Syntax(members).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenMembersAndRightBrace": unexpectedBetweenMembersAndRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightBrace": Syntax(rightBrace).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightBrace": unexpectedAfterRightBrace.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: - MemberDeclListItemSyntax +// MARK: - DeclModifierSyntax -/// -/// A member declaration of a type consisting of a declaration and an -/// optional semicolon; -/// -public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .memberDeclListItem else { return nil } + guard node.raw.kind == .declModifier else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `MemberDeclListItemSyntax` 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) { - assert(data.raw.kind == .memberDeclListItem) + assert(data.raw.kind == .declModifier) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDecl: UnexpectedNodesSyntax? = nil, - decl: D, - _ unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax? = nil, - _ unexpectedAfterSemicolon: 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(), (unexpectedBeforeDecl, decl, unexpectedBetweenDeclAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndDetail, detail, unexpectedAfterDetail))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDecl?.raw, - decl.raw, - unexpectedBetweenDeclAndSemicolon?.raw, - semicolon?.raw, - unexpectedAfterSemicolon?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndDetail?.raw, + detail?.raw, + unexpectedAfterDetail?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberDeclListItem, from: layout, arena: arena, + kind: SyntaxKind.declModifier, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDecl: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeDecl(value) + self = withUnexpectedBeforeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeDecl` replaced. - /// - param newChild: The new `unexpectedBeforeDecl` to replace the node's - /// current `unexpectedBeforeDecl`, if present. - public func withUnexpectedBeforeDecl(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclListItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. + /// - param newChild: The new `unexpectedBeforeName` to replace the node's + /// current `unexpectedBeforeName`, if present. + public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return MemberDeclListItemSyntax(newData) + return DeclModifierSyntax(newData) } - /// The declaration of the type member. - public var decl: DeclSyntax { + public var name: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return DeclSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDecl(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `decl` replaced. - /// - param newChild: The new `decl` to replace the node's - /// current `decl`, if present. - public func withDecl(_ newChild: DeclSyntax) -> MemberDeclListItemSyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax) -> DeclModifierSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return MemberDeclListItemSyntax(newData) + return DeclModifierSyntax(newData) } - public var unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDeclAndSemicolon(value) + self = withUnexpectedBetweenNameAndDetail(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDeclAndSemicolon` replaced. - /// - param newChild: The new `unexpectedBetweenDeclAndSemicolon` to replace the node's - /// current `unexpectedBetweenDeclAndSemicolon`, if present. - public func withUnexpectedBetweenDeclAndSemicolon(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclListItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndDetail` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndDetail` to replace the node's + /// current `unexpectedBetweenNameAndDetail`, if present. + public func withUnexpectedBetweenNameAndDetail(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return MemberDeclListItemSyntax(newData) + return DeclModifierSyntax(newData) } - /// An optional trailing semicolon. - public var semicolon: TokenSyntax? { + public var detail: DeclModifierDetailSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return TokenSyntax(childData!) + return DeclModifierDetailSyntax(childData!) } set(value) { - self = withSemicolon(value) + self = withDetail(value) } } - /// Returns a copy of the receiver with its `semicolon` replaced. - /// - param newChild: The new `semicolon` to replace the node's - /// current `semicolon`, if present. - public func withSemicolon(_ newChild: TokenSyntax?) -> MemberDeclListItemSyntax { + /// Returns a copy of the receiver with its `detail` replaced. + /// - param newChild: The new `detail` to replace the node's + /// current `detail`, if present. + public func withDetail(_ newChild: DeclModifierDetailSyntax?) -> DeclModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return MemberDeclListItemSyntax(newData) + return DeclModifierSyntax(newData) } - public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { + public var unexpectedAfterDetail: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterSemicolon(value) + self = withUnexpectedAfterDetail(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterSemicolon` replaced. - /// - param newChild: The new `unexpectedAfterSemicolon` to replace the node's - /// current `unexpectedAfterSemicolon`, if present. - public func withUnexpectedAfterSemicolon(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclListItemSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterDetail` replaced. + /// - param newChild: The new `unexpectedAfterDetail` to replace the node's + /// current `unexpectedAfterDetail`, if present. + public func withUnexpectedAfterDetail(_ newChild: UnexpectedNodesSyntax?) -> DeclModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return MemberDeclListItemSyntax(newData) + return DeclModifierSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDecl, - \Self.decl, - \Self.unexpectedBetweenDeclAndSemicolon, - \Self.semicolon, - \Self.unexpectedAfterSemicolon, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndDetail, + \Self.detail, + \Self.unexpectedAfterDetail, ]) } @@ -8028,192 +8165,174 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { } } -extension MemberDeclListItemSyntax: CustomReflectable { +extension DeclModifierSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeDecl": unexpectedBeforeDecl.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "decl": Syntax(decl).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDeclAndSemicolon": unexpectedBetweenDeclAndSemicolon.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, + "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: - SourceFileSyntax +// MARK: - InheritedTypeSyntax -public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { +public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .sourceFile else { return nil } + guard node.raw.kind == .inheritedType else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SourceFileSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `InheritedTypeSyntax` 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) { - assert(data.raw.kind == .sourceFile) + assert(data.raw.kind == .inheritedType) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? = nil, - eofToken: TokenSyntax, - _ unexpectedAfterEOFToken: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeTypeName: UnexpectedNodesSyntax? = nil, + typeName: T, + _ unexpectedBetweenTypeNameAndTrailingComma: 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(), (unexpectedBeforeStatements, statements, unexpectedBetweenStatementsAndEOFToken, eofToken, unexpectedAfterEOFToken))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeTypeName, typeName, unexpectedBetweenTypeNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndEOFToken?.raw, - eofToken.raw, - unexpectedAfterEOFToken?.raw, + unexpectedBeforeTypeName?.raw, + typeName.raw, + unexpectedBetweenTypeNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.sourceFile, from: layout, arena: arena, + kind: SyntaxKind.inheritedType, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeStatements: UnexpectedNodesSyntax? { + public var unexpectedBeforeTypeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeStatements(value) + self = withUnexpectedBeforeTypeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeStatements` replaced. - /// - param newChild: The new `unexpectedBeforeStatements` to replace the node's - /// current `unexpectedBeforeStatements`, if present. - public func withUnexpectedBeforeStatements(_ newChild: UnexpectedNodesSyntax?) -> SourceFileSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeTypeName` replaced. + /// - param newChild: The new `unexpectedBeforeTypeName` to replace the node's + /// current `unexpectedBeforeTypeName`, if present. + public func withUnexpectedBeforeTypeName(_ newChild: UnexpectedNodesSyntax?) -> InheritedTypeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SourceFileSyntax(newData) + return InheritedTypeSyntax(newData) } - public var statements: CodeBlockItemListSyntax { + public var typeName: TypeSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return CodeBlockItemListSyntax(childData!) + return TypeSyntax(childData!) } set(value) { - self = withStatements(value) + self = withTypeName(value) } } - /// 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) -> SourceFileSyntax { - var collection: RawSyntax + /// Returns a copy of the receiver with its `typeName` replaced. + /// - param newChild: The new `typeName` to replace the node's + /// current `typeName`, if present. + public func withTypeName(_ newChild: TypeSyntax) -> InheritedTypeSyntax { let arena = SyntaxArena() - if let col = raw.layoutView!.children[1] { - 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: 1, with: collection, arena: arena) - return SourceFileSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return InheritedTypeSyntax(newData) } - /// Returns a copy of the receiver with its `statements` replaced. - /// - param newChild: The new `statements` to replace the node's - /// current `statements`, if present. - public func withStatements(_ newChild: CodeBlockItemListSyntax) -> SourceFileSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SourceFileSyntax(newData) - } - - public var unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenStatementsAndEOFToken(value) + self = withUnexpectedBetweenTypeNameAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenStatementsAndEOFToken` replaced. - /// - param newChild: The new `unexpectedBetweenStatementsAndEOFToken` to replace the node's - /// current `unexpectedBetweenStatementsAndEOFToken`, if present. - public func withUnexpectedBetweenStatementsAndEOFToken(_ newChild: UnexpectedNodesSyntax?) -> SourceFileSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenTypeNameAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenTypeNameAndTrailingComma` to replace the node's + /// current `unexpectedBetweenTypeNameAndTrailingComma`, if present. + public func withUnexpectedBetweenTypeNameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> InheritedTypeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SourceFileSyntax(newData) + return InheritedTypeSyntax(newData) } - public var eofToken: TokenSyntax { + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withEOFToken(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `eofToken` replaced. - /// - param newChild: The new `eofToken` to replace the node's - /// current `eofToken`, if present. - public func withEOFToken(_ newChild: TokenSyntax) -> SourceFileSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> InheritedTypeSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SourceFileSyntax(newData) + return InheritedTypeSyntax(newData) } - public var unexpectedAfterEOFToken: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterEOFToken(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterEOFToken` replaced. - /// - param newChild: The new `unexpectedAfterEOFToken` to replace the node's - /// current `unexpectedAfterEOFToken`, if present. - public func withUnexpectedAfterEOFToken(_ newChild: UnexpectedNodesSyntax?) -> SourceFileSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> InheritedTypeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SourceFileSyntax(newData) + return InheritedTypeSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeStatements, - \Self.statements, - \Self.unexpectedBetweenStatementsAndEOFToken, - \Self.eofToken, - \Self.unexpectedAfterEOFToken, + \Self.unexpectedBeforeTypeName, + \Self.typeName, + \Self.unexpectedBetweenTypeNameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -8235,173 +8354,192 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { } } -extension SourceFileSyntax: CustomReflectable { +extension InheritedTypeSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeStatements": unexpectedBeforeStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenStatementsAndEOFToken": unexpectedBetweenStatementsAndEOFToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "eofToken": Syntax(eofToken).asProtocol(SyntaxProtocol.self), - "unexpectedAfterEOFToken": unexpectedAfterEOFToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeTypeName": unexpectedBeforeTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "typeName": Syntax(typeName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenTypeNameAndTrailingComma": unexpectedBetweenTypeNameAndTrailingComma.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: - InitializerClauseSyntax +// MARK: - TypeInheritanceClauseSyntax -public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { +public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .initializerClause else { return nil } + guard node.raw.kind == .typeInheritanceClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `InitializerClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `TypeInheritanceClauseSyntax` 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) { - assert(data.raw.kind == .initializerClause) + assert(data.raw.kind == .typeInheritanceClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, - equal: TokenSyntax = .equalToken(), - _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, - value: V, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? = nil, + inheritedTypeCollection: InheritedTypeListSyntax, + _ unexpectedAfterInheritedTypeCollection: 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(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndInheritedTypeCollection, inheritedTypeCollection, unexpectedAfterInheritedTypeCollection))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, + unexpectedBeforeColon?.raw, + colon.raw, + unexpectedBetweenColonAndInheritedTypeCollection?.raw, + inheritedTypeCollection.raw, + unexpectedAfterInheritedTypeCollection?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.initializerClause, from: layout, arena: arena, + kind: SyntaxKind.typeInheritanceClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { + public var unexpectedBeforeColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeEqual(value) + self = withUnexpectedBeforeColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeEqual` replaced. - /// - param newChild: The new `unexpectedBeforeEqual` to replace the node's - /// current `unexpectedBeforeEqual`, if present. - public func withUnexpectedBeforeEqual(_ newChild: UnexpectedNodesSyntax?) -> InitializerClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeColon` replaced. + /// - param newChild: The new `unexpectedBeforeColon` to replace the node's + /// current `unexpectedBeforeColon`, if present. + public func withUnexpectedBeforeColon(_ newChild: UnexpectedNodesSyntax?) -> TypeInheritanceClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return InitializerClauseSyntax(newData) + return TypeInheritanceClauseSyntax(newData) } - public var equal: TokenSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withEqual(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `equal` replaced. - /// - param newChild: The new `equal` to replace the node's - /// current `equal`, if present. - public func withEqual(_ newChild: TokenSyntax) -> InitializerClauseSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> TypeInheritanceClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return InitializerClauseSyntax(newData) + return TypeInheritanceClauseSyntax(newData) } - public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenEqualAndValue(value) + self = withUnexpectedBetweenColonAndInheritedTypeCollection(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenEqualAndValue` replaced. - /// - param newChild: The new `unexpectedBetweenEqualAndValue` to replace the node's - /// current `unexpectedBetweenEqualAndValue`, if present. - public func withUnexpectedBetweenEqualAndValue(_ newChild: UnexpectedNodesSyntax?) -> InitializerClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndInheritedTypeCollection` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndInheritedTypeCollection` to replace the node's + /// current `unexpectedBetweenColonAndInheritedTypeCollection`, if present. + public func withUnexpectedBetweenColonAndInheritedTypeCollection(_ newChild: UnexpectedNodesSyntax?) -> TypeInheritanceClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return InitializerClauseSyntax(newData) + return TypeInheritanceClauseSyntax(newData) } - public var value: ExprSyntax { + public var inheritedTypeCollection: InheritedTypeListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return ExprSyntax(childData!) + return InheritedTypeListSyntax(childData!) } set(value) { - self = withValue(value) + self = withInheritedTypeCollection(value) } } - /// Returns a copy of the receiver with its `value` replaced. - /// - param newChild: The new `value` to replace the node's - /// current `value`, if present. - public func withValue(_ newChild: ExprSyntax) -> InitializerClauseSyntax { + /// Adds the provided `InheritedType` to the node's `inheritedTypeCollection` + /// collection. + /// - param element: The new `InheritedType` to add to the node's + /// `inheritedTypeCollection` collection. + /// - returns: A copy of the receiver with the provided `InheritedType` + /// appended to its `inheritedTypeCollection` collection. + public func addInheritedType(_ element: InheritedTypeSyntax) -> TypeInheritanceClauseSyntax { + 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.inheritedTypeList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return TypeInheritanceClauseSyntax(newData) + } + + /// Returns a copy of the receiver with its `inheritedTypeCollection` replaced. + /// - param newChild: The new `inheritedTypeCollection` to replace the node's + /// current `inheritedTypeCollection`, if present. + public func withInheritedTypeCollection(_ newChild: InheritedTypeListSyntax) -> TypeInheritanceClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return InitializerClauseSyntax(newData) + return TypeInheritanceClauseSyntax(newData) } - public var unexpectedAfterValue: UnexpectedNodesSyntax? { + public var unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterValue(value) + self = withUnexpectedAfterInheritedTypeCollection(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterValue` replaced. - /// - param newChild: The new `unexpectedAfterValue` to replace the node's - /// current `unexpectedAfterValue`, if present. - public func withUnexpectedAfterValue(_ newChild: UnexpectedNodesSyntax?) -> InitializerClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterInheritedTypeCollection` replaced. + /// - param newChild: The new `unexpectedAfterInheritedTypeCollection` to replace the node's + /// current `unexpectedAfterInheritedTypeCollection`, if present. + public func withUnexpectedAfterInheritedTypeCollection(_ newChild: UnexpectedNodesSyntax?) -> TypeInheritanceClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return InitializerClauseSyntax(newData) + return TypeInheritanceClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeEqual, - \Self.equal, - \Self.unexpectedBetweenEqualAndValue, - \Self.value, - \Self.unexpectedAfterValue, + \Self.unexpectedBeforeColon, + \Self.colon, + \Self.unexpectedBetweenColonAndInheritedTypeCollection, + \Self.inheritedTypeCollection, + \Self.unexpectedAfterInheritedTypeCollection, ]) } @@ -8423,607 +8561,440 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { } } -extension InitializerClauseSyntax: CustomReflectable { +extension TypeInheritanceClauseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeEqual": unexpectedBeforeEqual.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "equal": Syntax(equal).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenEqualAndValue": unexpectedBetweenEqualAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "value": Syntax(value).asProtocol(SyntaxProtocol.self), - "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeColon": unexpectedBeforeColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndInheritedTypeCollection": unexpectedBetweenColonAndInheritedTypeCollection.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "inheritedTypeCollection": Syntax(inheritedTypeCollection).asProtocol(SyntaxProtocol.self), + "unexpectedAfterInheritedTypeCollection": unexpectedAfterInheritedTypeCollection.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - FunctionParameterSyntax +// MARK: - MemberDeclBlockSyntax -public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { +public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionParameter else { return nil } + guard node.raw.kind == .memberDeclBlock else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `FunctionParameterSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `MemberDeclBlockSyntax` 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) { - assert(data.raw.kind == .functionParameter) + assert(data.raw.kind == .memberDeclBlock) self._syntaxNode = Syntax(data) } - public init( + 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: T? = 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 + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? = nil, + members: MemberDeclListSyntax, + _ unexpectedBetweenMembersAndRightBrace: 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, unexpectedBetweenAttributesAndModifiers, modifiers, unexpectedBetweenModifiersAndFirstName, firstName, unexpectedBetweenFirstNameAndSecondName, secondName, unexpectedBetweenSecondNameAndColon, colon, unexpectedBetweenColonAndType, type, unexpectedBetweenTypeAndEllipsis, ellipsis, unexpectedBetweenEllipsisAndDefaultArgument, defaultArgument, unexpectedBetweenDefaultArgumentAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndMembers, members, unexpectedBetweenMembersAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (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, - unexpectedBetweenEllipsisAndDefaultArgument?.raw, - defaultArgument?.raw, - unexpectedBetweenDefaultArgumentAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndMembers?.raw, + members.raw, + unexpectedBetweenMembersAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionParameter, from: layout, arena: arena, + kind: SyntaxKind.memberDeclBlock, 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? = 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? { + public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeAttributes(value) + self = withUnexpectedBeforeLeftBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeAttributes` replaced. - /// - param newChild: The new `unexpectedBeforeAttributes` to replace the node's - /// current `unexpectedBeforeAttributes`, if present. - public func withUnexpectedBeforeAttributes(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftBrace` replaced. + /// - param newChild: The new `unexpectedBeforeLeftBrace` to replace the node's + /// current `unexpectedBeforeLeftBrace`, if present. + public func withUnexpectedBeforeLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + return MemberDeclBlockSyntax(newData) } - public var attributes: AttributeListSyntax? { + public var leftBrace: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } - return AttributeListSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withAttributes(value) - } - } - - /// 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) -> FunctionParameterSyntax { - 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 = withLeftBrace(value) } - let newData = data.replacingChild(at: 1, with: collection, arena: arena) - return FunctionParameterSyntax(newData) } - /// Returns a copy of the receiver with its `attributes` replaced. - /// - param newChild: The new `attributes` to replace the node's - /// current `attributes`, if present. - public func withAttributes(_ newChild: AttributeListSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `leftBrace` replaced. + /// - param newChild: The new `leftBrace` to replace the node's + /// current `leftBrace`, if present. + public func withLeftBrace(_ newChild: TokenSyntax) -> MemberDeclBlockSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + return MemberDeclBlockSyntax(newData) } - public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAttributesAndModifiers(value) + self = withUnexpectedBetweenLeftBraceAndMembers(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAttributesAndModifiers` replaced. - /// - param newChild: The new `unexpectedBetweenAttributesAndModifiers` to replace the node's - /// current `unexpectedBetweenAttributesAndModifiers`, if present. - public func withUnexpectedBetweenAttributesAndModifiers(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndMembers` replaced. + /// - param newChild: The new `unexpectedBetweenLeftBraceAndMembers` to replace the node's + /// current `unexpectedBetweenLeftBraceAndMembers`, if present. + public func withUnexpectedBetweenLeftBraceAndMembers(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + return MemberDeclBlockSyntax(newData) } - public var modifiers: ModifierListSyntax? { + public var members: MemberDeclListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return ModifierListSyntax(childData!) + return MemberDeclListSyntax(childData!) } set(value) { - self = withModifiers(value) + self = withMembers(value) } } - /// Adds the provided `Modifier` to the node's `modifiers` + /// Adds the provided `Member` to the node's `members` /// 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) -> FunctionParameterSyntax { + /// - param element: The new `Member` to add to the node's + /// `members` collection. + /// - returns: A copy of the receiver with the provided `Member` + /// appended to its `members` collection. + public func addMember(_ element: MemberDeclListItemSyntax) -> MemberDeclBlockSyntax { 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, + collection = RawSyntax.makeLayout(kind: SyntaxKind.memberDeclList, from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return FunctionParameterSyntax(newData) + return MemberDeclBlockSyntax(newData) } - /// Returns a copy of the receiver with its `modifiers` replaced. - /// - param newChild: The new `modifiers` to replace the node's - /// current `modifiers`, if present. - public func withModifiers(_ newChild: ModifierListSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `members` replaced. + /// - param newChild: The new `members` to replace the node's + /// current `members`, if present. + public func withMembers(_ newChild: MemberDeclListSyntax) -> MemberDeclBlockSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + return MemberDeclBlockSyntax(newData) } - public var unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? { + public var unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenModifiersAndFirstName(value) + self = withUnexpectedBetweenMembersAndRightBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenModifiersAndFirstName` replaced. - /// - param newChild: The new `unexpectedBetweenModifiersAndFirstName` to replace the node's - /// current `unexpectedBetweenModifiersAndFirstName`, if present. - public func withUnexpectedBetweenModifiersAndFirstName(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenMembersAndRightBrace` replaced. + /// - param newChild: The new `unexpectedBetweenMembersAndRightBrace` to replace the node's + /// current `unexpectedBetweenMembersAndRightBrace`, if present. + public func withUnexpectedBetweenMembersAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + return MemberDeclBlockSyntax(newData) } - public var firstName: TokenSyntax? { + public var rightBrace: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withFirstName(value) + self = withRightBrace(value) } } - /// Returns a copy of the receiver with its `firstName` replaced. - /// - param newChild: The new `firstName` to replace the node's - /// current `firstName`, if present. - public func withFirstName(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `rightBrace` replaced. + /// - param newChild: The new `rightBrace` to replace the node's + /// current `rightBrace`, if present. + public func withRightBrace(_ newChild: TokenSyntax) -> MemberDeclBlockSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + return MemberDeclBlockSyntax(newData) } - public var unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? { + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenFirstNameAndSecondName(value) + self = withUnexpectedAfterRightBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenFirstNameAndSecondName` replaced. - /// - param newChild: The new `unexpectedBetweenFirstNameAndSecondName` to replace the node's - /// current `unexpectedBetweenFirstNameAndSecondName`, if present. - public func withUnexpectedBetweenFirstNameAndSecondName(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. + /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's + /// current `unexpectedAfterRightBrace`, if present. + public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclBlockSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return FunctionParameterSyntax(newData) - } - - public var secondName: TokenSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withSecondName(value) - } + return MemberDeclBlockSyntax(newData) } - /// Returns a copy of the receiver with its `secondName` replaced. - /// - param newChild: The new `secondName` to replace the node's - /// current `secondName`, if present. - public func withSecondName(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndMembers, + \Self.members, + \Self.unexpectedBetweenMembersAndRightBrace, + \Self.rightBrace, + \Self.unexpectedAfterRightBrace, + ]) } - public var unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenSecondNameAndColon(value) + 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 + case 5: + return nil + case 6: + return nil + default: + fatalError("Invalid index") } } +} - /// Returns a copy of the receiver with its `unexpectedBetweenSecondNameAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenSecondNameAndColon` to replace the node's - /// current `unexpectedBetweenSecondNameAndColon`, if present. - public func withUnexpectedBetweenSecondNameAndColon(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return FunctionParameterSyntax(newData) +extension MemberDeclBlockSyntax: 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), + "unexpectedBetweenLeftBraceAndMembers": unexpectedBetweenLeftBraceAndMembers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "members": Syntax(members).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenMembersAndRightBrace": unexpectedBetweenMembersAndRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightBrace": Syntax(rightBrace).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightBrace": unexpectedAfterRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) } +} - public var colon: TokenSyntax? { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withColon(value) - } - } +// MARK: - MemberDeclListItemSyntax - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return FunctionParameterSyntax(newData) - } +/// +/// A member declaration of a type consisting of a declaration and an +/// optional semicolon; +/// +public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax - public var unexpectedBetweenColonAndType: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 10, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenColonAndType(value) - } + public init?(_ node: S) { + guard node.raw.kind == .memberDeclListItem else { return nil } + self._syntaxNode = node._syntaxNode } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndType` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndType` to replace the node's - /// current `unexpectedBetweenColonAndType`, if present. - public func withUnexpectedBetweenColonAndType(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + /// Creates a `MemberDeclListItemSyntax` 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) { + assert(data.raw.kind == .memberDeclListItem) + self._syntaxNode = Syntax(data) } - public var type: TypeSyntax? { - get { - let childData = data.child(at: 11, parent: Syntax(self)) - if childData == nil { return nil } - return TypeSyntax(childData!) - } - set(value) { - self = withType(value) + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDecl: UnexpectedNodesSyntax? = nil, + decl: D, + _ unexpectedBetweenDeclAndSemicolon: 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(), (unexpectedBeforeDecl, decl, unexpectedBetweenDeclAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeDecl?.raw, + decl.raw, + unexpectedBetweenDeclAndSemicolon?.raw, + semicolon?.raw, + unexpectedAfterSemicolon?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.memberDeclListItem, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } + self.init(data) } - /// Returns a copy of the receiver with its `type` replaced. - /// - param newChild: The new `type` to replace the node's - /// current `type`, if present. - public func withType(_ newChild: TypeSyntax?) -> FunctionParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 11, with: raw, arena: arena) - return FunctionParameterSyntax(newData) - } - - public var unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? { + public var unexpectedBeforeDecl: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 12, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenTypeAndEllipsis(value) + self = withUnexpectedBeforeDecl(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenTypeAndEllipsis` replaced. - /// - param newChild: The new `unexpectedBetweenTypeAndEllipsis` to replace the node's - /// current `unexpectedBetweenTypeAndEllipsis`, if present. - public func withUnexpectedBetweenTypeAndEllipsis(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeDecl` replaced. + /// - param newChild: The new `unexpectedBeforeDecl` to replace the node's + /// current `unexpectedBeforeDecl`, if present. + public func withUnexpectedBeforeDecl(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclListItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 12, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return MemberDeclListItemSyntax(newData) } - public var ellipsis: TokenSyntax? { + /// The declaration of the type member. + public var decl: DeclSyntax { get { - let childData = data.child(at: 13, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + return DeclSyntax(childData!) } set(value) { - self = withEllipsis(value) + self = withDecl(value) } } - /// Returns a copy of the receiver with its `ellipsis` replaced. - /// - param newChild: The new `ellipsis` to replace the node's - /// current `ellipsis`, if present. - public func withEllipsis(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `decl` replaced. + /// - param newChild: The new `decl` to replace the node's + /// current `decl`, if present. + public func withDecl(_ newChild: DeclSyntax) -> MemberDeclListItemSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 13, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return MemberDeclListItemSyntax(newData) } - public var unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 14, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenEllipsisAndDefaultArgument(value) + self = withUnexpectedBetweenDeclAndSemicolon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenEllipsisAndDefaultArgument` replaced. - /// - param newChild: The new `unexpectedBetweenEllipsisAndDefaultArgument` to replace the node's - /// current `unexpectedBetweenEllipsisAndDefaultArgument`, if present. - public func withUnexpectedBetweenEllipsisAndDefaultArgument(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDeclAndSemicolon` replaced. + /// - param newChild: The new `unexpectedBetweenDeclAndSemicolon` to replace the node's + /// current `unexpectedBetweenDeclAndSemicolon`, if present. + public func withUnexpectedBetweenDeclAndSemicolon(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclListItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 14, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return MemberDeclListItemSyntax(newData) } - public var defaultArgument: InitializerClauseSyntax? { + /// An optional trailing semicolon. + public var semicolon: TokenSyntax? { get { - let childData = data.child(at: 15, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return InitializerClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDefaultArgument(value) + self = withSemicolon(value) } } - /// Returns a copy of the receiver with its `defaultArgument` replaced. - /// - param newChild: The new `defaultArgument` to replace the node's - /// current `defaultArgument`, if present. - public func withDefaultArgument(_ newChild: InitializerClauseSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `semicolon` replaced. + /// - param newChild: The new `semicolon` to replace the node's + /// current `semicolon`, if present. + public func withSemicolon(_ newChild: TokenSyntax?) -> MemberDeclListItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 15, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return MemberDeclListItemSyntax(newData) } - public var unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 16, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDefaultArgumentAndTrailingComma(value) + self = withUnexpectedAfterSemicolon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDefaultArgumentAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenDefaultArgumentAndTrailingComma` to replace the node's - /// current `unexpectedBetweenDefaultArgumentAndTrailingComma`, if present. - public func withUnexpectedBetweenDefaultArgumentAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterSemicolon` replaced. + /// - param newChild: The new `unexpectedAfterSemicolon` to replace the node's + /// current `unexpectedAfterSemicolon`, if present. + public func withUnexpectedAfterSemicolon(_ newChild: UnexpectedNodesSyntax?) -> MemberDeclListItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 16, with: raw, arena: arena) - return FunctionParameterSyntax(newData) - } - - public var trailingComma: TokenSyntax? { - get { - let childData = data.child(at: 17, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 17, with: raw, arena: arena) - return FunctionParameterSyntax(newData) - } - - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 18, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 18, with: raw, arena: arena) - return FunctionParameterSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return MemberDeclListItemSyntax(newData) } 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.unexpectedBetweenEllipsisAndDefaultArgument, - \Self.defaultArgument, - \Self.unexpectedBetweenDefaultArgumentAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeDecl, + \Self.decl, + \Self.unexpectedBetweenDeclAndSemicolon, + \Self.semicolon, + \Self.unexpectedAfterSemicolon, ]) } @@ -9032,40 +9003,12 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "attributes" + return nil case 2: return nil case 3: - return "modifiers" - case 4: - return nil - case 5: - return nil - case 6: - return nil - case 7: - return "internal name" - 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 "default argument" - case 16: - return nil - case 17: return nil - case 18: + case 4: return nil default: fatalError("Invalid index") @@ -9073,188 +9016,192 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { } } -extension FunctionParameterSyntax: CustomReflectable { +extension MemberDeclListItemSyntax: 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": 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": 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, - "unexpectedBetweenEllipsisAndDefaultArgument": unexpectedBetweenEllipsisAndDefaultArgument.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, + "unexpectedBeforeDecl": unexpectedBeforeDecl.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "decl": Syntax(decl).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDeclAndSemicolon": unexpectedBetweenDeclAndSemicolon.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: - AccessPathComponentSyntax +// MARK: - SourceFileSyntax -public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { +public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessPathComponent else { return nil } + guard node.raw.kind == .sourceFile else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessPathComponentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `SourceFileSyntax` 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) { - assert(data.raw.kind == .accessPathComponent) + assert(data.raw.kind == .sourceFile) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? = nil, - trailingDot: TokenSyntax? = nil, - _ unexpectedAfterTrailingDot: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? = nil, + eofToken: TokenSyntax, + _ unexpectedAfterEOFToken: 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, unexpectedBetweenNameAndTrailingDot, trailingDot, unexpectedAfterTrailingDot))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeStatements, statements, unexpectedBetweenStatementsAndEOFToken, eofToken, unexpectedAfterEOFToken))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingDot?.raw, - trailingDot?.raw, - unexpectedAfterTrailingDot?.raw, + unexpectedBeforeStatements?.raw, + statements.raw, + unexpectedBetweenStatementsAndEOFToken?.raw, + eofToken.raw, + unexpectedAfterEOFToken?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessPathComponent, from: layout, arena: arena, + kind: SyntaxKind.sourceFile, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeStatements: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeName(value) + self = withUnexpectedBeforeStatements(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. - /// - param newChild: The new `unexpectedBeforeName` to replace the node's - /// current `unexpectedBeforeName`, if present. - public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> AccessPathComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeStatements` replaced. + /// - param newChild: The new `unexpectedBeforeStatements` to replace the node's + /// current `unexpectedBeforeStatements`, if present. + public func withUnexpectedBeforeStatements(_ newChild: UnexpectedNodesSyntax?) -> SourceFileSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AccessPathComponentSyntax(newData) + return SourceFileSyntax(newData) } - public var name: TokenSyntax { + public var statements: CodeBlockItemListSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return CodeBlockItemListSyntax(childData!) } set(value) { - self = withName(value) + self = withStatements(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax) -> AccessPathComponentSyntax { + /// 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) -> SourceFileSyntax { + 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.codeBlockItemList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return SourceFileSyntax(newData) + } + + /// Returns a copy of the receiver with its `statements` replaced. + /// - param newChild: The new `statements` to replace the node's + /// current `statements`, if present. + public func withStatements(_ newChild: CodeBlockItemListSyntax) -> SourceFileSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AccessPathComponentSyntax(newData) + return SourceFileSyntax(newData) } - public var unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? { + public var unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndTrailingDot(value) + self = withUnexpectedBetweenStatementsAndEOFToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndTrailingDot` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndTrailingDot` to replace the node's - /// current `unexpectedBetweenNameAndTrailingDot`, if present. - public func withUnexpectedBetweenNameAndTrailingDot(_ newChild: UnexpectedNodesSyntax?) -> AccessPathComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenStatementsAndEOFToken` replaced. + /// - param newChild: The new `unexpectedBetweenStatementsAndEOFToken` to replace the node's + /// current `unexpectedBetweenStatementsAndEOFToken`, if present. + public func withUnexpectedBetweenStatementsAndEOFToken(_ newChild: UnexpectedNodesSyntax?) -> SourceFileSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AccessPathComponentSyntax(newData) + return SourceFileSyntax(newData) } - public var trailingDot: TokenSyntax? { + public var eofToken: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingDot(value) + self = withEOFToken(value) } } - /// Returns a copy of the receiver with its `trailingDot` replaced. - /// - param newChild: The new `trailingDot` to replace the node's - /// current `trailingDot`, if present. - public func withTrailingDot(_ newChild: TokenSyntax?) -> AccessPathComponentSyntax { + /// Returns a copy of the receiver with its `eofToken` replaced. + /// - param newChild: The new `eofToken` to replace the node's + /// current `eofToken`, if present. + public func withEOFToken(_ newChild: TokenSyntax) -> SourceFileSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AccessPathComponentSyntax(newData) + return SourceFileSyntax(newData) } - public var unexpectedAfterTrailingDot: UnexpectedNodesSyntax? { + public var unexpectedAfterEOFToken: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingDot(value) + self = withUnexpectedAfterEOFToken(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingDot` replaced. - /// - param newChild: The new `unexpectedAfterTrailingDot` to replace the node's - /// current `unexpectedAfterTrailingDot`, if present. - public func withUnexpectedAfterTrailingDot(_ newChild: UnexpectedNodesSyntax?) -> AccessPathComponentSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterEOFToken` replaced. + /// - param newChild: The new `unexpectedAfterEOFToken` to replace the node's + /// current `unexpectedAfterEOFToken`, if present. + public func withUnexpectedAfterEOFToken(_ newChild: UnexpectedNodesSyntax?) -> SourceFileSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AccessPathComponentSyntax(newData) + return SourceFileSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndTrailingDot, - \Self.trailingDot, - \Self.unexpectedAfterTrailingDot, + \Self.unexpectedBeforeStatements, + \Self.statements, + \Self.unexpectedBetweenStatementsAndEOFToken, + \Self.eofToken, + \Self.unexpectedAfterEOFToken, ]) } @@ -9263,7 +9210,7 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: @@ -9276,220 +9223,173 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AccessPathComponentSyntax: CustomReflectable { +extension SourceFileSyntax: 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), - "unexpectedBetweenNameAndTrailingDot": unexpectedBetweenNameAndTrailingDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "trailingDot": trailingDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterTrailingDot": unexpectedAfterTrailingDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeStatements": unexpectedBeforeStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenStatementsAndEOFToken": unexpectedBetweenStatementsAndEOFToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "eofToken": Syntax(eofToken).asProtocol(SyntaxProtocol.self), + "unexpectedAfterEOFToken": unexpectedAfterEOFToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - AccessorParameterSyntax +// MARK: - InitializerClauseSyntax -public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { +public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorParameter else { return nil } + guard node.raw.kind == .initializerClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessorParameterSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `InitializerClauseSyntax` 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) { - assert(data.raw.kind == .accessorParameter) + assert(data.raw.kind == .initializerClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, + equal: TokenSyntax = .equalToken(), + _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, + value: V, + _ unexpectedAfterValue: 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, unexpectedBetweenLeftParenAndName, name, unexpectedBetweenNameAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeEqual?.raw, + equal.raw, + unexpectedBetweenEqualAndValue?.raw, + value.raw, + unexpectedAfterValue?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorParameter, from: layout, arena: arena, + kind: SyntaxKind.initializerClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftParen(value) + self = withUnexpectedBeforeEqual(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. - /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's - /// current `unexpectedBeforeLeftParen`, if present. - public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeEqual` replaced. + /// - param newChild: The new `unexpectedBeforeEqual` to replace the node's + /// current `unexpectedBeforeEqual`, if present. + public func withUnexpectedBeforeEqual(_ newChild: UnexpectedNodesSyntax?) -> InitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AccessorParameterSyntax(newData) + return InitializerClauseSyntax(newData) } - public var leftParen: TokenSyntax { + public var equal: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withEqual(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> AccessorParameterSyntax { + /// Returns a copy of the receiver with its `equal` replaced. + /// - param newChild: The new `equal` to replace the node's + /// current `equal`, if present. + public func withEqual(_ newChild: TokenSyntax) -> InitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AccessorParameterSyntax(newData) + return InitializerClauseSyntax(newData) } - public var unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndName(value) + self = withUnexpectedBetweenEqualAndValue(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndName` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndName` to replace the node's - /// current `unexpectedBetweenLeftParenAndName`, if present. - public func withUnexpectedBetweenLeftParenAndName(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenEqualAndValue` replaced. + /// - param newChild: The new `unexpectedBetweenEqualAndValue` to replace the node's + /// current `unexpectedBetweenEqualAndValue`, if present. + public func withUnexpectedBetweenEqualAndValue(_ newChild: UnexpectedNodesSyntax?) -> InitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AccessorParameterSyntax(newData) + return InitializerClauseSyntax(newData) } - public var name: TokenSyntax { + public var value: ExprSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withName(value) + self = withValue(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax) -> AccessorParameterSyntax { + /// Returns a copy of the receiver with its `value` replaced. + /// - param newChild: The new `value` to replace the node's + /// current `value`, if present. + public func withValue(_ newChild: ExprSyntax) -> InitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AccessorParameterSyntax(newData) + return InitializerClauseSyntax(newData) } - public var unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndRightParen(value) + self = withUnexpectedAfterValue(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndRightParen` to replace the node's - /// current `unexpectedBetweenNameAndRightParen`, if present. - public func withUnexpectedBetweenNameAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterValue` replaced. + /// - param newChild: The new `unexpectedAfterValue` to replace the node's + /// current `unexpectedAfterValue`, if present. + public func withUnexpectedAfterValue(_ newChild: UnexpectedNodesSyntax?) -> InitializerClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AccessorParameterSyntax(newData) - } - - public var rightParen: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withRightParen(value) - } - } - - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> AccessorParameterSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AccessorParameterSyntax(newData) - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return AccessorParameterSyntax(newData) + return InitializerClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndName, - \Self.name, - \Self.unexpectedBetweenNameAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeEqual, + \Self.equal, + \Self.unexpectedBetweenEqualAndValue, + \Self.value, + \Self.unexpectedAfterValue, ]) } @@ -9502,12 +9402,8 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "name" - case 4: - return nil - case 5: return nil - case 6: + case 4: return nil default: fatalError("Invalid index") @@ -9515,564 +9411,547 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AccessorParameterSyntax: CustomReflectable { +extension InitializerClauseSyntax: 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), - "unexpectedBetweenLeftParenAndName": unexpectedBetweenLeftParenAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenNameAndRightParen": unexpectedBetweenNameAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeEqual": unexpectedBeforeEqual.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "equal": Syntax(equal).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenEqualAndValue": unexpectedBetweenEqualAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "value": Syntax(value).asProtocol(SyntaxProtocol.self), + "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - AccessorBlockSyntax +// MARK: - FunctionParameterSyntax -public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { +public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorBlock else { return nil } + guard node.raw.kind == .functionParameter else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessorBlockSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `FunctionParameterSyntax` 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) { - assert(data.raw.kind == .accessorBlock) + assert(data.raw.kind == .functionParameter) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? = nil, - accessors: AccessorListSyntax, - _ unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = 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: T? = 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 ) { // 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, unexpectedBetweenLeftBraceAndAccessors, accessors, unexpectedBetweenAccessorsAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAttributes, attributes, unexpectedBetweenAttributesAndModifiers, modifiers, unexpectedBetweenModifiersAndFirstName, firstName, unexpectedBetweenFirstNameAndSecondName, secondName, unexpectedBetweenSecondNameAndColon, colon, unexpectedBetweenColonAndType, type, unexpectedBetweenTypeAndEllipsis, ellipsis, unexpectedBetweenEllipsisAndDefaultArgument, defaultArgument, unexpectedBetweenDefaultArgumentAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndAccessors?.raw, - accessors.raw, - unexpectedBetweenAccessorsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorBlock, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) + 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, + unexpectedBetweenEllipsisAndDefaultArgument?.raw, + defaultArgument?.raw, + unexpectedBetweenDefaultArgumentAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.functionParameter, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { + /// 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 { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftBrace(value) + self = withUnexpectedBeforeAttributes(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftBrace` replaced. - /// - param newChild: The new `unexpectedBeforeLeftBrace` to replace the node's - /// current `unexpectedBeforeLeftBrace`, if present. - public func withUnexpectedBeforeLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAttributes` replaced. + /// - param newChild: The new `unexpectedBeforeAttributes` to replace the node's + /// current `unexpectedBeforeAttributes`, if present. + public func withUnexpectedBeforeAttributes(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - public var leftBrace: TokenSyntax { + public var attributes: AttributeListSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return AttributeListSyntax(childData!) } set(value) { - self = withLeftBrace(value) + self = withAttributes(value) } } - /// Returns a copy of the receiver with its `leftBrace` replaced. - /// - param newChild: The new `leftBrace` to replace the node's - /// current `leftBrace`, if present. - public func withLeftBrace(_ newChild: TokenSyntax) -> AccessorBlockSyntax { + /// 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) -> FunctionParameterSyntax { + var collection: RawSyntax let arena = SyntaxArena() - let raw = newChild.raw + 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 FunctionParameterSyntax(newData) + } + + /// Returns a copy of the receiver with its `attributes` replaced. + /// - param newChild: The new `attributes` to replace the node's + /// current `attributes`, if present. + public func withAttributes(_ newChild: AttributeListSyntax?) -> FunctionParameterSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftBraceAndAccessors(value) + self = withUnexpectedBetweenAttributesAndModifiers(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndAccessors` replaced. - /// - param newChild: The new `unexpectedBetweenLeftBraceAndAccessors` to replace the node's - /// current `unexpectedBetweenLeftBraceAndAccessors`, if present. - public func withUnexpectedBetweenLeftBraceAndAccessors(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAttributesAndModifiers` replaced. + /// - param newChild: The new `unexpectedBetweenAttributesAndModifiers` to replace the node's + /// current `unexpectedBetweenAttributesAndModifiers`, if present. + public func withUnexpectedBetweenAttributesAndModifiers(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - public var accessors: AccessorListSyntax { + public var modifiers: ModifierListSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return AccessorListSyntax(childData!) + if childData == nil { return nil } + return ModifierListSyntax(childData!) } set(value) { - self = withAccessors(value) + self = withModifiers(value) } } - /// Adds the provided `Accessor` to the node's `accessors` + /// Adds the provided `Modifier` to the node's `modifiers` /// collection. - /// - param element: The new `Accessor` to add to the node's - /// `accessors` collection. - /// - returns: A copy of the receiver with the provided `Accessor` - /// appended to its `accessors` collection. - public func addAccessor(_ element: AccessorDeclSyntax) -> AccessorBlockSyntax { + /// - 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) -> FunctionParameterSyntax { 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.accessorList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - /// Returns a copy of the receiver with its `accessors` replaced. - /// - param newChild: The new `accessors` to replace the node's - /// current `accessors`, if present. - public func withAccessors(_ newChild: AccessorListSyntax) -> AccessorBlockSyntax { + /// Returns a copy of the receiver with its `modifiers` replaced. + /// - param newChild: The new `modifiers` to replace the node's + /// current `modifiers`, if present. + public func withModifiers(_ newChild: ModifierListSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAccessorsAndRightBrace(value) + self = withUnexpectedBetweenModifiersAndFirstName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAccessorsAndRightBrace` replaced. - /// - param newChild: The new `unexpectedBetweenAccessorsAndRightBrace` to replace the node's - /// current `unexpectedBetweenAccessorsAndRightBrace`, if present. - public func withUnexpectedBetweenAccessorsAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenModifiersAndFirstName` replaced. + /// - param newChild: The new `unexpectedBetweenModifiersAndFirstName` to replace the node's + /// current `unexpectedBetweenModifiersAndFirstName`, if present. + public func withUnexpectedBetweenModifiersAndFirstName(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - public var rightBrace: TokenSyntax { + public var firstName: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withRightBrace(value) + self = withFirstName(value) } } - /// Returns a copy of the receiver with its `rightBrace` replaced. - /// - param newChild: The new `rightBrace` to replace the node's - /// current `rightBrace`, if present. - public func withRightBrace(_ newChild: TokenSyntax) -> AccessorBlockSyntax { + /// Returns a copy of the receiver with its `firstName` replaced. + /// - param newChild: The new `firstName` to replace the node's + /// current `firstName`, if present. + public func withFirstName(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightBrace(value) + self = withUnexpectedBetweenFirstNameAndSecondName(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. - /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's - /// current `unexpectedAfterRightBrace`, if present. - public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenFirstNameAndSecondName` replaced. + /// - param newChild: The new `unexpectedBetweenFirstNameAndSecondName` to replace the node's + /// current `unexpectedBetweenFirstNameAndSecondName`, if present. + public func withUnexpectedBetweenFirstNameAndSecondName(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + return FunctionParameterSyntax(newData) } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeLeftBrace, - \Self.leftBrace, - \Self.unexpectedBetweenLeftBraceAndAccessors, - \Self.accessors, - \Self.unexpectedBetweenAccessorsAndRightBrace, - \Self.rightBrace, - \Self.unexpectedAfterRightBrace, - ]) + public var secondName: TokenSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withSecondName(value) + } } - 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 - case 5: - return nil - case 6: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension AccessorBlockSyntax: 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), - "unexpectedBetweenLeftBraceAndAccessors": unexpectedBetweenLeftBraceAndAccessors.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "accessors": Syntax(accessors).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAccessorsAndRightBrace": unexpectedBetweenAccessorsAndRightBrace.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: - PatternBindingSyntax - -public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { - public enum Accessor: SyntaxChildChoices { - case `accessors`(AccessorBlockSyntax) - case `getter`(CodeBlockSyntax) - public var _syntaxNode: Syntax { - switch self { - case .accessors(let node): return node._syntaxNode - case .getter(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: AccessorBlockSyntax) { - self = .accessors(node) - } - public init(_ node: CodeBlockSyntax) { - self = .getter(node) - } - public init?(_ node: S) { - if let node = node.as(AccessorBlockSyntax.self) { - self = .accessors(node) - return - } - if let node = node.as(CodeBlockSyntax.self) { - self = .getter(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(AccessorBlockSyntax.self), - .node(CodeBlockSyntax.self), - ]) - } - } - - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .patternBinding else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `PatternBindingSyntax` 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) { - assert(data.raw.kind == .patternBinding) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax? = nil, - _ unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? = nil, - accessor: Accessor? = nil, - _ unexpectedBetweenAccessorAndTrailingComma: 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(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedBetweenInitializerAndAccessor, accessor, unexpectedBetweenAccessorAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer?.raw, - unexpectedBetweenInitializerAndAccessor?.raw, - accessor?.raw, - unexpectedBetweenAccessorAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.patternBinding, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) + /// Returns a copy of the receiver with its `secondName` replaced. + /// - param newChild: The new `secondName` to replace the node's + /// current `secondName`, if present. + public func withSecondName(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedBeforePattern: UnexpectedNodesSyntax? { + public var unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePattern(value) + self = withUnexpectedBetweenSecondNameAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. - /// - param newChild: The new `unexpectedBeforePattern` to replace the node's - /// current `unexpectedBeforePattern`, if present. - public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenSecondNameAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenSecondNameAndColon` to replace the node's + /// current `unexpectedBetweenSecondNameAndColon`, if present. + public func withUnexpectedBetweenSecondNameAndColon(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var pattern: PatternSyntax { + public var colon: TokenSyntax? { get { - let childData = data.child(at: 1, parent: Syntax(self)) - return PatternSyntax(childData!) + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withPattern(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `pattern` replaced. - /// - param newChild: The new `pattern` to replace the node's - /// current `pattern`, if present. - public func withPattern(_ newChild: PatternSyntax) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndType: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPatternAndTypeAnnotation(value) + self = withUnexpectedBetweenColonAndType(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndTypeAnnotation` replaced. - /// - param newChild: The new `unexpectedBetweenPatternAndTypeAnnotation` to replace the node's - /// current `unexpectedBetweenPatternAndTypeAnnotation`, if present. - public func withUnexpectedBetweenPatternAndTypeAnnotation(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndType` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndType` to replace the node's + /// current `unexpectedBetweenColonAndType`, if present. + public func withUnexpectedBetweenColonAndType(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var typeAnnotation: TypeAnnotationSyntax? { + public var type: TypeSyntax? { get { - let childData = data.child(at: 3, parent: Syntax(self)) + let childData = data.child(at: 11, parent: Syntax(self)) if childData == nil { return nil } - return TypeAnnotationSyntax(childData!) + return TypeSyntax(childData!) } set(value) { - self = withTypeAnnotation(value) + self = withType(value) } } - /// Returns a copy of the receiver with its `typeAnnotation` replaced. - /// - param newChild: The new `typeAnnotation` to replace the node's - /// current `typeAnnotation`, if present. - public func withTypeAnnotation(_ newChild: TypeAnnotationSyntax?) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `type` replaced. + /// - param newChild: The new `type` to replace the node's + /// current `type`, if present. + public func withType(_ newChild: TypeSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 11, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 12, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenTypeAnnotationAndInitializer(value) + self = withUnexpectedBetweenTypeAndEllipsis(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenTypeAnnotationAndInitializer` replaced. - /// - param newChild: The new `unexpectedBetweenTypeAnnotationAndInitializer` to replace the node's - /// current `unexpectedBetweenTypeAnnotationAndInitializer`, if present. - public func withUnexpectedBetweenTypeAnnotationAndInitializer(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenTypeAndEllipsis` replaced. + /// - param newChild: The new `unexpectedBetweenTypeAndEllipsis` to replace the node's + /// current `unexpectedBetweenTypeAndEllipsis`, if present. + public func withUnexpectedBetweenTypeAndEllipsis(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 12, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var initializer: InitializerClauseSyntax? { + public var ellipsis: TokenSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) + let childData = data.child(at: 13, parent: Syntax(self)) if childData == nil { return nil } - return InitializerClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withInitializer(value) + self = withEllipsis(value) } } - /// Returns a copy of the receiver with its `initializer` replaced. - /// - param newChild: The new `initializer` to replace the node's - /// current `initializer`, if present. - public func withInitializer(_ newChild: InitializerClauseSyntax?) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `ellipsis` replaced. + /// - param newChild: The new `ellipsis` to replace the node's + /// current `ellipsis`, if present. + public func withEllipsis(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 13, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? { + public var unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 14, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenInitializerAndAccessor(value) + self = withUnexpectedBetweenEllipsisAndDefaultArgument(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenInitializerAndAccessor` replaced. - /// - param newChild: The new `unexpectedBetweenInitializerAndAccessor` to replace the node's - /// current `unexpectedBetweenInitializerAndAccessor`, if present. - public func withUnexpectedBetweenInitializerAndAccessor(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return PatternBindingSyntax(newData) + /// Returns a copy of the receiver with its `unexpectedBetweenEllipsisAndDefaultArgument` replaced. + /// - param newChild: The new `unexpectedBetweenEllipsisAndDefaultArgument` to replace the node's + /// current `unexpectedBetweenEllipsisAndDefaultArgument`, if present. + public func withUnexpectedBetweenEllipsisAndDefaultArgument(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 14, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var accessor: Accessor? { + public var defaultArgument: InitializerClauseSyntax? { get { - let childData = data.child(at: 7, parent: Syntax(self)) + let childData = data.child(at: 15, parent: Syntax(self)) if childData == nil { return nil } - return Accessor(childData!) + return InitializerClauseSyntax(childData!) } set(value) { - self = withAccessor(value) + self = withDefaultArgument(value) } } - /// Returns a copy of the receiver with its `accessor` replaced. - /// - param newChild: The new `accessor` to replace the node's - /// current `accessor`, if present. - public func withAccessor(_ newChild: Accessor?) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `defaultArgument` replaced. + /// - param newChild: The new `defaultArgument` to replace the node's + /// current `defaultArgument`, if present. + public func withDefaultArgument(_ newChild: InitializerClauseSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 15, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 16, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAccessorAndTrailingComma(value) + self = withUnexpectedBetweenDefaultArgumentAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAccessorAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenAccessorAndTrailingComma` to replace the node's - /// current `unexpectedBetweenAccessorAndTrailingComma`, if present. - public func withUnexpectedBetweenAccessorAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDefaultArgumentAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenDefaultArgumentAndTrailingComma` to replace the node's + /// current `unexpectedBetweenDefaultArgumentAndTrailingComma`, if present. + public func withUnexpectedBetweenDefaultArgumentAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 16, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } public var trailingComma: TokenSyntax? { get { - let childData = data.child(at: 9, parent: Syntax(self)) + let childData = data.child(at: 17, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } @@ -10084,16 +9963,16 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `trailingComma` replaced. /// - param newChild: The new `trailingComma` to replace the node's /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> PatternBindingSyntax { + public func withTrailingComma(_ newChild: TokenSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 17, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 18, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } @@ -10105,24 +9984,32 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> FunctionParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 18, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePattern, - \Self.pattern, - \Self.unexpectedBetweenPatternAndTypeAnnotation, - \Self.typeAnnotation, - \Self.unexpectedBetweenTypeAnnotationAndInitializer, - \Self.initializer, - \Self.unexpectedBetweenInitializerAndAccessor, - \Self.accessor, - \Self.unexpectedBetweenAccessorAndTrailingComma, + \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.unexpectedBetweenEllipsisAndDefaultArgument, + \Self.defaultArgument, + \Self.unexpectedBetweenDefaultArgumentAndTrailingComma, \Self.trailingComma, \Self.unexpectedAfterTrailingComma, ]) @@ -10133,11 +10020,11 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "attributes" case 2: return nil case 3: - return "type annotation" + return "modifiers" case 4: return nil case 5: @@ -10145,302 +10032,217 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { case 6: return nil case 7: - return nil + return "internal name" 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 "default argument" + case 16: + return nil + case 17: + return nil + case 18: + return nil default: fatalError("Invalid index") } } } -extension PatternBindingSyntax: CustomReflectable { +extension FunctionParameterSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "initializer": initializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenInitializerAndAccessor": unexpectedBetweenInitializerAndAccessor.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "accessor": accessor.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAccessorAndTrailingComma": unexpectedBetweenAccessorAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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": 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": 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, + "unexpectedBetweenEllipsisAndDefaultArgument": unexpectedBetweenEllipsisAndDefaultArgument.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, ]) } } -// MARK: - EnumCaseElementSyntax +// MARK: - AccessPathComponentSyntax -/// -/// 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 AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumCaseElement else { return nil } + guard node.raw.kind == .accessPathComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `EnumCaseElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AccessPathComponentSyntax` 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) { - assert(data.raw.kind == .enumCaseElement) + assert(data.raw.kind == .accessPathComponent) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? = nil, - associatedValue: ParameterClauseSyntax? = nil, - _ unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? = nil, - rawValue: InitializerClauseSyntax? = nil, - _ unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? = nil, + trailingDot: TokenSyntax? = nil, + _ unexpectedAfterTrailingDot: 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(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndAssociatedValue, associatedValue, unexpectedBetweenAssociatedValueAndRawValue, rawValue, unexpectedBetweenRawValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingDot, trailingDot, unexpectedAfterTrailingDot))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndAssociatedValue?.raw, - associatedValue?.raw, - unexpectedBetweenAssociatedValueAndRawValue?.raw, - rawValue?.raw, - unexpectedBetweenRawValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndTrailingDot?.raw, + trailingDot?.raw, + unexpectedAfterTrailingDot?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseElement, from: layout, arena: arena, + kind: SyntaxKind.accessPathComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeIdentifier(value) + self = withUnexpectedBeforeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeIdentifier` replaced. - /// - param newChild: The new `unexpectedBeforeIdentifier` to replace the node's - /// current `unexpectedBeforeIdentifier`, if present. - public func withUnexpectedBeforeIdentifier(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. + /// - param newChild: The new `unexpectedBeforeName` to replace the node's + /// current `unexpectedBeforeName`, if present. + public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> AccessPathComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + return AccessPathComponentSyntax(newData) } - /// The name of this case. - public var identifier: TokenSyntax { + public var name: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withIdentifier(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `identifier` replaced. - /// - param newChild: The new `identifier` to replace the node's - /// current `identifier`, if present. - public func withIdentifier(_ newChild: TokenSyntax) -> EnumCaseElementSyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax) -> AccessPathComponentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + return AccessPathComponentSyntax(newData) } - public var unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenIdentifierAndAssociatedValue(value) + self = withUnexpectedBetweenNameAndTrailingDot(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenIdentifierAndAssociatedValue` replaced. - /// - param newChild: The new `unexpectedBetweenIdentifierAndAssociatedValue` to replace the node's - /// current `unexpectedBetweenIdentifierAndAssociatedValue`, if present. - public func withUnexpectedBetweenIdentifierAndAssociatedValue(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndTrailingDot` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndTrailingDot` to replace the node's + /// current `unexpectedBetweenNameAndTrailingDot`, if present. + public func withUnexpectedBetweenNameAndTrailingDot(_ newChild: UnexpectedNodesSyntax?) -> AccessPathComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + return AccessPathComponentSyntax(newData) } - /// The set of associated values of the case. - public var associatedValue: ParameterClauseSyntax? { + public var trailingDot: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return ParameterClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withAssociatedValue(value) + self = withTrailingDot(value) } } - /// Returns a copy of the receiver with its `associatedValue` replaced. - /// - param newChild: The new `associatedValue` to replace the node's - /// current `associatedValue`, if present. - public func withAssociatedValue(_ newChild: ParameterClauseSyntax?) -> EnumCaseElementSyntax { + /// Returns a copy of the receiver with its `trailingDot` replaced. + /// - param newChild: The new `trailingDot` to replace the node's + /// current `trailingDot`, if present. + public func withTrailingDot(_ newChild: TokenSyntax?) -> AccessPathComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + return AccessPathComponentSyntax(newData) } - public var unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingDot: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAssociatedValueAndRawValue(value) + self = withUnexpectedAfterTrailingDot(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAssociatedValueAndRawValue` replaced. - /// - param newChild: The new `unexpectedBetweenAssociatedValueAndRawValue` to replace the node's - /// current `unexpectedBetweenAssociatedValueAndRawValue`, if present. - public func withUnexpectedBetweenAssociatedValueAndRawValue(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) - } - - /// - /// The raw value of this enum element, if present. - /// - public var rawValue: InitializerClauseSyntax? { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return InitializerClauseSyntax(childData!) - } - set(value) { - self = withRawValue(value) - } - } - - /// Returns a copy of the receiver with its `rawValue` replaced. - /// - param newChild: The new `rawValue` to replace the node's - /// current `rawValue`, if present. - public func withRawValue(_ newChild: InitializerClauseSyntax?) -> EnumCaseElementSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) - } - - public var unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenRawValueAndTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenRawValueAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenRawValueAndTrailingComma` to replace the node's - /// current `unexpectedBetweenRawValueAndTrailingComma`, if present. - public func withUnexpectedBetweenRawValueAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) - } - - /// - /// The trailing comma of this element, if the case has - /// multiple elements. - /// - public var trailingComma: TokenSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> EnumCaseElementSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) - } - - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingDot` replaced. + /// - param newChild: The new `unexpectedAfterTrailingDot` to replace the node's + /// current `unexpectedAfterTrailingDot`, if present. + public func withUnexpectedAfterTrailingDot(_ newChild: UnexpectedNodesSyntax?) -> AccessPathComponentSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return AccessPathComponentSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIdentifier, - \Self.identifier, - \Self.unexpectedBetweenIdentifierAndAssociatedValue, - \Self.associatedValue, - \Self.unexpectedBetweenAssociatedValueAndRawValue, - \Self.rawValue, - \Self.unexpectedBetweenRawValueAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndTrailingDot, + \Self.trailingDot, + \Self.unexpectedAfterTrailingDot, ]) } @@ -10449,20 +10251,12 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "name" case 2: return nil case 3: - return "associated values" - case 4: - return nil - case 5: - return nil - case 6: - return nil - case 7: return nil - case 8: + case 4: return nil default: fatalError("Invalid index") @@ -10470,127 +10264,127 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { } } -extension EnumCaseElementSyntax: CustomReflectable { +extension AccessPathComponentSyntax: 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, - "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenNameAndTrailingDot": unexpectedBetweenNameAndTrailingDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "trailingDot": trailingDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterTrailingDot": unexpectedAfterTrailingDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DesignatedTypeElementSyntax +// MARK: - AccessorParameterSyntax -public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { +public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .designatedTypeElement else { return nil } + guard node.raw.kind == .accessorParameter else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DesignatedTypeElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AccessorParameterSyntax` 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) { - assert(data.raw.kind == .designatedTypeElement) + assert(data.raw.kind == .accessorParameter) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, - leadingComma: TokenSyntax = .commaToken(), - _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, name: TokenSyntax, - _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenNameAndRightParen: 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(), (unexpectedBeforeLeadingComma, leadingComma, unexpectedBetweenLeadingCommaAndName, name, unexpectedAfterName))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndName, name, unexpectedBetweenNameAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeadingComma?.raw, - leadingComma.raw, - unexpectedBetweenLeadingCommaAndName?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndName?.raw, name.raw, - unexpectedAfterName?.raw, + unexpectedBetweenNameAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.designatedTypeElement, from: layout, arena: arena, + kind: SyntaxKind.accessorParameter, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeadingComma(value) + self = withUnexpectedBeforeLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeadingComma` replaced. - /// - param newChild: The new `unexpectedBeforeLeadingComma` to replace the node's - /// current `unexpectedBeforeLeadingComma`, if present. - public func withUnexpectedBeforeLeadingComma(_ newChild: UnexpectedNodesSyntax?) -> DesignatedTypeElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. + /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's + /// current `unexpectedBeforeLeftParen`, if present. + public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DesignatedTypeElementSyntax(newData) + return AccessorParameterSyntax(newData) } - public var leadingComma: TokenSyntax { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeadingComma(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `leadingComma` replaced. - /// - param newChild: The new `leadingComma` to replace the node's - /// current `leadingComma`, if present. - public func withLeadingComma(_ newChild: TokenSyntax) -> DesignatedTypeElementSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> AccessorParameterSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DesignatedTypeElementSyntax(newData) + return AccessorParameterSyntax(newData) } - public var unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeadingCommaAndName(value) + self = withUnexpectedBetweenLeftParenAndName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeadingCommaAndName` replaced. - /// - param newChild: The new `unexpectedBetweenLeadingCommaAndName` to replace the node's - /// current `unexpectedBetweenLeadingCommaAndName`, if present. - public func withUnexpectedBetweenLeadingCommaAndName(_ newChild: UnexpectedNodesSyntax?) -> DesignatedTypeElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndName` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndName` to replace the node's + /// current `unexpectedBetweenLeftParenAndName`, if present. + public func withUnexpectedBetweenLeftParenAndName(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DesignatedTypeElementSyntax(newData) + return AccessorParameterSyntax(newData) } public var name: TokenSyntax { @@ -10606,304 +10400,344 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `name` replaced. /// - param newChild: The new `name` to replace the node's /// current `name`, if present. - public func withName(_ newChild: TokenSyntax) -> DesignatedTypeElementSyntax { + public func withName(_ newChild: TokenSyntax) -> AccessorParameterSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DesignatedTypeElementSyntax(newData) + return AccessorParameterSyntax(newData) } - public var unexpectedAfterName: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterName(value) + self = withUnexpectedBetweenNameAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterName` replaced. - /// - param newChild: The new `unexpectedAfterName` to replace the node's - /// current `unexpectedAfterName`, if present. - public func withUnexpectedAfterName(_ newChild: UnexpectedNodesSyntax?) -> DesignatedTypeElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndRightParen` to replace the node's + /// current `unexpectedBetweenNameAndRightParen`, if present. + public func withUnexpectedBetweenNameAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DesignatedTypeElementSyntax(newData) + return AccessorParameterSyntax(newData) } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeLeadingComma, - \Self.leadingComma, - \Self.unexpectedBetweenLeadingCommaAndName, - \Self.name, - \Self.unexpectedAfterName, - ]) + public var rightParen: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withRightParen(value) + } } - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - case 3: + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> AccessorParameterSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return AccessorParameterSyntax(newData) + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightParen(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> AccessorParameterSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return AccessorParameterSyntax(newData) + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndName, + \Self.name, + \Self.unexpectedBetweenNameAndRightParen, + \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 "name" case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension DesignatedTypeElementSyntax: CustomReflectable { +extension AccessorParameterSyntax: 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, + "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndName": unexpectedBetweenLeftParenAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedAfterName": unexpectedAfterName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenNameAndRightParen": unexpectedBetweenNameAndRightParen.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: - OperatorPrecedenceAndTypesSyntax +// MARK: - AccessorBlockSyntax -/// -/// A clause to specify precedence group in infix operator declarations, and designated types in any operator declaration. -/// -public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { +public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .operatorPrecedenceAndTypes else { return nil } + guard node.raw.kind == .accessorBlock else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OperatorPrecedenceAndTypesSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AccessorBlockSyntax` 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) { - assert(data.raw.kind == .operatorPrecedenceAndTypes) + assert(data.raw.kind == .accessorBlock) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, - precedenceGroup: TokenSyntax, - _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, - designatedTypes: DesignatedTypeListSyntax, - _ unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? = nil, + accessors: AccessorListSyntax, + _ unexpectedBetweenAccessorsAndRightBrace: 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(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndPrecedenceGroup, precedenceGroup, unexpectedBetweenPrecedenceGroupAndDesignatedTypes, designatedTypes, unexpectedAfterDesignatedTypes))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndAccessors, accessors, unexpectedBetweenAccessorsAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndPrecedenceGroup?.raw, - precedenceGroup.raw, - unexpectedBetweenPrecedenceGroupAndDesignatedTypes?.raw, - designatedTypes.raw, - unexpectedAfterDesignatedTypes?.raw, + unexpectedBeforeLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndAccessors?.raw, + accessors.raw, + unexpectedBetweenAccessorsAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.operatorPrecedenceAndTypes, from: layout, arena: arena, + kind: SyntaxKind.accessorBlock, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeColon: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeColon(value) + self = withUnexpectedBeforeLeftBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeColon` replaced. - /// - param newChild: The new `unexpectedBeforeColon` to replace the node's - /// current `unexpectedBeforeColon`, if present. - public func withUnexpectedBeforeColon(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftBrace` replaced. + /// - param newChild: The new `unexpectedBeforeLeftBrace` to replace the node's + /// current `unexpectedBeforeLeftBrace`, if present. + public func withUnexpectedBeforeLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return AccessorBlockSyntax(newData) } - public var colon: TokenSyntax { + public var leftBrace: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withLeftBrace(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> OperatorPrecedenceAndTypesSyntax { + /// Returns a copy of the receiver with its `leftBrace` replaced. + /// - param newChild: The new `leftBrace` to replace the node's + /// current `leftBrace`, if present. + public func withLeftBrace(_ newChild: TokenSyntax) -> AccessorBlockSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return AccessorBlockSyntax(newData) } - public var unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndPrecedenceGroup(value) + self = withUnexpectedBetweenLeftBraceAndAccessors(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndPrecedenceGroup` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndPrecedenceGroup` to replace the node's - /// current `unexpectedBetweenColonAndPrecedenceGroup`, if present. - public func withUnexpectedBetweenColonAndPrecedenceGroup(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndAccessors` replaced. + /// - param newChild: The new `unexpectedBetweenLeftBraceAndAccessors` to replace the node's + /// current `unexpectedBetweenLeftBraceAndAccessors`, if present. + public func withUnexpectedBetweenLeftBraceAndAccessors(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return AccessorBlockSyntax(newData) } - /// - /// The precedence group for this operator - /// - public var precedenceGroup: TokenSyntax { + public var accessors: AccessorListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + return AccessorListSyntax(childData!) } set(value) { - self = withPrecedenceGroup(value) + self = withAccessors(value) } } - /// Returns a copy of the receiver with its `precedenceGroup` replaced. - /// - param newChild: The new `precedenceGroup` to replace the node's - /// current `precedenceGroup`, if present. - public func withPrecedenceGroup(_ newChild: TokenSyntax) -> OperatorPrecedenceAndTypesSyntax { + /// Adds the provided `Accessor` to the node's `accessors` + /// collection. + /// - param element: The new `Accessor` to add to the node's + /// `accessors` collection. + /// - returns: A copy of the receiver with the provided `Accessor` + /// appended to its `accessors` collection. + public func addAccessor(_ element: AccessorDeclSyntax) -> AccessorBlockSyntax { + 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.accessorList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return AccessorBlockSyntax(newData) + } + + /// Returns a copy of the receiver with its `accessors` replaced. + /// - param newChild: The new `accessors` to replace the node's + /// current `accessors`, if present. + public func withAccessors(_ newChild: AccessorListSyntax) -> AccessorBlockSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return AccessorBlockSyntax(newData) } - public var unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? { + public var unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPrecedenceGroupAndDesignatedTypes(value) + self = withUnexpectedBetweenAccessorsAndRightBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPrecedenceGroupAndDesignatedTypes` replaced. - /// - param newChild: The new `unexpectedBetweenPrecedenceGroupAndDesignatedTypes` to replace the node's - /// current `unexpectedBetweenPrecedenceGroupAndDesignatedTypes`, if present. - public func withUnexpectedBetweenPrecedenceGroupAndDesignatedTypes(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAccessorsAndRightBrace` replaced. + /// - param newChild: The new `unexpectedBetweenAccessorsAndRightBrace` to replace the node's + /// current `unexpectedBetweenAccessorsAndRightBrace`, if present. + public func withUnexpectedBetweenAccessorsAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return AccessorBlockSyntax(newData) } - /// - /// The designated types associated with this operator. - /// - public var designatedTypes: DesignatedTypeListSyntax { + public var rightBrace: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return DesignatedTypeListSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDesignatedTypes(value) - } - } - - /// Adds the provided `DesignatedTypeElement` to the node's `designatedTypes` - /// collection. - /// - param element: The new `DesignatedTypeElement` to add to the node's - /// `designatedTypes` collection. - /// - returns: A copy of the receiver with the provided `DesignatedTypeElement` - /// appended to its `designatedTypes` collection. - public func addDesignatedTypeElement(_ element: DesignatedTypeElementSyntax) -> OperatorPrecedenceAndTypesSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[5] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.designatedTypeList, - from: [element.raw], arena: arena) + self = withRightBrace(value) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) } - /// Returns a copy of the receiver with its `designatedTypes` replaced. - /// - param newChild: The new `designatedTypes` to replace the node's - /// current `designatedTypes`, if present. - public func withDesignatedTypes(_ newChild: DesignatedTypeListSyntax) -> OperatorPrecedenceAndTypesSyntax { + /// Returns a copy of the receiver with its `rightBrace` replaced. + /// - param newChild: The new `rightBrace` to replace the node's + /// current `rightBrace`, if present. + public func withRightBrace(_ newChild: TokenSyntax) -> AccessorBlockSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return AccessorBlockSyntax(newData) } - public var unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? { + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterDesignatedTypes(value) + self = withUnexpectedAfterRightBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterDesignatedTypes` replaced. - /// - param newChild: The new `unexpectedAfterDesignatedTypes` to replace the node's - /// current `unexpectedAfterDesignatedTypes`, if present. - public func withUnexpectedAfterDesignatedTypes(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw + /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. + /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's + /// current `unexpectedAfterRightBrace`, if present. + public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> AccessorBlockSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return AccessorBlockSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeColon, - \Self.colon, - \Self.unexpectedBetweenColonAndPrecedenceGroup, - \Self.precedenceGroup, - \Self.unexpectedBetweenPrecedenceGroupAndDesignatedTypes, - \Self.designatedTypes, - \Self.unexpectedAfterDesignatedTypes, + \Self.unexpectedBeforeLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndAccessors, + \Self.accessors, + \Self.unexpectedBetweenAccessorsAndRightBrace, + \Self.rightBrace, + \Self.unexpectedAfterRightBrace, ]) } @@ -10916,7 +10750,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "precedence group" + return nil case 4: return nil case 5: @@ -10929,252 +10763,356 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { } } -extension OperatorPrecedenceAndTypesSyntax: CustomReflectable { +extension AccessorBlockSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeColon": unexpectedBeforeColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndPrecedenceGroup": unexpectedBetweenColonAndPrecedenceGroup.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "precedenceGroup": Syntax(precedenceGroup).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPrecedenceGroupAndDesignatedTypes": unexpectedBetweenPrecedenceGroupAndDesignatedTypes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "designatedTypes": Syntax(designatedTypes).asProtocol(SyntaxProtocol.self), - "unexpectedAfterDesignatedTypes": unexpectedAfterDesignatedTypes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLeftBrace": unexpectedBeforeLeftBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftBrace": Syntax(leftBrace).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftBraceAndAccessors": unexpectedBetweenLeftBraceAndAccessors.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "accessors": Syntax(accessors).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAccessorsAndRightBrace": unexpectedBetweenAccessorsAndRightBrace.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: - PrecedenceGroupRelationSyntax +// MARK: - PatternBindingSyntax + +public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { + public enum Accessor: SyntaxChildChoices { + case `accessors`(AccessorBlockSyntax) + case `getter`(CodeBlockSyntax) + public var _syntaxNode: Syntax { + switch self { + case .accessors(let node): return node._syntaxNode + case .getter(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: AccessorBlockSyntax) { + self = .accessors(node) + } + public init(_ node: CodeBlockSyntax) { + self = .getter(node) + } + public init?(_ node: S) { + if let node = node.as(AccessorBlockSyntax.self) { + self = .accessors(node) + return + } + if let node = node.as(CodeBlockSyntax.self) { + self = .getter(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(AccessorBlockSyntax.self), + .node(CodeBlockSyntax.self), + ]) + } + } -/// -/// Specify the new precedence group's relation to existing precedence -/// groups. -/// -public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupRelation else { return nil } + guard node.raw.kind == .patternBinding else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupRelationSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `PatternBindingSyntax` 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) { - assert(data.raw.kind == .precedenceGroupRelation) + assert(data.raw.kind == .patternBinding) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? = nil, - higherThanOrLowerThan: TokenSyntax, - _ unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? = nil, - otherNames: PrecedenceGroupNameListSyntax, - _ unexpectedAfterOtherNames: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax? = nil, + _ unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? = nil, + accessor: Accessor? = nil, + _ unexpectedBetweenAccessorAndTrailingComma: 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(), (unexpectedBeforeHigherThanOrLowerThan, higherThanOrLowerThan, unexpectedBetweenHigherThanOrLowerThanAndColon, colon, unexpectedBetweenColonAndOtherNames, otherNames, unexpectedAfterOtherNames))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedBetweenInitializerAndAccessor, accessor, unexpectedBetweenAccessorAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeHigherThanOrLowerThan?.raw, - higherThanOrLowerThan.raw, - unexpectedBetweenHigherThanOrLowerThanAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndOtherNames?.raw, - otherNames.raw, - unexpectedAfterOtherNames?.raw, + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer?.raw, + unexpectedBetweenInitializerAndAccessor?.raw, + accessor?.raw, + unexpectedBetweenAccessorAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupRelation, from: layout, arena: arena, + kind: SyntaxKind.patternBinding, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? { + public var unexpectedBeforePattern: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeHigherThanOrLowerThan(value) + self = withUnexpectedBeforePattern(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeHigherThanOrLowerThan` replaced. - /// - param newChild: The new `unexpectedBeforeHigherThanOrLowerThan` to replace the node's - /// current `unexpectedBeforeHigherThanOrLowerThan`, if present. - public func withUnexpectedBeforeHigherThanOrLowerThan(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. + /// - param newChild: The new `unexpectedBeforePattern` to replace the node's + /// current `unexpectedBeforePattern`, if present. + public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return PatternBindingSyntax(newData) } - /// - /// The relation to specified other precedence groups. - /// - public var higherThanOrLowerThan: TokenSyntax { + public var pattern: PatternSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return PatternSyntax(childData!) } set(value) { - self = withHigherThanOrLowerThan(value) + self = withPattern(value) } } - /// Returns a copy of the receiver with its `higherThanOrLowerThan` replaced. - /// - param newChild: The new `higherThanOrLowerThan` to replace the node's - /// current `higherThanOrLowerThan`, if present. - public func withHigherThanOrLowerThan(_ newChild: TokenSyntax) -> PrecedenceGroupRelationSyntax { + /// Returns a copy of the receiver with its `pattern` replaced. + /// - param newChild: The new `pattern` to replace the node's + /// current `pattern`, if present. + public func withPattern(_ newChild: PatternSyntax) -> PatternBindingSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return PatternBindingSyntax(newData) } - public var unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenHigherThanOrLowerThanAndColon(value) + self = withUnexpectedBetweenPatternAndTypeAnnotation(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenHigherThanOrLowerThanAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenHigherThanOrLowerThanAndColon` to replace the node's - /// current `unexpectedBetweenHigherThanOrLowerThanAndColon`, if present. - public func withUnexpectedBetweenHigherThanOrLowerThanAndColon(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndTypeAnnotation` replaced. + /// - param newChild: The new `unexpectedBetweenPatternAndTypeAnnotation` to replace the node's + /// current `unexpectedBetweenPatternAndTypeAnnotation`, if present. + public func withUnexpectedBetweenPatternAndTypeAnnotation(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return PatternBindingSyntax(newData) } - public var colon: TokenSyntax { + public var typeAnnotation: TypeAnnotationSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return TypeAnnotationSyntax(childData!) } set(value) { - self = withColon(value) + self = withTypeAnnotation(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> PrecedenceGroupRelationSyntax { + /// Returns a copy of the receiver with its `typeAnnotation` replaced. + /// - param newChild: The new `typeAnnotation` to replace the node's + /// current `typeAnnotation`, if present. + public func withTypeAnnotation(_ newChild: TypeAnnotationSyntax?) -> PatternBindingSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return PatternBindingSyntax(newData) } - public var unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndOtherNames(value) + self = withUnexpectedBetweenTypeAnnotationAndInitializer(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndOtherNames` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndOtherNames` to replace the node's - /// current `unexpectedBetweenColonAndOtherNames`, if present. - public func withUnexpectedBetweenColonAndOtherNames(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenTypeAnnotationAndInitializer` replaced. + /// - param newChild: The new `unexpectedBetweenTypeAnnotationAndInitializer` to replace the node's + /// current `unexpectedBetweenTypeAnnotationAndInitializer`, if present. + public func withUnexpectedBetweenTypeAnnotationAndInitializer(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return PatternBindingSyntax(newData) } - /// - /// The name of other precedence group to which this precedence - /// group relates. - /// - public var otherNames: PrecedenceGroupNameListSyntax { + public var initializer: InitializerClauseSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return PrecedenceGroupNameListSyntax(childData!) + if childData == nil { return nil } + return InitializerClauseSyntax(childData!) } set(value) { - self = withOtherNames(value) - } - } - - /// Adds the provided `OtherName` to the node's `otherNames` - /// collection. - /// - param element: The new `OtherName` to add to the node's - /// `otherNames` collection. - /// - returns: A copy of the receiver with the provided `OtherName` - /// appended to its `otherNames` collection. - public func addOtherName(_ element: PrecedenceGroupNameElementSyntax) -> PrecedenceGroupRelationSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[5] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupNameList, - from: [element.raw], arena: arena) + self = withInitializer(value) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return PrecedenceGroupRelationSyntax(newData) } - /// Returns a copy of the receiver with its `otherNames` replaced. - /// - param newChild: The new `otherNames` to replace the node's - /// current `otherNames`, if present. - public func withOtherNames(_ newChild: PrecedenceGroupNameListSyntax) -> PrecedenceGroupRelationSyntax { + /// Returns a copy of the receiver with its `initializer` replaced. + /// - param newChild: The new `initializer` to replace the node's + /// current `initializer`, if present. + public func withInitializer(_ newChild: InitializerClauseSyntax?) -> PatternBindingSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return PatternBindingSyntax(newData) } - public var unexpectedAfterOtherNames: UnexpectedNodesSyntax? { + public var unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterOtherNames(value) + self = withUnexpectedBetweenInitializerAndAccessor(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterOtherNames` replaced. - /// - param newChild: The new `unexpectedAfterOtherNames` to replace the node's - /// current `unexpectedAfterOtherNames`, if present. - public func withUnexpectedAfterOtherNames(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenInitializerAndAccessor` replaced. + /// - param newChild: The new `unexpectedBetweenInitializerAndAccessor` to replace the node's + /// current `unexpectedBetweenInitializerAndAccessor`, if present. + public func withUnexpectedBetweenInitializerAndAccessor(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return PatternBindingSyntax(newData) + } + + public var accessor: Accessor? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return Accessor(childData!) + } + set(value) { + self = withAccessor(value) + } + } + + /// Returns a copy of the receiver with its `accessor` replaced. + /// - param newChild: The new `accessor` to replace the node's + /// current `accessor`, if present. + public func withAccessor(_ newChild: Accessor?) -> PatternBindingSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return PatternBindingSyntax(newData) + } + + public var unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenAccessorAndTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenAccessorAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenAccessorAndTrailingComma` to replace the node's + /// current `unexpectedBetweenAccessorAndTrailingComma`, if present. + public func withUnexpectedBetweenAccessorAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return PatternBindingSyntax(newData) + } + + public var trailingComma: TokenSyntax? { + get { + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> PatternBindingSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return PatternBindingSyntax(newData) + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 10, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PatternBindingSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return PatternBindingSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeHigherThanOrLowerThan, - \Self.higherThanOrLowerThan, - \Self.unexpectedBetweenHigherThanOrLowerThanAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndOtherNames, - \Self.otherNames, - \Self.unexpectedAfterOtherNames, + \Self.unexpectedBeforePattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedBetweenInitializerAndAccessor, + \Self.accessor, + \Self.unexpectedBetweenAccessorAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -11187,187 +11125,308 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "type annotation" 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 PrecedenceGroupRelationSyntax: CustomReflectable { +extension PatternBindingSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeHigherThanOrLowerThan": unexpectedBeforeHigherThanOrLowerThan.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "higherThanOrLowerThan": Syntax(higherThanOrLowerThan).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenHigherThanOrLowerThanAndColon": unexpectedBetweenHigherThanOrLowerThanAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndOtherNames": unexpectedBetweenColonAndOtherNames.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "otherNames": Syntax(otherNames).asProtocol(SyntaxProtocol.self), - "unexpectedAfterOtherNames": unexpectedAfterOtherNames.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "initializer": initializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenInitializerAndAccessor": unexpectedBetweenInitializerAndAccessor.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "accessor": accessor.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenAccessorAndTrailingComma": unexpectedBetweenAccessorAndTrailingComma.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: - PrecedenceGroupNameElementSyntax +// MARK: - EnumCaseElementSyntax -public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// 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 == .precedenceGroupNameElement else { return nil } + guard node.raw.kind == .enumCaseElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupNameElementSyntax` 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) { - assert(data.raw.kind == .precedenceGroupNameElement) + assert(data.raw.kind == .enumCaseElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? = nil, + associatedValue: ParameterClauseSyntax? = 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(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndAssociatedValue, associatedValue, unexpectedBetweenAssociatedValueAndRawValue, rawValue, unexpectedBetweenRawValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.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.precedenceGroupNameElement, from: layout, arena: arena, + kind: SyntaxKind.enumCaseElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeName(value) + self = withUnexpectedBeforeIdentifier(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. - /// - param newChild: The new `unexpectedBeforeName` to replace the node's - /// current `unexpectedBeforeName`, if present. - public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupNameElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeIdentifier` replaced. + /// - param newChild: The new `unexpectedBeforeIdentifier` to replace the node's + /// current `unexpectedBeforeIdentifier`, if present. + public func withUnexpectedBeforeIdentifier(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PrecedenceGroupNameElementSyntax(newData) + return EnumCaseElementSyntax(newData) } - public var name: TokenSyntax { + /// The name of this case. + public var identifier: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withIdentifier(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax) -> PrecedenceGroupNameElementSyntax { + /// Returns a copy of the receiver with its `identifier` replaced. + /// - param newChild: The new `identifier` to replace the node's + /// current `identifier`, if present. + public func withIdentifier(_ newChild: TokenSyntax) -> EnumCaseElementSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupNameElementSyntax(newData) + return EnumCaseElementSyntax(newData) } - public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndTrailingComma(value) + self = withUnexpectedBetweenIdentifierAndAssociatedValue(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndTrailingComma` to replace the node's - /// current `unexpectedBetweenNameAndTrailingComma`, if present. - public func withUnexpectedBetweenNameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupNameElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenIdentifierAndAssociatedValue` replaced. + /// - param newChild: The new `unexpectedBetweenIdentifierAndAssociatedValue` to replace the node's + /// current `unexpectedBetweenIdentifierAndAssociatedValue`, if present. + public func withUnexpectedBetweenIdentifierAndAssociatedValue(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PrecedenceGroupNameElementSyntax(newData) + return EnumCaseElementSyntax(newData) } - public var trailingComma: TokenSyntax? { + /// The set of associated values of the case. + public var associatedValue: ParameterClauseSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return TokenSyntax(childData!) + return ParameterClauseSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withAssociatedValue(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> PrecedenceGroupNameElementSyntax { + /// Returns a copy of the receiver with its `associatedValue` replaced. + /// - param newChild: The new `associatedValue` to replace the node's + /// current `associatedValue`, if present. + public func withAssociatedValue(_ newChild: ParameterClauseSyntax?) -> EnumCaseElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupNameElementSyntax(newData) + return EnumCaseElementSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenAssociatedValueAndRawValue(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupNameElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAssociatedValueAndRawValue` replaced. + /// - param newChild: The new `unexpectedBetweenAssociatedValueAndRawValue` to replace the node's + /// current `unexpectedBetweenAssociatedValueAndRawValue`, if present. + public func withUnexpectedBetweenAssociatedValueAndRawValue(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PrecedenceGroupNameElementSyntax(newData) + return EnumCaseElementSyntax(newData) + } + + /// + /// The raw value of this enum element, if present. + /// + public var rawValue: InitializerClauseSyntax? { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } + return InitializerClauseSyntax(childData!) + } + set(value) { + self = withRawValue(value) + } + } + + /// Returns a copy of the receiver with its `rawValue` replaced. + /// - param newChild: The new `rawValue` to replace the node's + /// current `rawValue`, if present. + public func withRawValue(_ newChild: InitializerClauseSyntax?) -> EnumCaseElementSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return EnumCaseElementSyntax(newData) + } + + public var unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenRawValueAndTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenRawValueAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenRawValueAndTrailingComma` to replace the node's + /// current `unexpectedBetweenRawValueAndTrailingComma`, if present. + public func withUnexpectedBetweenRawValueAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return EnumCaseElementSyntax(newData) + } + + /// + /// The trailing comma of this element, if the case has + /// multiple elements. + /// + public var trailingComma: TokenSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> EnumCaseElementSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return EnumCaseElementSyntax(newData) + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> EnumCaseElementSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return EnumCaseElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndTrailingComma, + \Self.unexpectedBeforeIdentifier, + \Self.identifier, + \Self.unexpectedBetweenIdentifierAndAssociatedValue, + \Self.associatedValue, + \Self.unexpectedBetweenAssociatedValueAndRawValue, + \Self.rawValue, + \Self.unexpectedBetweenRawValueAndTrailingComma, \Self.trailingComma, \Self.unexpectedAfterTrailingComma, ]) @@ -11378,244 +11437,198 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: - return nil + return "associated values" case 4: return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension PrecedenceGroupNameElementSyntax: CustomReflectable { +extension EnumCaseElementSyntax: 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), - "unexpectedBetweenNameAndTrailingComma": unexpectedBetweenNameAndTrailingComma.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: - PrecedenceGroupAssignmentSyntax +// MARK: - DesignatedTypeElementSyntax -/// -/// Specifies the precedence of an operator when used in an operation -/// that includes optional chaining. -/// -public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { +public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssignment else { return nil } + guard node.raw.kind == .designatedTypeElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupAssignmentSyntax` 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) { - assert(data.raw.kind == .precedenceGroupAssignment) + assert(data.raw.kind == .designatedTypeElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? = nil, - assignmentKeyword: TokenSyntax = .identifier("assignment"), - _ unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, - flag: TokenSyntax, - _ unexpectedAfterFlag: 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(), (unexpectedBeforeAssignmentKeyword, assignmentKeyword, unexpectedBetweenAssignmentKeywordAndColon, colon, unexpectedBetweenColonAndFlag, flag, unexpectedAfterFlag))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeadingComma, leadingComma, unexpectedBetweenLeadingCommaAndName, name, unexpectedAfterName))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAssignmentKeyword?.raw, - assignmentKeyword.raw, - unexpectedBetweenAssignmentKeywordAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndFlag?.raw, - flag.raw, - unexpectedAfterFlag?.raw, + unexpectedBeforeLeadingComma?.raw, + leadingComma.raw, + unexpectedBetweenLeadingCommaAndName?.raw, + name.raw, + unexpectedAfterName?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssignment, from: layout, arena: arena, + kind: SyntaxKind.designatedTypeElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeAssignmentKeyword(value) + self = withUnexpectedBeforeLeadingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeAssignmentKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeAssignmentKeyword` to replace the node's - /// current `unexpectedBeforeAssignmentKeyword`, if present. - public func withUnexpectedBeforeAssignmentKeyword(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeadingComma` replaced. + /// - param newChild: The new `unexpectedBeforeLeadingComma` to replace the node's + /// current `unexpectedBeforeLeadingComma`, if present. + public func withUnexpectedBeforeLeadingComma(_ newChild: UnexpectedNodesSyntax?) -> DesignatedTypeElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var assignmentKeyword: TokenSyntax { + public var leadingComma: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withAssignmentKeyword(value) + self = withLeadingComma(value) } } - /// Returns a copy of the receiver with its `assignmentKeyword` replaced. - /// - param newChild: The new `assignmentKeyword` to replace the node's - /// current `assignmentKeyword`, if present. - public func withAssignmentKeyword(_ newChild: TokenSyntax) -> PrecedenceGroupAssignmentSyntax { + /// Returns a copy of the receiver with its `leadingComma` replaced. + /// - param newChild: The new `leadingComma` to replace the node's + /// current `leadingComma`, if present. + public func withLeadingComma(_ newChild: TokenSyntax) -> DesignatedTypeElementSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAssignmentKeywordAndColon(value) + self = withUnexpectedBetweenLeadingCommaAndName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAssignmentKeywordAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenAssignmentKeywordAndColon` to replace the node's - /// current `unexpectedBetweenAssignmentKeywordAndColon`, if present. - public func withUnexpectedBetweenAssignmentKeywordAndColon(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeadingCommaAndName` replaced. + /// - param newChild: The new `unexpectedBetweenLeadingCommaAndName` to replace the node's + /// current `unexpectedBetweenLeadingCommaAndName`, if present. + public func withUnexpectedBetweenLeadingCommaAndName(_ newChild: UnexpectedNodesSyntax?) -> DesignatedTypeElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var colon: TokenSyntax { + public var name: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> PrecedenceGroupAssignmentSyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax) -> DesignatedTypeElementSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? { + public var unexpectedAfterName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndFlag(value) + self = withUnexpectedAfterName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndFlag` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndFlag` to replace the node's - /// current `unexpectedBetweenColonAndFlag`, if present. - public func withUnexpectedBetweenColonAndFlag(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterName` replaced. + /// - param newChild: The new `unexpectedAfterName` to replace the node's + /// current `unexpectedAfterName`, if present. + public func withUnexpectedAfterName(_ newChild: UnexpectedNodesSyntax?) -> DesignatedTypeElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) - } - - /// - /// When true, an operator in the corresponding precedence group - /// uses the same grouping rules during optional chaining as the - /// assignment operators from the standard library. Otherwise, - /// operators in the precedence group follows the same optional - /// chaining rules as operators that don't perform assignment. - /// - public var flag: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withFlag(value) - } - } - - /// Returns a copy of the receiver with its `flag` replaced. - /// - param newChild: The new `flag` to replace the node's - /// current `flag`, if present. - public func withFlag(_ newChild: TokenSyntax) -> PrecedenceGroupAssignmentSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) - } - - public var unexpectedAfterFlag: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterFlag(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterFlag` replaced. - /// - param newChild: The new `unexpectedAfterFlag` to replace the node's - /// current `unexpectedAfterFlag`, if present. - public func withUnexpectedAfterFlag(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) + return DesignatedTypeElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAssignmentKeyword, - \Self.assignmentKeyword, - \Self.unexpectedBetweenAssignmentKeywordAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndFlag, - \Self.flag, - \Self.unexpectedAfterFlag, + \Self.unexpectedBeforeLeadingComma, + \Self.leadingComma, + \Self.unexpectedBetweenLeadingCommaAndName, + \Self.name, + \Self.unexpectedAfterName, ]) } @@ -11631,242 +11644,254 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension PrecedenceGroupAssignmentSyntax: CustomReflectable { +extension DesignatedTypeElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAssignmentKeyword": unexpectedBeforeAssignmentKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "assignmentKeyword": Syntax(assignmentKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAssignmentKeywordAndColon": unexpectedBetweenAssignmentKeywordAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndFlag": unexpectedBetweenColonAndFlag.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "flag": Syntax(flag).asProtocol(SyntaxProtocol.self), - "unexpectedAfterFlag": unexpectedAfterFlag.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: - PrecedenceGroupAssociativitySyntax +// MARK: - OperatorPrecedenceAndTypesSyntax /// -/// Specifies how a sequence of operators with the same precedence level -/// are grouped together in the absence of grouping parentheses. +/// A clause to specify precedence group in infix operator declarations, and designated types in any operator declaration. /// -public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable { +public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssociativity else { return nil } + guard node.raw.kind == .operatorPrecedenceAndTypes else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupAssociativitySyntax` node from the given `SyntaxData`. This assumes + /// Creates a `OperatorPrecedenceAndTypesSyntax` 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) { - assert(data.raw.kind == .precedenceGroupAssociativity) + assert(data.raw.kind == .operatorPrecedenceAndTypes) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? = nil, - associativityKeyword: TokenSyntax = .identifier("associativity"), - _ unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, + precedenceGroup: TokenSyntax, + _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, + designatedTypes: DesignatedTypeListSyntax, + _ unexpectedAfterDesignatedTypes: 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(), (unexpectedBeforeAssociativityKeyword, associativityKeyword, unexpectedBetweenAssociativityKeywordAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedAfterValue))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndPrecedenceGroup, precedenceGroup, unexpectedBetweenPrecedenceGroupAndDesignatedTypes, designatedTypes, unexpectedAfterDesignatedTypes))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAssociativityKeyword?.raw, - associativityKeyword.raw, - unexpectedBetweenAssociativityKeywordAndColon?.raw, + unexpectedBeforeColon?.raw, colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, + unexpectedBetweenColonAndPrecedenceGroup?.raw, + precedenceGroup.raw, + unexpectedBetweenPrecedenceGroupAndDesignatedTypes?.raw, + designatedTypes.raw, + unexpectedAfterDesignatedTypes?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssociativity, from: layout, arena: arena, + kind: SyntaxKind.operatorPrecedenceAndTypes, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeAssociativityKeyword(value) + self = withUnexpectedBeforeColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeAssociativityKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeAssociativityKeyword` to replace the node's - /// current `unexpectedBeforeAssociativityKeyword`, if present. - public func withUnexpectedBeforeAssociativityKeyword(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeColon` replaced. + /// - param newChild: The new `unexpectedBeforeColon` to replace the node's + /// current `unexpectedBeforeColon`, if present. + public func withUnexpectedBeforeColon(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var associativityKeyword: TokenSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withAssociativityKeyword(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `associativityKeyword` replaced. - /// - param newChild: The new `associativityKeyword` to replace the node's - /// current `associativityKeyword`, if present. - public func withAssociativityKeyword(_ newChild: TokenSyntax) -> PrecedenceGroupAssociativitySyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> OperatorPrecedenceAndTypesSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAssociativityKeywordAndColon(value) + self = withUnexpectedBetweenColonAndPrecedenceGroup(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAssociativityKeywordAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenAssociativityKeywordAndColon` to replace the node's - /// current `unexpectedBetweenAssociativityKeywordAndColon`, if present. - public func withUnexpectedBetweenAssociativityKeywordAndColon(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndPrecedenceGroup` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndPrecedenceGroup` to replace the node's + /// current `unexpectedBetweenColonAndPrecedenceGroup`, if present. + public func withUnexpectedBetweenColonAndPrecedenceGroup(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var colon: TokenSyntax { + /// + /// The precedence group for this operator + /// + public var precedenceGroup: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withPrecedenceGroup(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> PrecedenceGroupAssociativitySyntax { + /// Returns a copy of the receiver with its `precedenceGroup` replaced. + /// - param newChild: The new `precedenceGroup` to replace the node's + /// current `precedenceGroup`, if present. + public func withPrecedenceGroup(_ newChild: TokenSyntax) -> OperatorPrecedenceAndTypesSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndValue(value) + self = withUnexpectedBetweenPrecedenceGroupAndDesignatedTypes(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndValue` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndValue` to replace the node's - /// current `unexpectedBetweenColonAndValue`, if present. - public func withUnexpectedBetweenColonAndValue(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPrecedenceGroupAndDesignatedTypes` replaced. + /// - param newChild: The new `unexpectedBetweenPrecedenceGroupAndDesignatedTypes` to replace the node's + /// current `unexpectedBetweenPrecedenceGroupAndDesignatedTypes`, if present. + public func withUnexpectedBetweenPrecedenceGroupAndDesignatedTypes(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } /// - /// Operators that are `left`-associative group left-to-right. - /// Operators that are `right`-associative group right-to-left. - /// Operators that are specified with an associativity of `none` - /// don't associate at all + /// The designated types associated with this operator. /// - public var value: TokenSyntax { + public var designatedTypes: DesignatedTypeListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + return DesignatedTypeListSyntax(childData!) } set(value) { - self = withValue(value) + self = withDesignatedTypes(value) } } - /// Returns a copy of the receiver with its `value` replaced. - /// - param newChild: The new `value` to replace the node's - /// current `value`, if present. - public func withValue(_ newChild: TokenSyntax) -> PrecedenceGroupAssociativitySyntax { + /// Adds the provided `DesignatedTypeElement` to the node's `designatedTypes` + /// collection. + /// - param element: The new `DesignatedTypeElement` to add to the node's + /// `designatedTypes` collection. + /// - returns: A copy of the receiver with the provided `DesignatedTypeElement` + /// appended to its `designatedTypes` collection. + public func addDesignatedTypeElement(_ element: DesignatedTypeElementSyntax) -> OperatorPrecedenceAndTypesSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.designatedTypeList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return OperatorPrecedenceAndTypesSyntax(newData) + } + + /// Returns a copy of the receiver with its `designatedTypes` replaced. + /// - param newChild: The new `designatedTypes` to replace the node's + /// current `designatedTypes`, if present. + public func withDesignatedTypes(_ newChild: DesignatedTypeListSyntax) -> OperatorPrecedenceAndTypesSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var unexpectedAfterValue: UnexpectedNodesSyntax? { + public var unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterValue(value) + self = withUnexpectedAfterDesignatedTypes(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterValue` replaced. - /// - param newChild: The new `unexpectedAfterValue` to replace the node's - /// current `unexpectedAfterValue`, if present. - public func withUnexpectedAfterValue(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { + /// Returns a copy of the receiver with its `unexpectedAfterDesignatedTypes` replaced. + /// - param newChild: The new `unexpectedAfterDesignatedTypes` to replace the node's + /// current `unexpectedAfterDesignatedTypes`, if present. + public func withUnexpectedAfterDesignatedTypes(_ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAssociativityKeyword, - \Self.associativityKeyword, - \Self.unexpectedBetweenAssociativityKeywordAndColon, + \Self.unexpectedBeforeColon, \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedAfterValue, + \Self.unexpectedBetweenColonAndPrecedenceGroup, + \Self.precedenceGroup, + \Self.unexpectedBetweenPrecedenceGroupAndDesignatedTypes, + \Self.designatedTypes, + \Self.unexpectedAfterDesignatedTypes, ]) } @@ -11879,7 +11904,7 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable case 2: return nil case 3: - return nil + return "precedence group" case 4: return nil case 5: @@ -11892,541 +11917,252 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable } } -extension PrecedenceGroupAssociativitySyntax: CustomReflectable { +extension OperatorPrecedenceAndTypesSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAssociativityKeyword": unexpectedBeforeAssociativityKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "associativityKeyword": Syntax(associativityKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAssociativityKeywordAndColon": unexpectedBetweenAssociativityKeywordAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeColon": unexpectedBeforeColon.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), - "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenColonAndPrecedenceGroup": unexpectedBetweenColonAndPrecedenceGroup.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "precedenceGroup": Syntax(precedenceGroup).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPrecedenceGroupAndDesignatedTypes": unexpectedBetweenPrecedenceGroupAndDesignatedTypes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "designatedTypes": Syntax(designatedTypes).asProtocol(SyntaxProtocol.self), + "unexpectedAfterDesignatedTypes": unexpectedAfterDesignatedTypes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - AttributeSyntax +// MARK: - PrecedenceGroupRelationSyntax /// -/// An `@` attribute. +/// Specify the new precedence group's relation to existing precedence +/// groups. /// -public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { - public enum Argument: SyntaxChildChoices { - case `argumentList`(TupleExprElementListSyntax) - case `token`(TokenSyntax) - case `availability`(AvailabilitySpecListSyntax) - case `specializeArguments`(SpecializeAttributeSpecListSyntax) - case `objCName`(ObjCSelectorSyntax) - case `implementsArguments`(ImplementsAttributeArgumentsSyntax) - case `differentiableArguments`(DifferentiableAttributeArgumentsSyntax) - case `derivativeRegistrationArguments`(DerivativeRegistrationAttributeArgumentsSyntax) - case `backDeployArguments`(BackDeployAttributeSpecListSyntax) - case `conventionArguments`(ConventionAttributeArgumentsSyntax) - case `conventionWitnessMethodArguments`(ConventionWitnessMethodAttributeArgumentsSyntax) - case `opaqueReturnTypeOfAttributeArguments`(OpaqueReturnTypeOfAttributeArgumentsSyntax) - case `exposeAttributeArguments`(ExposeAttributeArgumentsSyntax) - case `originallyDefinedInArguments`(OriginallyDefinedInArgumentsSyntax) - case `underscorePrivateAttributeArguments`(UnderscorePrivateAttributeArgumentsSyntax) - case `dynamicReplacementArguments`(DynamicReplacementArgumentsSyntax) - case `unavailableFromAsyncArguments`(UnavailableFromAsyncArgumentsSyntax) - case `effectsArguments`(EffectsArgumentsSyntax) - case `documentationArguments`(DocumentationAttributeArgumentsSyntax) - public var _syntaxNode: Syntax { - switch self { - case .argumentList(let node): return node._syntaxNode - case .token(let node): return node._syntaxNode - case .availability(let node): return node._syntaxNode - case .specializeArguments(let node): return node._syntaxNode - case .objCName(let node): return node._syntaxNode - case .implementsArguments(let node): return node._syntaxNode - case .differentiableArguments(let node): return node._syntaxNode - case .derivativeRegistrationArguments(let node): return node._syntaxNode - case .backDeployArguments(let node): return node._syntaxNode - case .conventionArguments(let node): return node._syntaxNode - case .conventionWitnessMethodArguments(let node): return node._syntaxNode - case .opaqueReturnTypeOfAttributeArguments(let node): return node._syntaxNode - case .exposeAttributeArguments(let node): return node._syntaxNode - case .originallyDefinedInArguments(let node): return node._syntaxNode - case .underscorePrivateAttributeArguments(let node): return node._syntaxNode - case .dynamicReplacementArguments(let node): return node._syntaxNode - case .unavailableFromAsyncArguments(let node): return node._syntaxNode - case .effectsArguments(let node): return node._syntaxNode - case .documentationArguments(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: TupleExprElementListSyntax) { - self = .argumentList(node) - } - public init(_ node: TokenSyntax) { - self = .token(node) - } - public init(_ node: AvailabilitySpecListSyntax) { - self = .availability(node) - } - public init(_ node: SpecializeAttributeSpecListSyntax) { - self = .specializeArguments(node) - } - public init(_ node: ObjCSelectorSyntax) { - self = .objCName(node) - } - public init(_ node: ImplementsAttributeArgumentsSyntax) { - self = .implementsArguments(node) - } - public init(_ node: DifferentiableAttributeArgumentsSyntax) { - self = .differentiableArguments(node) - } - public init(_ node: DerivativeRegistrationAttributeArgumentsSyntax) { - self = .derivativeRegistrationArguments(node) - } - public init(_ node: BackDeployAttributeSpecListSyntax) { - self = .backDeployArguments(node) - } - public init(_ node: ConventionAttributeArgumentsSyntax) { - self = .conventionArguments(node) - } - public init(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) { - self = .conventionWitnessMethodArguments(node) - } - public init(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) { - self = .opaqueReturnTypeOfAttributeArguments(node) - } - public init(_ node: ExposeAttributeArgumentsSyntax) { - self = .exposeAttributeArguments(node) - } - public init(_ node: OriginallyDefinedInArgumentsSyntax) { - self = .originallyDefinedInArguments(node) - } - public init(_ node: UnderscorePrivateAttributeArgumentsSyntax) { - self = .underscorePrivateAttributeArguments(node) - } - public init(_ node: DynamicReplacementArgumentsSyntax) { - self = .dynamicReplacementArguments(node) - } - public init(_ node: UnavailableFromAsyncArgumentsSyntax) { - self = .unavailableFromAsyncArguments(node) - } - public init(_ node: EffectsArgumentsSyntax) { - self = .effectsArguments(node) - } - public init(_ node: DocumentationAttributeArgumentsSyntax) { - self = .documentationArguments(node) - } - public init?(_ node: S) { - if let node = node.as(TupleExprElementListSyntax.self) { - self = .argumentList(node) - return - } - if let node = node.as(TokenSyntax.self) { - self = .token(node) - return - } - if let node = node.as(AvailabilitySpecListSyntax.self) { - self = .availability(node) - return - } - if let node = node.as(SpecializeAttributeSpecListSyntax.self) { - self = .specializeArguments(node) - return - } - if let node = node.as(ObjCSelectorSyntax.self) { - self = .objCName(node) - return - } - if let node = node.as(ImplementsAttributeArgumentsSyntax.self) { - self = .implementsArguments(node) - return - } - if let node = node.as(DifferentiableAttributeArgumentsSyntax.self) { - self = .differentiableArguments(node) - return - } - if let node = node.as(DerivativeRegistrationAttributeArgumentsSyntax.self) { - self = .derivativeRegistrationArguments(node) - return - } - if let node = node.as(BackDeployAttributeSpecListSyntax.self) { - self = .backDeployArguments(node) - return - } - if let node = node.as(ConventionAttributeArgumentsSyntax.self) { - self = .conventionArguments(node) - return - } - if let node = node.as(ConventionWitnessMethodAttributeArgumentsSyntax.self) { - self = .conventionWitnessMethodArguments(node) - return - } - if let node = node.as(OpaqueReturnTypeOfAttributeArgumentsSyntax.self) { - self = .opaqueReturnTypeOfAttributeArguments(node) - return - } - if let node = node.as(ExposeAttributeArgumentsSyntax.self) { - self = .exposeAttributeArguments(node) - return - } - if let node = node.as(OriginallyDefinedInArgumentsSyntax.self) { - self = .originallyDefinedInArguments(node) - return - } - if let node = node.as(UnderscorePrivateAttributeArgumentsSyntax.self) { - self = .underscorePrivateAttributeArguments(node) - return - } - if let node = node.as(DynamicReplacementArgumentsSyntax.self) { - self = .dynamicReplacementArguments(node) - return - } - if let node = node.as(UnavailableFromAsyncArgumentsSyntax.self) { - self = .unavailableFromAsyncArguments(node) - return - } - if let node = node.as(EffectsArgumentsSyntax.self) { - self = .effectsArguments(node) - return - } - if let node = node.as(DocumentationAttributeArgumentsSyntax.self) { - self = .documentationArguments(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(TupleExprElementListSyntax.self), - .node(TokenSyntax.self), - .node(AvailabilitySpecListSyntax.self), - .node(SpecializeAttributeSpecListSyntax.self), - .node(ObjCSelectorSyntax.self), - .node(ImplementsAttributeArgumentsSyntax.self), - .node(DifferentiableAttributeArgumentsSyntax.self), - .node(DerivativeRegistrationAttributeArgumentsSyntax.self), - .node(BackDeployAttributeSpecListSyntax.self), - .node(ConventionAttributeArgumentsSyntax.self), - .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), - .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), - .node(ExposeAttributeArgumentsSyntax.self), - .node(OriginallyDefinedInArgumentsSyntax.self), - .node(UnderscorePrivateAttributeArgumentsSyntax.self), - .node(DynamicReplacementArgumentsSyntax.self), - .node(UnavailableFromAsyncArgumentsSyntax.self), - .node(EffectsArgumentsSyntax.self), - .node(DocumentationAttributeArgumentsSyntax.self), - ]) - } - } - +public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .attribute else { return nil } + guard node.raw.kind == .precedenceGroupRelation else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AttributeSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `PrecedenceGroupRelationSyntax` 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) { - assert(data.raw.kind == .attribute) + assert(data.raw.kind == .precedenceGroupRelation) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, - atSignToken: TokenSyntax = .atSignToken(), - _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, - attributeName: A, - _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, - argument: Argument? = nil, - _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? = nil, + higherThanOrLowerThan: TokenSyntax, + _ unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? = nil, + otherNames: PrecedenceGroupNameListSyntax, + _ unexpectedAfterOtherNames: 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(), (unexpectedBeforeAtSignToken, atSignToken, unexpectedBetweenAtSignTokenAndAttributeName, attributeName, unexpectedBetweenAttributeNameAndLeftParen, leftParen, unexpectedBetweenLeftParenAndArgument, argument, unexpectedBetweenArgumentAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeHigherThanOrLowerThan, higherThanOrLowerThan, unexpectedBetweenHigherThanOrLowerThanAndColon, colon, unexpectedBetweenColonAndOtherNames, otherNames, unexpectedAfterOtherNames))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAtSignToken?.raw, - atSignToken.raw, - unexpectedBetweenAtSignTokenAndAttributeName?.raw, - attributeName.raw, - unexpectedBetweenAttributeNameAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArgument?.raw, - argument?.raw, - unexpectedBetweenArgumentAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeHigherThanOrLowerThan?.raw, + higherThanOrLowerThan.raw, + unexpectedBetweenHigherThanOrLowerThanAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndOtherNames?.raw, + otherNames.raw, + unexpectedAfterOtherNames?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.attribute, from: layout, arena: arena, + kind: SyntaxKind.precedenceGroupRelation, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? { + public var unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeAtSignToken(value) + self = withUnexpectedBeforeHigherThanOrLowerThan(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeAtSignToken` replaced. - /// - param newChild: The new `unexpectedBeforeAtSignToken` to replace the node's - /// current `unexpectedBeforeAtSignToken`, if present. - public func withUnexpectedBeforeAtSignToken(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeHigherThanOrLowerThan` replaced. + /// - param newChild: The new `unexpectedBeforeHigherThanOrLowerThan` to replace the node's + /// current `unexpectedBeforeHigherThanOrLowerThan`, if present. + public func withUnexpectedBeforeHigherThanOrLowerThan(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AttributeSyntax(newData) + return PrecedenceGroupRelationSyntax(newData) } - /// The `@` sign. - public var atSignToken: TokenSyntax { + /// + /// The relation to specified other precedence groups. + /// + public var higherThanOrLowerThan: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withAtSignToken(value) + self = withHigherThanOrLowerThan(value) } } - /// Returns a copy of the receiver with its `atSignToken` replaced. - /// - param newChild: The new `atSignToken` to replace the node's - /// current `atSignToken`, if present. - public func withAtSignToken(_ newChild: TokenSyntax) -> AttributeSyntax { + /// Returns a copy of the receiver with its `higherThanOrLowerThan` replaced. + /// - param newChild: The new `higherThanOrLowerThan` to replace the node's + /// current `higherThanOrLowerThan`, if present. + public func withHigherThanOrLowerThan(_ newChild: TokenSyntax) -> PrecedenceGroupRelationSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AttributeSyntax(newData) + return PrecedenceGroupRelationSyntax(newData) } - public var unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? { + public var unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAtSignTokenAndAttributeName(value) + self = withUnexpectedBetweenHigherThanOrLowerThanAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAtSignTokenAndAttributeName` replaced. - /// - param newChild: The new `unexpectedBetweenAtSignTokenAndAttributeName` to replace the node's - /// current `unexpectedBetweenAtSignTokenAndAttributeName`, if present. - public func withUnexpectedBetweenAtSignTokenAndAttributeName(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenHigherThanOrLowerThanAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenHigherThanOrLowerThanAndColon` to replace the node's + /// current `unexpectedBetweenHigherThanOrLowerThanAndColon`, if present. + public func withUnexpectedBetweenHigherThanOrLowerThanAndColon(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AttributeSyntax(newData) + return PrecedenceGroupRelationSyntax(newData) } - /// The name of the attribute. - public var attributeName: TypeSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TypeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withAttributeName(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `attributeName` replaced. - /// - param newChild: The new `attributeName` to replace the node's - /// current `attributeName`, if present. - public func withAttributeName(_ newChild: TypeSyntax) -> AttributeSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> PrecedenceGroupRelationSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AttributeSyntax(newData) + return PrecedenceGroupRelationSyntax(newData) } - public var unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAttributeNameAndLeftParen(value) + self = withUnexpectedBetweenColonAndOtherNames(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAttributeNameAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenAttributeNameAndLeftParen` to replace the node's - /// current `unexpectedBetweenAttributeNameAndLeftParen`, if present. - public func withUnexpectedBetweenAttributeNameAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndOtherNames` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndOtherNames` to replace the node's + /// current `unexpectedBetweenColonAndOtherNames`, if present. + public func withUnexpectedBetweenColonAndOtherNames(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AttributeSyntax(newData) + return PrecedenceGroupRelationSyntax(newData) } /// - /// If the attribute takes arguments, the opening parenthesis. + /// The name of other precedence group to which this precedence + /// group relates. /// - public var leftParen: TokenSyntax? { + public var otherNames: PrecedenceGroupNameListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withLeftParen(value) - } - } - - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax?) -> AttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AttributeSyntax(newData) - } - - public var unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLeftParenAndArgument(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndArgument` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndArgument` to replace the node's - /// current `unexpectedBetweenLeftParenAndArgument`, if present. - public func withUnexpectedBetweenLeftParenAndArgument(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return AttributeSyntax(newData) - } - - /// - /// The arguments of the attribute. In case the attribute - /// takes multiple arguments, they are gather in the - /// appropriate takes first. - /// - public var argument: Argument? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return Argument(childData!) - } - set(value) { - self = withArgument(value) - } - } - - /// Returns a copy of the receiver with its `argument` replaced. - /// - param newChild: The new `argument` to replace the node's - /// current `argument`, if present. - public func withArgument(_ newChild: Argument?) -> AttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return AttributeSyntax(newData) - } - - public var unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) + return PrecedenceGroupNameListSyntax(childData!) } set(value) { - self = withUnexpectedBetweenArgumentAndRightParen(value) + self = withOtherNames(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenArgumentAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenArgumentAndRightParen` to replace the node's - /// current `unexpectedBetweenArgumentAndRightParen`, if present. - public func withUnexpectedBetweenArgumentAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + /// Adds the provided `OtherName` to the node's `otherNames` + /// collection. + /// - param element: The new `OtherName` to add to the node's + /// `otherNames` collection. + /// - returns: A copy of the receiver with the provided `OtherName` + /// appended to its `otherNames` collection. + public func addOtherName(_ element: PrecedenceGroupNameElementSyntax) -> PrecedenceGroupRelationSyntax { + var collection: RawSyntax let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return AttributeSyntax(newData) - } - - /// - /// If the attribute takes arguments, the closing parenthesis. - /// - public var rightParen: TokenSyntax? { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withRightParen(value) + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupNameList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return PrecedenceGroupRelationSyntax(newData) } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax?) -> AttributeSyntax { + /// Returns a copy of the receiver with its `otherNames` replaced. + /// - param newChild: The new `otherNames` to replace the node's + /// current `otherNames`, if present. + public func withOtherNames(_ newChild: PrecedenceGroupNameListSyntax) -> PrecedenceGroupRelationSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return AttributeSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return PrecedenceGroupRelationSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterOtherNames: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedAfterOtherNames(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterOtherNames` replaced. + /// - param newChild: The new `unexpectedAfterOtherNames` to replace the node's + /// current `unexpectedAfterOtherNames`, if present. + public func withUnexpectedAfterOtherNames(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupRelationSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return AttributeSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return PrecedenceGroupRelationSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAtSignToken, - \Self.atSignToken, - \Self.unexpectedBetweenAtSignTokenAndAttributeName, - \Self.attributeName, - \Self.unexpectedBetweenAttributeNameAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndArgument, - \Self.argument, - \Self.unexpectedBetweenArgumentAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeHigherThanOrLowerThan, + \Self.higherThanOrLowerThan, + \Self.unexpectedBetweenHigherThanOrLowerThanAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndOtherNames, + \Self.otherNames, + \Self.unexpectedAfterOtherNames, ]) } @@ -12439,318 +12175,189 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "name" + 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 AttributeSyntax: CustomReflectable { +extension PrecedenceGroupRelationSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAtSignToken": unexpectedBeforeAtSignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "atSignToken": Syntax(atSignToken).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAtSignTokenAndAttributeName": unexpectedBetweenAtSignTokenAndAttributeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "attributeName": Syntax(attributeName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAttributeNameAndLeftParen": unexpectedBetweenAttributeNameAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": leftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenLeftParenAndArgument": unexpectedBetweenLeftParenAndArgument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "argument": argument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenArgumentAndRightParen": unexpectedBetweenArgumentAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": rightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeHigherThanOrLowerThan": unexpectedBeforeHigherThanOrLowerThan.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "higherThanOrLowerThan": Syntax(higherThanOrLowerThan).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenHigherThanOrLowerThanAndColon": unexpectedBetweenHigherThanOrLowerThanAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndOtherNames": unexpectedBetweenColonAndOtherNames.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "otherNames": Syntax(otherNames).asProtocol(SyntaxProtocol.self), + "unexpectedAfterOtherNames": unexpectedAfterOtherNames.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - AvailabilityEntrySyntax +// MARK: - PrecedenceGroupNameElementSyntax -/// -/// The availability argument for the _specialize attribute -/// -public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityEntry else { return nil } + guard node.raw.kind == .precedenceGroupNameElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AvailabilityEntrySyntax` node from the given `SyntaxData`. This assumes + /// Creates a `PrecedenceGroupNameElementSyntax` 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) { - assert(data.raw.kind == .availabilityEntry) + assert(data.raw.kind == .precedenceGroupNameElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, - availabilityList: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax = .semicolonToken(), - _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: 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, unexpectedBetweenColonAndAvailabilityList, availabilityList, unexpectedBetweenAvailabilityListAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndAvailabilityList?.raw, - availabilityList.raw, - unexpectedBetweenAvailabilityListAndSemicolon?.raw, - semicolon.raw, - unexpectedAfterSemicolon?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityEntry, from: layout, arena: arena, + kind: SyntaxKind.precedenceGroupNameElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLabel(value) + self = withUnexpectedBeforeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. - /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's - /// current `unexpectedBeforeLabel`, if present. - public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. + /// - param newChild: The new `unexpectedBeforeName` to replace the node's + /// current `unexpectedBeforeName`, if present. + public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupNameElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) + return PrecedenceGroupNameElementSyntax(newData) } - /// The label of the argument - public var label: TokenSyntax { + public var name: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLabel(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `label` replaced. - /// - param newChild: The new `label` to replace the node's - /// current `label`, if present. - public func withLabel(_ newChild: TokenSyntax) -> AvailabilityEntrySyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax) -> PrecedenceGroupNameElementSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) + return PrecedenceGroupNameElementSyntax(newData) } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLabelAndColon(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's - /// current `unexpectedBetweenLabelAndColon`, if present. - public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) - } - - /// The colon separating the label and the value - public var colon: TokenSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withColon(value) - } - } - - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> AvailabilityEntrySyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) - } - - public var unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenColonAndAvailabilityList(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndAvailabilityList` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndAvailabilityList` to replace the node's - /// current `unexpectedBetweenColonAndAvailabilityList`, if present. - public func withUnexpectedBetweenColonAndAvailabilityList(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) - } - - public var availabilityList: AvailabilitySpecListSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return AvailabilitySpecListSyntax(childData!) - } - set(value) { - self = withAvailabilityList(value) - } - } - - /// Adds the provided `Availability` to the node's `availabilityList` - /// collection. - /// - param element: The new `Availability` to add to the node's - /// `availabilityList` collection. - /// - returns: A copy of the receiver with the provided `Availability` - /// appended to its `availabilityList` collection. - public func addAvailability(_ element: AvailabilityArgumentSyntax) -> AvailabilityEntrySyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[5] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return AvailabilityEntrySyntax(newData) - } - - /// Returns a copy of the receiver with its `availabilityList` replaced. - /// - param newChild: The new `availabilityList` to replace the node's - /// current `availabilityList`, if present. - public func withAvailabilityList(_ newChild: AvailabilitySpecListSyntax) -> AvailabilityEntrySyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) - } - - public var unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenAvailabilityListAndSemicolon(value) + self = withUnexpectedBetweenNameAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilityListAndSemicolon` replaced. - /// - param newChild: The new `unexpectedBetweenAvailabilityListAndSemicolon` to replace the node's - /// current `unexpectedBetweenAvailabilityListAndSemicolon`, if present. - public func withUnexpectedBetweenAvailabilityListAndSemicolon(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndTrailingComma` to replace the node's + /// current `unexpectedBetweenNameAndTrailingComma`, if present. + public func withUnexpectedBetweenNameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupNameElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(newData) } - public var semicolon: TokenSyntax { + public var trailingComma: TokenSyntax? { get { - let childData = data.child(at: 7, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withSemicolon(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `semicolon` replaced. - /// - param newChild: The new `semicolon` to replace the node's - /// current `semicolon`, if present. - public func withSemicolon(_ newChild: TokenSyntax) -> AvailabilityEntrySyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> PrecedenceGroupNameElementSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(newData) } - public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterSemicolon(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterSemicolon` replaced. - /// - param newChild: The new `unexpectedAfterSemicolon` to replace the node's - /// current `unexpectedAfterSemicolon`, if present. - public func withUnexpectedAfterSemicolon(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupNameElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndAvailabilityList, - \Self.availabilityList, - \Self.unexpectedBetweenAvailabilityListAndSemicolon, - \Self.semicolon, - \Self.unexpectedAfterSemicolon, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -12759,164 +12366,146 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "label" + return "name" 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 default: fatalError("Invalid index") } } } -extension AvailabilityEntrySyntax: CustomReflectable { +extension PrecedenceGroupNameElementSyntax: 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), - "unexpectedBetweenColonAndAvailabilityList": unexpectedBetweenColonAndAvailabilityList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "availabilityList": Syntax(availabilityList).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAvailabilityListAndSemicolon": unexpectedBetweenAvailabilityListAndSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "semicolon": Syntax(semicolon).asProtocol(SyntaxProtocol.self), - "unexpectedAfterSemicolon": unexpectedAfterSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenNameAndTrailingComma": unexpectedBetweenNameAndTrailingComma.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: - LabeledSpecializeEntrySyntax +// MARK: - PrecedenceGroupAssignmentSyntax /// -/// A labeled argument for the `@_specialize` attribute like -/// `exported: true` +/// Specifies the precedence of an operator when used in an operation +/// that includes optional chaining. /// -public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .labeledSpecializeEntry else { return nil } + guard node.raw.kind == .precedenceGroupAssignment else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `LabeledSpecializeEntrySyntax` node from the given `SyntaxData`. This assumes + /// Creates a `PrecedenceGroupAssignmentSyntax` 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) { - assert(data.raw.kind == .labeledSpecializeEntry) + assert(data.raw.kind == .precedenceGroupAssignment) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? = nil, + assignmentKeyword: TokenSyntax = .identifier("assignment"), + _ unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, + flag: TokenSyntax, + _ unexpectedAfterFlag: 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, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssignmentKeyword, assignmentKeyword, unexpectedBetweenAssignmentKeywordAndColon, colon, unexpectedBetweenColonAndFlag, flag, unexpectedAfterFlag))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, + unexpectedBeforeAssignmentKeyword?.raw, + assignmentKeyword.raw, + unexpectedBetweenAssignmentKeywordAndColon?.raw, colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBetweenColonAndFlag?.raw, + flag.raw, + unexpectedAfterFlag?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.labeledSpecializeEntry, from: layout, arena: arena, + kind: SyntaxKind.precedenceGroupAssignment, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLabel(value) + self = withUnexpectedBeforeAssignmentKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. - /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's - /// current `unexpectedBeforeLabel`, if present. - public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAssignmentKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeAssignmentKeyword` to replace the node's + /// current `unexpectedBeforeAssignmentKeyword`, if present. + public func withUnexpectedBeforeAssignmentKeyword(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssignmentSyntax(newData) } - /// The label of the argument - public var label: TokenSyntax { + public var assignmentKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLabel(value) + self = withAssignmentKeyword(value) } } - /// Returns a copy of the receiver with its `label` replaced. - /// - param newChild: The new `label` to replace the node's - /// current `label`, if present. - public func withLabel(_ newChild: TokenSyntax) -> LabeledSpecializeEntrySyntax { + /// Returns a copy of the receiver with its `assignmentKeyword` replaced. + /// - param newChild: The new `assignmentKeyword` to replace the node's + /// current `assignmentKeyword`, if present. + public func withAssignmentKeyword(_ newChild: TokenSyntax) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssignmentSyntax(newData) } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLabelAndColon(value) + self = withUnexpectedBetweenAssignmentKeywordAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's - /// current `unexpectedBetweenLabelAndColon`, if present. - public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAssignmentKeywordAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenAssignmentKeywordAndColon` to replace the node's + /// current `unexpectedBetweenAssignmentKeywordAndColon`, if present. + public func withUnexpectedBetweenAssignmentKeywordAndColon(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssignmentSyntax(newData) } - /// The colon separating the label and the value public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) @@ -12930,132 +12519,91 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `colon` replaced. /// - param newChild: The new `colon` to replace the node's /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> LabeledSpecializeEntrySyntax { + public func withColon(_ newChild: TokenSyntax) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssignmentSyntax(newData) } - public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndValue(value) + self = withUnexpectedBetweenColonAndFlag(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndValue` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndValue` to replace the node's - /// current `unexpectedBetweenColonAndValue`, if present. - public func withUnexpectedBetweenColonAndValue(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndFlag` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndFlag` to replace the node's + /// current `unexpectedBetweenColonAndFlag`, if present. + public func withUnexpectedBetweenColonAndFlag(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) - } - - /// The value for this argument - public var value: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withValue(value) - } - } - - /// Returns a copy of the receiver with its `value` replaced. - /// - param newChild: The new `value` to replace the node's - /// current `value`, if present. - public func withValue(_ newChild: TokenSyntax) -> LabeledSpecializeEntrySyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) - } - - public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenValueAndTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenValueAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenValueAndTrailingComma` to replace the node's - /// current `unexpectedBetweenValueAndTrailingComma`, if present. - public func withUnexpectedBetweenValueAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssignmentSyntax(newData) } /// - /// A trailing comma if this argument is followed by another one + /// When true, an operator in the corresponding precedence group + /// uses the same grouping rules during optional chaining as the + /// assignment operators from the standard library. Otherwise, + /// operators in the precedence group follows the same optional + /// chaining rules as operators that don't perform assignment. /// - public var trailingComma: TokenSyntax? { + public var flag: TokenSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withFlag(value) } - } - - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> LabeledSpecializeEntrySyntax { + } + + /// Returns a copy of the receiver with its `flag` replaced. + /// - param newChild: The new `flag` to replace the node's + /// current `flag`, if present. + public func withFlag(_ newChild: TokenSyntax) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return PrecedenceGroupAssignmentSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterFlag: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedAfterFlag(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedAfterFlag` replaced. + /// - param newChild: The new `unexpectedAfterFlag` to replace the node's + /// current `unexpectedAfterFlag`, if present. + public func withUnexpectedAfterFlag(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return PrecedenceGroupAssignmentSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, + \Self.unexpectedBeforeAssignmentKeyword, + \Self.assignmentKeyword, + \Self.unexpectedBetweenAssignmentKeywordAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedBetweenValueAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBetweenColonAndFlag, + \Self.flag, + \Self.unexpectedAfterFlag, ]) } @@ -13064,7 +12612,7 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -13072,12 +12620,8 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return "value" - case 6: return nil - case 7: - return nil - case 8: + case 6: return nil default: fatalError("Invalid index") @@ -13085,144 +12629,135 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { } } -extension LabeledSpecializeEntrySyntax: CustomReflectable { +extension PrecedenceGroupAssignmentSyntax: 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, + "unexpectedBeforeAssignmentKeyword": unexpectedBeforeAssignmentKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "assignmentKeyword": Syntax(assignmentKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAssignmentKeywordAndColon": unexpectedBetweenAssignmentKeywordAndColon.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, + "unexpectedBetweenColonAndFlag": unexpectedBetweenColonAndFlag.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "flag": Syntax(flag).asProtocol(SyntaxProtocol.self), + "unexpectedAfterFlag": unexpectedAfterFlag.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - TargetFunctionEntrySyntax +// MARK: - PrecedenceGroupAssociativitySyntax /// -/// A labeled argument for the `@_specialize` attribute with a function -/// decl value like -/// `target: myFunc(_:)` +/// Specifies how a sequence of operators with the same precedence level +/// are grouped together in the absence of grouping parentheses. /// -public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .targetFunctionEntry else { return nil } + guard node.raw.kind == .precedenceGroupAssociativity else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `TargetFunctionEntrySyntax` node from the given `SyntaxData`. This assumes + /// Creates a `PrecedenceGroupAssociativitySyntax` 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) { - assert(data.raw.kind == .targetFunctionEntry) + assert(data.raw.kind == .precedenceGroupAssociativity) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? = nil, + associativityKeyword: TokenSyntax = .identifier("associativity"), + _ unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, - declname: DeclNameSyntax, - _ unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ unexpectedAfterValue: 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, unexpectedBetweenColonAndDeclname, declname, unexpectedBetweenDeclnameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssociativityKeyword, associativityKeyword, unexpectedBetweenAssociativityKeywordAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedAfterValue))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, + unexpectedBeforeAssociativityKeyword?.raw, + associativityKeyword.raw, + unexpectedBetweenAssociativityKeywordAndColon?.raw, colon.raw, - unexpectedBetweenColonAndDeclname?.raw, - declname.raw, - unexpectedBetweenDeclnameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBetweenColonAndValue?.raw, + value.raw, + unexpectedAfterValue?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.targetFunctionEntry, from: layout, arena: arena, + kind: SyntaxKind.precedenceGroupAssociativity, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLabel(value) + self = withUnexpectedBeforeAssociativityKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. - /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's - /// current `unexpectedBeforeLabel`, if present. - public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAssociativityKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeAssociativityKeyword` to replace the node's + /// current `unexpectedBeforeAssociativityKeyword`, if present. + public func withUnexpectedBeforeAssociativityKeyword(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - /// The label of the argument - public var label: TokenSyntax { + public var associativityKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLabel(value) + self = withAssociativityKeyword(value) } } - /// Returns a copy of the receiver with its `label` replaced. - /// - param newChild: The new `label` to replace the node's - /// current `label`, if present. - public func withLabel(_ newChild: TokenSyntax) -> TargetFunctionEntrySyntax { + /// Returns a copy of the receiver with its `associativityKeyword` replaced. + /// - param newChild: The new `associativityKeyword` to replace the node's + /// current `associativityKeyword`, if present. + public func withAssociativityKeyword(_ newChild: TokenSyntax) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLabelAndColon(value) + self = withUnexpectedBetweenAssociativityKeywordAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's - /// current `unexpectedBetweenLabelAndColon`, if present. - public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAssociativityKeywordAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenAssociativityKeywordAndColon` to replace the node's + /// current `unexpectedBetweenAssociativityKeywordAndColon`, if present. + public func withUnexpectedBetweenAssociativityKeywordAndColon(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - /// The colon separating the label and the value public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) @@ -13236,132 +12771,90 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `colon` replaced. /// - param newChild: The new `colon` to replace the node's /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> TargetFunctionEntrySyntax { + public func withColon(_ newChild: TokenSyntax) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndDeclname(value) + self = withUnexpectedBetweenColonAndValue(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndDeclname` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndDeclname` to replace the node's - /// current `unexpectedBetweenColonAndDeclname`, if present. - public func withUnexpectedBetweenColonAndDeclname(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndValue` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndValue` to replace the node's + /// current `unexpectedBetweenColonAndValue`, if present. + public func withUnexpectedBetweenColonAndValue(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - /// The value for this argument - public var declname: DeclNameSyntax { + /// + /// Operators that are `left`-associative group left-to-right. + /// Operators that are `right`-associative group right-to-left. + /// Operators that are specified with an associativity of `none` + /// don't associate at all + /// + public var value: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return DeclNameSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDeclname(value) + self = withValue(value) } } - /// Returns a copy of the receiver with its `declname` replaced. - /// - param newChild: The new `declname` to replace the node's - /// current `declname`, if present. - public func withDeclname(_ newChild: DeclNameSyntax) -> TargetFunctionEntrySyntax { + /// Returns a copy of the receiver with its `value` replaced. + /// - param newChild: The new `value` to replace the node's + /// current `value`, if present. + public func withValue(_ newChild: TokenSyntax) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - public var unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDeclnameAndTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenDeclnameAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenDeclnameAndTrailingComma` to replace the node's - /// current `unexpectedBetweenDeclnameAndTrailingComma`, if present. - public func withUnexpectedBetweenDeclnameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) - } - - /// - /// A trailing comma if this argument is followed by another one - /// - public var trailingComma: TokenSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withTrailingComma(value) - } - } - - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> TargetFunctionEntrySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) - } - - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedAfterValue(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedAfterValue` replaced. + /// - param newChild: The new `unexpectedAfterValue` to replace the node's + /// current `unexpectedAfterValue`, if present. + public func withUnexpectedAfterValue(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return PrecedenceGroupAssociativitySyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, + \Self.unexpectedBeforeAssociativityKeyword, + \Self.associativityKeyword, + \Self.unexpectedBetweenAssociativityKeywordAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndDeclname, - \Self.declname, - \Self.unexpectedBetweenDeclnameAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedAfterValue, ]) } @@ -13370,7 +12863,7 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -13378,12 +12871,8 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return "declaration name" - case 6: - return nil - case 7: return nil - case 8: + case 6: return nil default: fatalError("Invalid index") @@ -13391,185 +12880,541 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { } } -extension TargetFunctionEntrySyntax: CustomReflectable { +extension PrecedenceGroupAssociativitySyntax: 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, + "unexpectedBeforeAssociativityKeyword": unexpectedBeforeAssociativityKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "associativityKeyword": Syntax(associativityKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAssociativityKeywordAndColon": unexpectedBetweenAssociativityKeywordAndColon.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), - "unexpectedBetweenDeclnameAndTrailingComma": unexpectedBetweenDeclnameAndTrailingComma.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, + "unexpectedBetweenColonAndValue": unexpectedBetweenColonAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "value": Syntax(value).asProtocol(SyntaxProtocol.self), + "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DeclNameSyntax +// MARK: - AttributeSyntax + +/// +/// An `@` attribute. +/// +public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { + public enum Argument: SyntaxChildChoices { + case `argumentList`(TupleExprElementListSyntax) + case `token`(TokenSyntax) + case `availability`(AvailabilitySpecListSyntax) + case `specializeArguments`(SpecializeAttributeSpecListSyntax) + case `objCName`(ObjCSelectorSyntax) + case `implementsArguments`(ImplementsAttributeArgumentsSyntax) + case `differentiableArguments`(DifferentiableAttributeArgumentsSyntax) + case `derivativeRegistrationArguments`(DerivativeRegistrationAttributeArgumentsSyntax) + case `backDeployArguments`(BackDeployAttributeSpecListSyntax) + case `conventionArguments`(ConventionAttributeArgumentsSyntax) + case `conventionWitnessMethodArguments`(ConventionWitnessMethodAttributeArgumentsSyntax) + case `opaqueReturnTypeOfAttributeArguments`(OpaqueReturnTypeOfAttributeArgumentsSyntax) + case `exposeAttributeArguments`(ExposeAttributeArgumentsSyntax) + case `originallyDefinedInArguments`(OriginallyDefinedInArgumentsSyntax) + case `underscorePrivateAttributeArguments`(UnderscorePrivateAttributeArgumentsSyntax) + case `dynamicReplacementArguments`(DynamicReplacementArgumentsSyntax) + case `unavailableFromAsyncArguments`(UnavailableFromAsyncArgumentsSyntax) + case `effectsArguments`(EffectsArgumentsSyntax) + case `documentationArguments`(DocumentationAttributeArgumentsSyntax) + public var _syntaxNode: Syntax { + switch self { + case .argumentList(let node): return node._syntaxNode + case .token(let node): return node._syntaxNode + case .availability(let node): return node._syntaxNode + case .specializeArguments(let node): return node._syntaxNode + case .objCName(let node): return node._syntaxNode + case .implementsArguments(let node): return node._syntaxNode + case .differentiableArguments(let node): return node._syntaxNode + case .derivativeRegistrationArguments(let node): return node._syntaxNode + case .backDeployArguments(let node): return node._syntaxNode + case .conventionArguments(let node): return node._syntaxNode + case .conventionWitnessMethodArguments(let node): return node._syntaxNode + case .opaqueReturnTypeOfAttributeArguments(let node): return node._syntaxNode + case .exposeAttributeArguments(let node): return node._syntaxNode + case .originallyDefinedInArguments(let node): return node._syntaxNode + case .underscorePrivateAttributeArguments(let node): return node._syntaxNode + case .dynamicReplacementArguments(let node): return node._syntaxNode + case .unavailableFromAsyncArguments(let node): return node._syntaxNode + case .effectsArguments(let node): return node._syntaxNode + case .documentationArguments(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: TupleExprElementListSyntax) { + self = .argumentList(node) + } + public init(_ node: TokenSyntax) { + self = .token(node) + } + public init(_ node: AvailabilitySpecListSyntax) { + self = .availability(node) + } + public init(_ node: SpecializeAttributeSpecListSyntax) { + self = .specializeArguments(node) + } + public init(_ node: ObjCSelectorSyntax) { + self = .objCName(node) + } + public init(_ node: ImplementsAttributeArgumentsSyntax) { + self = .implementsArguments(node) + } + public init(_ node: DifferentiableAttributeArgumentsSyntax) { + self = .differentiableArguments(node) + } + public init(_ node: DerivativeRegistrationAttributeArgumentsSyntax) { + self = .derivativeRegistrationArguments(node) + } + public init(_ node: BackDeployAttributeSpecListSyntax) { + self = .backDeployArguments(node) + } + public init(_ node: ConventionAttributeArgumentsSyntax) { + self = .conventionArguments(node) + } + public init(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) { + self = .conventionWitnessMethodArguments(node) + } + public init(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) { + self = .opaqueReturnTypeOfAttributeArguments(node) + } + public init(_ node: ExposeAttributeArgumentsSyntax) { + self = .exposeAttributeArguments(node) + } + public init(_ node: OriginallyDefinedInArgumentsSyntax) { + self = .originallyDefinedInArguments(node) + } + public init(_ node: UnderscorePrivateAttributeArgumentsSyntax) { + self = .underscorePrivateAttributeArguments(node) + } + public init(_ node: DynamicReplacementArgumentsSyntax) { + self = .dynamicReplacementArguments(node) + } + public init(_ node: UnavailableFromAsyncArgumentsSyntax) { + self = .unavailableFromAsyncArguments(node) + } + public init(_ node: EffectsArgumentsSyntax) { + self = .effectsArguments(node) + } + public init(_ node: DocumentationAttributeArgumentsSyntax) { + self = .documentationArguments(node) + } + public init?(_ node: S) { + if let node = node.as(TupleExprElementListSyntax.self) { + self = .argumentList(node) + return + } + if let node = node.as(TokenSyntax.self) { + self = .token(node) + return + } + if let node = node.as(AvailabilitySpecListSyntax.self) { + self = .availability(node) + return + } + if let node = node.as(SpecializeAttributeSpecListSyntax.self) { + self = .specializeArguments(node) + return + } + if let node = node.as(ObjCSelectorSyntax.self) { + self = .objCName(node) + return + } + if let node = node.as(ImplementsAttributeArgumentsSyntax.self) { + self = .implementsArguments(node) + return + } + if let node = node.as(DifferentiableAttributeArgumentsSyntax.self) { + self = .differentiableArguments(node) + return + } + if let node = node.as(DerivativeRegistrationAttributeArgumentsSyntax.self) { + self = .derivativeRegistrationArguments(node) + return + } + if let node = node.as(BackDeployAttributeSpecListSyntax.self) { + self = .backDeployArguments(node) + return + } + if let node = node.as(ConventionAttributeArgumentsSyntax.self) { + self = .conventionArguments(node) + return + } + if let node = node.as(ConventionWitnessMethodAttributeArgumentsSyntax.self) { + self = .conventionWitnessMethodArguments(node) + return + } + if let node = node.as(OpaqueReturnTypeOfAttributeArgumentsSyntax.self) { + self = .opaqueReturnTypeOfAttributeArguments(node) + return + } + if let node = node.as(ExposeAttributeArgumentsSyntax.self) { + self = .exposeAttributeArguments(node) + return + } + if let node = node.as(OriginallyDefinedInArgumentsSyntax.self) { + self = .originallyDefinedInArguments(node) + return + } + if let node = node.as(UnderscorePrivateAttributeArgumentsSyntax.self) { + self = .underscorePrivateAttributeArguments(node) + return + } + if let node = node.as(DynamicReplacementArgumentsSyntax.self) { + self = .dynamicReplacementArguments(node) + return + } + if let node = node.as(UnavailableFromAsyncArgumentsSyntax.self) { + self = .unavailableFromAsyncArguments(node) + return + } + if let node = node.as(EffectsArgumentsSyntax.self) { + self = .effectsArguments(node) + return + } + if let node = node.as(DocumentationAttributeArgumentsSyntax.self) { + self = .documentationArguments(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(TupleExprElementListSyntax.self), + .node(TokenSyntax.self), + .node(AvailabilitySpecListSyntax.self), + .node(SpecializeAttributeSpecListSyntax.self), + .node(ObjCSelectorSyntax.self), + .node(ImplementsAttributeArgumentsSyntax.self), + .node(DifferentiableAttributeArgumentsSyntax.self), + .node(DerivativeRegistrationAttributeArgumentsSyntax.self), + .node(BackDeployAttributeSpecListSyntax.self), + .node(ConventionAttributeArgumentsSyntax.self), + .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), + .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), + .node(ExposeAttributeArgumentsSyntax.self), + .node(OriginallyDefinedInArgumentsSyntax.self), + .node(UnderscorePrivateAttributeArgumentsSyntax.self), + .node(DynamicReplacementArgumentsSyntax.self), + .node(UnavailableFromAsyncArgumentsSyntax.self), + .node(EffectsArgumentsSyntax.self), + .node(DocumentationAttributeArgumentsSyntax.self), + ]) + } + } -public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declName else { return nil } + guard node.raw.kind == .attribute else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclNameSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AttributeSyntax` 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) { - assert(data.raw.kind == .declName) + assert(data.raw.kind == .attribute) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? = nil, - declBaseName: TokenSyntax, - _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, + atSignToken: TokenSyntax = .atSignToken(), + _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, + attributeName: A, + _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, + argument: Argument? = nil, + _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ 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(), (unexpectedBeforeDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAtSignToken, atSignToken, unexpectedBetweenAtSignTokenAndAttributeName, attributeName, unexpectedBetweenAttributeNameAndLeftParen, leftParen, unexpectedBetweenLeftParenAndArgument, argument, unexpectedBetweenArgumentAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDeclBaseName?.raw, - declBaseName.raw, - unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, - declNameArguments?.raw, - unexpectedAfterDeclNameArguments?.raw, + unexpectedBeforeAtSignToken?.raw, + atSignToken.raw, + unexpectedBetweenAtSignTokenAndAttributeName?.raw, + attributeName.raw, + unexpectedBetweenAttributeNameAndLeftParen?.raw, + leftParen?.raw, + unexpectedBetweenLeftParenAndArgument?.raw, + argument?.raw, + unexpectedBetweenArgumentAndRightParen?.raw, + rightParen?.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declName, from: layout, arena: arena, + kind: SyntaxKind.attribute, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? { + public var unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeDeclBaseName(value) + self = withUnexpectedBeforeAtSignToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeDeclBaseName` replaced. - /// - param newChild: The new `unexpectedBeforeDeclBaseName` to replace the node's - /// current `unexpectedBeforeDeclBaseName`, if present. - public func withUnexpectedBeforeDeclBaseName(_ newChild: UnexpectedNodesSyntax?) -> DeclNameSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAtSignToken` replaced. + /// - param newChild: The new `unexpectedBeforeAtSignToken` to replace the node's + /// current `unexpectedBeforeAtSignToken`, if present. + public func withUnexpectedBeforeAtSignToken(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DeclNameSyntax(newData) + return AttributeSyntax(newData) } - /// - /// The base name of the protocol's requirement. - /// - public var declBaseName: TokenSyntax { + /// The `@` sign. + public var atSignToken: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withDeclBaseName(value) + self = withAtSignToken(value) } } - /// Returns a copy of the receiver with its `declBaseName` replaced. - /// - param newChild: The new `declBaseName` to replace the node's - /// current `declBaseName`, if present. - public func withDeclBaseName(_ newChild: TokenSyntax) -> DeclNameSyntax { + /// Returns a copy of the receiver with its `atSignToken` replaced. + /// - param newChild: The new `atSignToken` to replace the node's + /// current `atSignToken`, if present. + public func withAtSignToken(_ newChild: TokenSyntax) -> AttributeSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DeclNameSyntax(newData) + return AttributeSyntax(newData) } - public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(value) + self = withUnexpectedBetweenAtSignTokenAndAttributeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDeclBaseNameAndDeclNameArguments` replaced. - /// - param newChild: The new `unexpectedBetweenDeclBaseNameAndDeclNameArguments` to replace the node's - /// current `unexpectedBetweenDeclBaseNameAndDeclNameArguments`, if present. - public func withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> DeclNameSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAtSignTokenAndAttributeName` replaced. + /// - param newChild: The new `unexpectedBetweenAtSignTokenAndAttributeName` to replace the node's + /// current `unexpectedBetweenAtSignTokenAndAttributeName`, if present. + public func withUnexpectedBetweenAtSignTokenAndAttributeName(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DeclNameSyntax(newData) + return AttributeSyntax(newData) + } + + /// The name of the attribute. + public var attributeName: TypeSyntax { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + return TypeSyntax(childData!) + } + set(value) { + self = withAttributeName(value) + } + } + + /// Returns a copy of the receiver with its `attributeName` replaced. + /// - param newChild: The new `attributeName` to replace the node's + /// current `attributeName`, if present. + public func withAttributeName(_ newChild: TypeSyntax) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return AttributeSyntax(newData) + } + + public var unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenAttributeNameAndLeftParen(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenAttributeNameAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenAttributeNameAndLeftParen` to replace the node's + /// current `unexpectedBetweenAttributeNameAndLeftParen`, if present. + public func withUnexpectedBetweenAttributeNameAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return AttributeSyntax(newData) } /// - /// The argument labels of the protocol's requirement if it - /// is a function requirement. + /// If the attribute takes arguments, the opening parenthesis. /// - public var declNameArguments: DeclNameArgumentsSyntax? { + public var leftParen: TokenSyntax? { get { - let childData = data.child(at: 3, parent: Syntax(self)) + let childData = data.child(at: 5, parent: Syntax(self)) if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDeclNameArguments(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `declNameArguments` replaced. - /// - param newChild: The new `declNameArguments` to replace the node's - /// current `declNameArguments`, if present. - public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> DeclNameSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax?) -> AttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DeclNameSyntax(newData) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return AttributeSyntax(newData) } - public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterDeclNameArguments(value) + self = withUnexpectedBetweenLeftParenAndArgument(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterDeclNameArguments` replaced. - /// - param newChild: The new `unexpectedAfterDeclNameArguments` to replace the node's - /// current `unexpectedAfterDeclNameArguments`, if present. - public func withUnexpectedAfterDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> DeclNameSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndArgument` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndArgument` to replace the node's + /// current `unexpectedBetweenLeftParenAndArgument`, if present. + public func withUnexpectedBetweenLeftParenAndArgument(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return AttributeSyntax(newData) + } + + /// + /// The arguments of the attribute. In case the attribute + /// takes multiple arguments, they are gather in the + /// appropriate takes first. + /// + public var argument: Argument? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return Argument(childData!) + } + set(value) { + self = withArgument(value) + } + } + + /// Returns a copy of the receiver with its `argument` replaced. + /// - param newChild: The new `argument` to replace the node's + /// current `argument`, if present. + public func withArgument(_ newChild: Argument?) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return AttributeSyntax(newData) + } + + public var unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenArgumentAndRightParen(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenArgumentAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenArgumentAndRightParen` to replace the node's + /// current `unexpectedBetweenArgumentAndRightParen`, if present. + public func withUnexpectedBetweenArgumentAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return AttributeSyntax(newData) + } + + /// + /// If the attribute takes arguments, the closing parenthesis. + /// + public var rightParen: TokenSyntax? { + get { + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withRightParen(value) + } + } + + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax?) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return AttributeSyntax(newData) + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 10, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightParen(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DeclNameSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return AttributeSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDeclBaseName, - \Self.declBaseName, - \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, - \Self.declNameArguments, - \Self.unexpectedAfterDeclNameArguments, + \Self.unexpectedBeforeAtSignToken, + \Self.atSignToken, + \Self.unexpectedBetweenAtSignTokenAndAttributeName, + \Self.attributeName, + \Self.unexpectedBetweenAttributeNameAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndArgument, + \Self.argument, + \Self.unexpectedBetweenArgumentAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -13578,299 +13423,322 @@ 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 "name" 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 DeclNameSyntax: CustomReflectable { +extension AttributeSyntax: 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, + "unexpectedBeforeAtSignToken": unexpectedBeforeAtSignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "atSignToken": Syntax(atSignToken).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAtSignTokenAndAttributeName": unexpectedBetweenAtSignTokenAndAttributeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "attributeName": Syntax(attributeName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAttributeNameAndLeftParen": unexpectedBetweenAttributeNameAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": leftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenLeftParenAndArgument": unexpectedBetweenLeftParenAndArgument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "argument": argument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenArgumentAndRightParen": unexpectedBetweenArgumentAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightParen": rightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ImplementsAttributeArgumentsSyntax +// MARK: - AvailabilityEntrySyntax /// -/// The arguments for the `@_implements` attribute of the form -/// `Type, methodName(arg1Label:arg2Label:)` +/// The availability argument for the _specialize attribute /// -public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .implementsAttributeArguments else { return nil } + guard node.raw.kind == .availabilityEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ImplementsAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AvailabilityEntrySyntax` 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) { - assert(data.raw.kind == .implementsAttributeArguments) + assert(data.raw.kind == .availabilityEntry) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? = nil, - declBaseName: TokenSyntax, - _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, + availabilityList: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax = .semicolonToken(), + _ 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(), (unexpectedBeforeType, type, unexpectedBetweenTypeAndComma, comma, unexpectedBetweenCommaAndDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndAvailabilityList, availabilityList, unexpectedBetweenAvailabilityListAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedBetweenTypeAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndDeclBaseName?.raw, - declBaseName.raw, - unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, - declNameArguments?.raw, - unexpectedAfterDeclNameArguments?.raw, + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndAvailabilityList?.raw, + availabilityList.raw, + unexpectedBetweenAvailabilityListAndSemicolon?.raw, + semicolon.raw, + unexpectedAfterSemicolon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.implementsAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.availabilityEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeType: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeType(value) + self = withUnexpectedBeforeLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeType` replaced. - /// - param newChild: The new `unexpectedBeforeType` to replace the node's - /// current `unexpectedBeforeType`, if present. - public func withUnexpectedBeforeType(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. + /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's + /// current `unexpectedBeforeLabel`, if present. + public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - /// - /// The type for which the method with this attribute - /// implements a requirement. - /// - public var type: TypeSyntax { + /// The label of the argument + public var label: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TypeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withType(value) + self = withLabel(value) } } - /// Returns a copy of the receiver with its `type` replaced. - /// - param newChild: The new `type` to replace the node's - /// current `type`, if present. - public func withType(_ newChild: TypeSyntax) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel(_ newChild: TokenSyntax) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - public var unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenTypeAndComma(value) + self = withUnexpectedBetweenLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenTypeAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenTypeAndComma` to replace the node's - /// current `unexpectedBetweenTypeAndComma`, if present. - public func withUnexpectedBetweenTypeAndComma(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's + /// current `unexpectedBetweenLabelAndColon`, if present. + public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - /// - /// The comma separating the type and method name - /// - public var comma: TokenSyntax { + /// The colon separating the label and the value + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withComma(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `comma` replaced. - /// - param newChild: The new `comma` to replace the node's - /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - public var unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndDeclBaseName(value) + self = withUnexpectedBetweenColonAndAvailabilityList(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndDeclBaseName` replaced. - /// - param newChild: The new `unexpectedBetweenCommaAndDeclBaseName` to replace the node's - /// current `unexpectedBetweenCommaAndDeclBaseName`, if present. - public func withUnexpectedBetweenCommaAndDeclBaseName(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndAvailabilityList` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndAvailabilityList` to replace the node's + /// current `unexpectedBetweenColonAndAvailabilityList`, if present. + public func withUnexpectedBetweenColonAndAvailabilityList(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - /// - /// The base name of the protocol's requirement. - /// - public var declBaseName: TokenSyntax { + public var availabilityList: AvailabilitySpecListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + return AvailabilitySpecListSyntax(childData!) } set(value) { - self = withDeclBaseName(value) + self = withAvailabilityList(value) } } - /// Returns a copy of the receiver with its `declBaseName` replaced. - /// - param newChild: The new `declBaseName` to replace the node's - /// current `declBaseName`, if present. - public func withDeclBaseName(_ newChild: TokenSyntax) -> ImplementsAttributeArgumentsSyntax { + /// Adds the provided `Availability` to the node's `availabilityList` + /// collection. + /// - param element: The new `Availability` to add to the node's + /// `availabilityList` collection. + /// - returns: A copy of the receiver with the provided `Availability` + /// appended to its `availabilityList` collection. + public func addAvailability(_ element: AvailabilityArgumentSyntax) -> AvailabilityEntrySyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return AvailabilityEntrySyntax(newData) + } + + /// Returns a copy of the receiver with its `availabilityList` replaced. + /// - param newChild: The new `availabilityList` to replace the node's + /// current `availabilityList`, if present. + public func withAvailabilityList(_ newChild: AvailabilitySpecListSyntax) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(value) + self = withUnexpectedBetweenAvailabilityListAndSemicolon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDeclBaseNameAndDeclNameArguments` replaced. - /// - param newChild: The new `unexpectedBetweenDeclBaseNameAndDeclNameArguments` to replace the node's - /// current `unexpectedBetweenDeclBaseNameAndDeclNameArguments`, if present. - public func withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilityListAndSemicolon` replaced. + /// - param newChild: The new `unexpectedBetweenAvailabilityListAndSemicolon` to replace the node's + /// current `unexpectedBetweenAvailabilityListAndSemicolon`, if present. + public func withUnexpectedBetweenAvailabilityListAndSemicolon(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - /// - /// The argument labels of the protocol's requirement if it - /// is a function requirement. - /// - public var declNameArguments: DeclNameArgumentsSyntax? { + public var semicolon: TokenSyntax { get { let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDeclNameArguments(value) + self = withSemicolon(value) } } - /// Returns a copy of the receiver with its `declNameArguments` replaced. - /// - param newChild: The new `declNameArguments` to replace the node's - /// current `declNameArguments`, if present. - public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `semicolon` replaced. + /// - param newChild: The new `semicolon` to replace the node's + /// current `semicolon`, if present. + public func withSemicolon(_ newChild: TokenSyntax) -> AvailabilityEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } - public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterDeclNameArguments(value) + self = withUnexpectedAfterSemicolon(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterDeclNameArguments` replaced. - /// - param newChild: The new `unexpectedAfterDeclNameArguments` to replace the node's - /// current `unexpectedAfterDeclNameArguments`, if present. - public func withUnexpectedAfterDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterSemicolon` replaced. + /// - param newChild: The new `unexpectedAfterSemicolon` to replace the node's + /// current `unexpectedAfterSemicolon`, if present. + public func withUnexpectedAfterSemicolon(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return AvailabilityEntrySyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeType, - \Self.type, - \Self.unexpectedBetweenTypeAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndDeclBaseName, - \Self.declBaseName, - \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, - \Self.declNameArguments, - \Self.unexpectedAfterDeclNameArguments, + \Self.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndAvailabilityList, + \Self.availabilityList, + \Self.unexpectedBetweenAvailabilityListAndSemicolon, + \Self.semicolon, + \Self.unexpectedAfterSemicolon, ]) } @@ -13879,7 +13747,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 0: return nil case 1: - return "type" + return "label" case 2: return nil case 3: @@ -13887,11 +13755,11 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 4: return nil case 5: - return "declaration base name" + return nil case 6: return nil case 7: - return "declaration name arguments" + return nil case 8: return nil default: @@ -13900,139 +13768,146 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } -extension ImplementsAttributeArgumentsSyntax: CustomReflectable { +extension AvailabilityEntrySyntax: 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), - "unexpectedBetweenTypeAndComma": unexpectedBetweenTypeAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCommaAndDeclBaseName": unexpectedBetweenCommaAndDeclBaseName.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, + "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), + "unexpectedBetweenColonAndAvailabilityList": unexpectedBetweenColonAndAvailabilityList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "availabilityList": Syntax(availabilityList).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAvailabilityListAndSemicolon": unexpectedBetweenAvailabilityListAndSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "semicolon": Syntax(semicolon).asProtocol(SyntaxProtocol.self), + "unexpectedAfterSemicolon": unexpectedAfterSemicolon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ObjCSelectorPieceSyntax +// MARK: - LabeledSpecializeEntrySyntax /// -/// A piece of an Objective-C selector. Either consisting of just an -/// identifier for a nullary selector, an identifier and a colon for a -/// labeled argument or just a colon for an unlabeled argument +/// A labeled argument for the `@_specialize` attribute like +/// `exported: true` /// -public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { +public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .objCSelectorPiece else { return nil } + guard node.raw.kind == .labeledSpecializeEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ObjCSelectorPieceSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `LabeledSpecializeEntrySyntax` 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) { - assert(data.raw.kind == .objCSelectorPiece) + assert(data.raw.kind == .labeledSpecializeEntry) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax? = nil, - _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ 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(), (unexpectedBeforeName, name, unexpectedBetweenNameAndColon, colon, unexpectedAfterColon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name?.raw, - unexpectedBetweenNameAndColon?.raw, - colon?.raw, - unexpectedAfterColon?.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.objCSelectorPiece, from: layout, arena: arena, + kind: SyntaxKind.labeledSpecializeEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeName(value) + self = withUnexpectedBeforeLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. - /// - param newChild: The new `unexpectedBeforeName` to replace the node's - /// current `unexpectedBeforeName`, if present. - public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> ObjCSelectorPieceSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. + /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's + /// current `unexpectedBeforeLabel`, if present. + public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } - public var name: TokenSyntax? { + /// The label of the argument + public var label: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withLabel(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax?) -> ObjCSelectorPieceSyntax { + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel(_ newChild: TokenSyntax) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } - public var unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndColon(value) + self = withUnexpectedBetweenLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndColon` to replace the node's - /// current `unexpectedBetweenNameAndColon`, if present. - public func withUnexpectedBetweenNameAndColon(_ newChild: UnexpectedNodesSyntax?) -> ObjCSelectorPieceSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's + /// current `unexpectedBetweenLabelAndColon`, if present. + public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } - public var colon: TokenSyntax? { + /// The colon separating the label and the value + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { @@ -14043,41 +13918,132 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `colon` replaced. /// - param newChild: The new `colon` to replace the node's /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax?) -> ObjCSelectorPieceSyntax { + public func withColon(_ newChild: TokenSyntax) -> LabeledSpecializeEntrySyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return LabeledSpecializeEntrySyntax(newData) + } + + public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenColonAndValue(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndValue` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndValue` to replace the node's + /// current `unexpectedBetweenColonAndValue`, if present. + public func withUnexpectedBetweenColonAndValue(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return LabeledSpecializeEntrySyntax(newData) + } + + /// The value for this argument + public var value: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withValue(value) + } + } + + /// Returns a copy of the receiver with its `value` replaced. + /// - param newChild: The new `value` to replace the node's + /// current `value`, if present. + public func withValue(_ newChild: TokenSyntax) -> LabeledSpecializeEntrySyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return LabeledSpecializeEntrySyntax(newData) + } + + public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenValueAndTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenValueAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenValueAndTrailingComma` to replace the node's + /// current `unexpectedBetweenValueAndTrailingComma`, if present. + public func withUnexpectedBetweenValueAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return LabeledSpecializeEntrySyntax(newData) + } + + /// + /// A trailing comma if this argument is followed by another one + /// + public var trailingComma: TokenSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withTrailingComma(value) + } + } + + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return LabeledSpecializeEntrySyntax(newData) } - public var unexpectedAfterColon: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterColon(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterColon` replaced. - /// - param newChild: The new `unexpectedAfterColon` to replace the node's - /// current `unexpectedAfterColon`, if present. - public func withUnexpectedAfterColon(_ newChild: UnexpectedNodesSyntax?) -> ObjCSelectorPieceSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return LabeledSpecializeEntrySyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndColon, + \Self.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, \Self.colon, - \Self.unexpectedAfterColon, + \Self.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedBetweenValueAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -14086,344 +14052,304 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return "label" case 2: return nil case 3: return nil case 4: return nil + case 5: + return "value" + case 6: + return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension ObjCSelectorPieceSyntax: CustomReflectable { +extension LabeledSpecializeEntrySyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "name": name.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenNameAndColon": unexpectedBetweenNameAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterColon": unexpectedAfterColon.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: - TargetFunctionEntrySyntax /// -/// The arguments for the `@differentiable` attribute: an optional -/// differentiability kind, an optional differentiability parameter clause, -/// and an optional 'where' clause. +/// A labeled argument for the `@_specialize` attribute with a function +/// decl value like +/// `target: myFunc(_:)` /// -public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiableAttributeArguments else { return nil } + guard node.raw.kind == .targetFunctionEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiableAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `TargetFunctionEntrySyntax` 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) { - assert(data.raw.kind == .differentiableAttributeArguments) + assert(data.raw.kind == .targetFunctionEntry) 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, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, + declname: DeclNameSyntax, + _ unexpectedBetweenDeclnameAndTrailingComma: 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(), (unexpectedBeforeDiffKind, diffKind, unexpectedBetweenDiffKindAndDiffKindComma, diffKindComma, unexpectedBetweenDiffKindCommaAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndDiffParamsComma, diffParamsComma, unexpectedBetweenDiffParamsCommaAndWhereClause, whereClause, unexpectedAfterWhereClause))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndDeclname, declname, unexpectedBetweenDeclnameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (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, + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndDeclname?.raw, + declname.raw, + unexpectedBetweenDeclnameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiableAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.targetFunctionEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDiffKind: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeDiffKind(value) + self = withUnexpectedBeforeLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeDiffKind` replaced. - /// - param newChild: The new `unexpectedBeforeDiffKind` to replace the node's - /// current `unexpectedBeforeDiffKind`, if present. - public func withUnexpectedBeforeDiffKind(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. + /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's + /// current `unexpectedBeforeLabel`, if present. + public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + return TargetFunctionEntrySyntax(newData) } - public var diffKind: TokenSyntax? { + /// The label of the argument + public var label: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withDiffKind(value) + self = withLabel(value) } } - /// Returns a copy of the receiver with its `diffKind` replaced. - /// - param newChild: The new `diffKind` to replace the node's - /// current `diffKind`, if present. - public func withDiffKind(_ newChild: TokenSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel(_ newChild: TokenSyntax) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + return TargetFunctionEntrySyntax(newData) } - public var unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDiffKindAndDiffKindComma(value) + self = withUnexpectedBetweenLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDiffKindAndDiffKindComma` replaced. - /// - param newChild: The new `unexpectedBetweenDiffKindAndDiffKindComma` to replace the node's - /// current `unexpectedBetweenDiffKindAndDiffKindComma`, if present. - public func withUnexpectedBetweenDiffKindAndDiffKindComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's + /// current `unexpectedBetweenLabelAndColon`, if present. + public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + return TargetFunctionEntrySyntax(newData) } - /// - /// The comma following the differentiability kind, if it exists. - /// - public var diffKindComma: TokenSyntax? { + /// The colon separating the label and the value + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withDiffKindComma(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `diffKindComma` replaced. - /// - param newChild: The new `diffKindComma` to replace the node's - /// current `diffKindComma`, if present. - public func withDiffKindComma(_ newChild: TokenSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + return TargetFunctionEntrySyntax(newData) } - public var unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDiffKindCommaAndDiffParams(value) + self = withUnexpectedBetweenColonAndDeclname(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDiffKindCommaAndDiffParams` replaced. - /// - param newChild: The new `unexpectedBetweenDiffKindCommaAndDiffParams` to replace the node's - /// current `unexpectedBetweenDiffKindCommaAndDiffParams`, if present. - public func withUnexpectedBetweenDiffKindCommaAndDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndDeclname` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndDeclname` to replace the node's + /// current `unexpectedBetweenColonAndDeclname`, if present. + public func withUnexpectedBetweenColonAndDeclname(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) - } - - public var diffParams: DifferentiabilityParamsClauseSyntax? { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return DifferentiabilityParamsClauseSyntax(childData!) - } - set(value) { - self = withDiffParams(value) - } - } - - /// Returns a copy of the receiver with its `diffParams` replaced. - /// - param newChild: The new `diffParams` to replace the node's - /// current `diffParams`, if present. - public func withDiffParams(_ newChild: DifferentiabilityParamsClauseSyntax?) -> DifferentiableAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) - } - - public var unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenDiffParamsAndDiffParamsComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenDiffParamsAndDiffParamsComma` replaced. - /// - param newChild: The new `unexpectedBetweenDiffParamsAndDiffParamsComma` to replace the node's - /// current `unexpectedBetweenDiffParamsAndDiffParamsComma`, if present. - public func withUnexpectedBetweenDiffParamsAndDiffParamsComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + return TargetFunctionEntrySyntax(newData) } - /// - /// The comma following the differentiability parameters clause, - /// if it exists. - /// - public var diffParamsComma: TokenSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + /// The value for this argument + public var declname: DeclNameSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return DeclNameSyntax(childData!) } set(value) { - self = withDiffParamsComma(value) + self = withDeclname(value) } } - /// Returns a copy of the receiver with its `diffParamsComma` replaced. - /// - param newChild: The new `diffParamsComma` to replace the node's - /// current `diffParamsComma`, if present. - public func withDiffParamsComma(_ newChild: TokenSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `declname` replaced. + /// - param newChild: The new `declname` to replace the node's + /// current `declname`, if present. + public func withDeclname(_ newChild: DeclNameSyntax) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) } - public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDiffParamsCommaAndWhereClause(value) + self = withUnexpectedBetweenDeclnameAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDiffParamsCommaAndWhereClause` replaced. - /// - param newChild: The new `unexpectedBetweenDiffParamsCommaAndWhereClause` to replace the node's - /// current `unexpectedBetweenDiffParamsCommaAndWhereClause`, if present. - public func withUnexpectedBetweenDiffParamsCommaAndWhereClause(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDeclnameAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenDeclnameAndTrailingComma` to replace the node's + /// current `unexpectedBetweenDeclnameAndTrailingComma`, if present. + public func withUnexpectedBetweenDeclnameAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) } - public var whereClause: GenericWhereClauseSyntax? { + /// + /// A trailing comma if this argument is followed by another one + /// + public var trailingComma: TokenSyntax? { get { - let childData = data.child(at: 9, parent: Syntax(self)) + let childData = data.child(at: 7, parent: Syntax(self)) if childData == nil { return nil } - return GenericWhereClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withWhereClause(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `whereClause` replaced. - /// - param newChild: The new `whereClause` to replace the node's - /// current `whereClause`, if present. - public func withWhereClause(_ newChild: GenericWhereClauseSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) } - public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterWhereClause(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterWhereClause` replaced. - /// - param newChild: The new `unexpectedAfterWhereClause` to replace the node's - /// current `unexpectedAfterWhereClause`, if present. - public func withUnexpectedAfterWhereClause(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) } 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.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndDeclname, + \Self.declname, + \Self.unexpectedBetweenDeclnameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -14432,7 +14358,7 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: @@ -14440,284 +14366,198 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash case 4: return nil case 5: - return nil + return "declaration name" 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 TargetFunctionEntrySyntax: 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, + "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), + "unexpectedBetweenColonAndDeclname": unexpectedBetweenColonAndDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "declname": Syntax(declname).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDeclnameAndTrailingComma": unexpectedBetweenDeclnameAndTrailingComma.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), - ]) - } - } +// MARK: - DeclNameSyntax +public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParamsClause else { return nil } + guard node.raw.kind == .declName else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamsClauseSyntax` 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) { - assert(data.raw.kind == .differentiabilityParamsClause) + assert(data.raw.kind == .declName) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, - wrtLabel: TokenSyntax = .identifier("wrt"), - _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, - parameters: Parameters, - _ unexpectedAfterParameters: 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(), (unexpectedBeforeWrtLabel, wrtLabel, unexpectedBetweenWrtLabelAndColon, colon, unexpectedBetweenColonAndParameters, parameters, unexpectedAfterParameters))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWrtLabel?.raw, - wrtLabel.raw, - unexpectedBetweenWrtLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndParameters?.raw, - parameters.raw, - unexpectedAfterParameters?.raw, + unexpectedBeforeDeclBaseName?.raw, + declBaseName.raw, + unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedAfterDeclNameArguments?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParamsClause, from: layout, arena: arena, + kind: SyntaxKind.declName, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeWrtLabel(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeWrtLabel` replaced. - /// - param newChild: The new `unexpectedBeforeWrtLabel` to replace the node's - /// current `unexpectedBeforeWrtLabel`, if present. - public func withUnexpectedBeforeWrtLabel(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) - } - - /// The "wrt" label. - public var wrtLabel: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withWrtLabel(value) - } - } - - /// Returns a copy of the receiver with its `wrtLabel` replaced. - /// - param newChild: The new `wrtLabel` to replace the node's - /// current `wrtLabel`, if present. - public func withWrtLabel(_ newChild: TokenSyntax) -> DifferentiabilityParamsClauseSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) - } - - public var unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenWrtLabelAndColon(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenWrtLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenWrtLabelAndColon` to replace the node's - /// current `unexpectedBetweenWrtLabelAndColon`, if present. - public func withUnexpectedBetweenWrtLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { + self = withUnexpectedBeforeDeclBaseName(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBeforeDeclBaseName` replaced. + /// - param newChild: The new `unexpectedBeforeDeclBaseName` to replace the node's + /// current `unexpectedBeforeDeclBaseName`, if present. + public func withUnexpectedBeforeDeclBaseName(_ newChild: UnexpectedNodesSyntax?) -> DeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return DeclNameSyntax(newData) } /// - /// The colon separating "wrt" and the parameter list. + /// The base name of the protocol's requirement. /// - public var colon: TokenSyntax { + public var declBaseName: TokenSyntax { get { - let childData = data.child(at: 3, parent: Syntax(self)) + let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withDeclBaseName(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> DifferentiabilityParamsClauseSyntax { + /// Returns a copy of the receiver with its `declBaseName` replaced. + /// - param newChild: The new `declBaseName` to replace the node's + /// current `declBaseName`, if present. + public func withDeclBaseName(_ newChild: TokenSyntax) -> DeclNameSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return DeclNameSyntax(newData) } - public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndParameters(value) + self = withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndParameters` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndParameters` to replace the node's - /// current `unexpectedBetweenColonAndParameters`, if present. - public func withUnexpectedBetweenColonAndParameters(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDeclBaseNameAndDeclNameArguments` replaced. + /// - param newChild: The new `unexpectedBetweenDeclBaseNameAndDeclNameArguments` to replace the node's + /// current `unexpectedBetweenDeclBaseNameAndDeclNameArguments`, if present. + public func withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> DeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return DeclNameSyntax(newData) } - public var parameters: Parameters { + /// + /// The argument labels of the protocol's requirement if it + /// is a function requirement. + /// + public var declNameArguments: DeclNameArgumentsSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) - return Parameters(childData!) + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return DeclNameArgumentsSyntax(childData!) } set(value) { - self = withParameters(value) + self = withDeclNameArguments(value) } } - /// Returns a copy of the receiver with its `parameters` replaced. - /// - param newChild: The new `parameters` to replace the node's - /// current `parameters`, if present. - public func withParameters(_ newChild: Parameters) -> DifferentiabilityParamsClauseSyntax { + /// Returns a copy of the receiver with its `declNameArguments` replaced. + /// - param newChild: The new `declNameArguments` to replace the node's + /// current `declNameArguments`, if present. + public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> DeclNameSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return DeclNameSyntax(newData) } - public var unexpectedAfterParameters: UnexpectedNodesSyntax? { + public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterParameters(value) + self = withUnexpectedAfterDeclNameArguments(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterParameters` replaced. - /// - param newChild: The new `unexpectedAfterParameters` to replace the node's - /// current `unexpectedAfterParameters`, if present. - public func withUnexpectedAfterParameters(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterDeclNameArguments` replaced. + /// - param newChild: The new `unexpectedAfterDeclNameArguments` to replace the node's + /// current `unexpectedAfterDeclNameArguments`, if present. + public func withUnexpectedAfterDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> DeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return DeclNameSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWrtLabel, - \Self.wrtLabel, - \Self.unexpectedBetweenWrtLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndParameters, - \Self.parameters, - \Self.unexpectedAfterParameters, + \Self.unexpectedBeforeDeclBaseName, + \Self.declBaseName, + \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedAfterDeclNameArguments, ]) } @@ -14726,260 +14566,299 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl 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 - case 5: - return "parameters" - case 6: - return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamsClauseSyntax: CustomReflectable { +extension DeclNameSyntax: 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, + "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: - DifferentiabilityParamsSyntax +// MARK: - ImplementsAttributeArgumentsSyntax -/// The differentiability parameters. -public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the `@_implements` attribute of the form +/// `Type, methodName(arg1Label:arg2Label:)` +/// +public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParams else { return nil } + guard node.raw.kind == .implementsAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ImplementsAttributeArgumentsSyntax` 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) { - assert(data.raw.kind == .differentiabilityParams) + assert(data.raw.kind == .implementsAttributeArguments) self._syntaxNode = Syntax(data) } - public init( + 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, + _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndDeclBaseName: 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(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeType, type, unexpectedBetweenTypeAndComma, comma, unexpectedBetweenCommaAndDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndDiffParams?.raw, - diffParams.raw, - unexpectedBetweenDiffParamsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeType?.raw, + type.raw, + unexpectedBetweenTypeAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndDeclBaseName?.raw, + declBaseName.raw, + unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedAfterDeclNameArguments?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParams, from: layout, arena: arena, + kind: SyntaxKind.implementsAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeType: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftParen(value) + self = withUnexpectedBeforeType(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. - /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's - /// current `unexpectedBeforeLeftParen`, if present. - public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeType` replaced. + /// - param newChild: The new `unexpectedBeforeType` to replace the node's + /// current `unexpectedBeforeType`, if present. + public func withUnexpectedBeforeType(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DifferentiabilityParamsSyntax(newData) + return ImplementsAttributeArgumentsSyntax(newData) } - public var leftParen: TokenSyntax { + /// + /// The type for which the method with this attribute + /// implements a requirement. + /// + public var type: TypeSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return TypeSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withType(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> DifferentiabilityParamsSyntax { + /// Returns a copy of the receiver with its `type` replaced. + /// - param newChild: The new `type` to replace the node's + /// current `type`, if present. + public func withType(_ newChild: TypeSyntax) -> ImplementsAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DifferentiabilityParamsSyntax(newData) + return ImplementsAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndDiffParams(value) + self = withUnexpectedBetweenTypeAndComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndDiffParams` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndDiffParams` to replace the node's - /// current `unexpectedBetweenLeftParenAndDiffParams`, if present. - public func withUnexpectedBetweenLeftParenAndDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenTypeAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenTypeAndComma` to replace the node's + /// current `unexpectedBetweenTypeAndComma`, if present. + public func withUnexpectedBetweenTypeAndComma(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DifferentiabilityParamsSyntax(newData) + return ImplementsAttributeArgumentsSyntax(newData) } - /// The parameters for differentiation. - public var diffParams: DifferentiabilityParamListSyntax { + /// + /// The comma separating the type and method name + /// + public var comma: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return DifferentiabilityParamListSyntax(childData!) - } - set(value) { - self = withDiffParams(value) + return TokenSyntax(childData!) } - } - - /// 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) + set(value) { + self = withComma(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return DifferentiabilityParamsSyntax(newData) } - /// Returns a copy of the receiver with its `diffParams` replaced. - /// - param newChild: The new `diffParams` to replace the node's - /// current `diffParams`, if present. - public func withDiffParams(_ newChild: DifferentiabilityParamListSyntax) -> DifferentiabilityParamsSyntax { + /// Returns a copy of the receiver with its `comma` replaced. + /// - param newChild: The new `comma` to replace the node's + /// current `comma`, if present. + public func withComma(_ newChild: TokenSyntax) -> ImplementsAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DifferentiabilityParamsSyntax(newData) + return ImplementsAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDiffParamsAndRightParen(value) + self = withUnexpectedBetweenCommaAndDeclBaseName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDiffParamsAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenDiffParamsAndRightParen` to replace the node's - /// current `unexpectedBetweenDiffParamsAndRightParen`, if present. - public func withUnexpectedBetweenDiffParamsAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndDeclBaseName` replaced. + /// - param newChild: The new `unexpectedBetweenCommaAndDeclBaseName` to replace the node's + /// current `unexpectedBetweenCommaAndDeclBaseName`, if present. + public func withUnexpectedBetweenCommaAndDeclBaseName(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DifferentiabilityParamsSyntax(newData) + return ImplementsAttributeArgumentsSyntax(newData) } - public var rightParen: TokenSyntax { + /// + /// The base name of the protocol's requirement. + /// + public var declBaseName: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withDeclBaseName(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> DifferentiabilityParamsSyntax { + /// Returns a copy of the receiver with its `declBaseName` replaced. + /// - param newChild: The new `declBaseName` to replace the node's + /// current `declBaseName`, if present. + public func withDeclBaseName(_ newChild: TokenSyntax) -> ImplementsAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DifferentiabilityParamsSyntax(newData) + return ImplementsAttributeArgumentsSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDeclBaseNameAndDeclNameArguments` replaced. + /// - param newChild: The new `unexpectedBetweenDeclBaseNameAndDeclNameArguments` to replace the node's + /// current `unexpectedBetweenDeclBaseNameAndDeclNameArguments`, if present. + public func withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DifferentiabilityParamsSyntax(newData) + return ImplementsAttributeArgumentsSyntax(newData) + } + + /// + /// The argument labels of the protocol's requirement if it + /// is a function requirement. + /// + public var declNameArguments: DeclNameArgumentsSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return DeclNameArgumentsSyntax(childData!) + } + set(value) { + self = withDeclNameArguments(value) + } + } + + /// Returns a copy of the receiver with its `declNameArguments` replaced. + /// - param newChild: The new `declNameArguments` to replace the node's + /// current `declNameArguments`, if present. + public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> ImplementsAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return ImplementsAttributeArgumentsSyntax(newData) + } + + public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterDeclNameArguments(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterDeclNameArguments` replaced. + /// - param newChild: The new `unexpectedAfterDeclNameArguments` to replace the node's + /// current `unexpectedAfterDeclNameArguments`, if present. + public func withUnexpectedAfterDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> ImplementsAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return ImplementsAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndDiffParams, - \Self.diffParams, - \Self.unexpectedBetweenDiffParamsAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeType, + \Self.type, + \Self.unexpectedBetweenTypeAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndDeclBaseName, + \Self.declBaseName, + \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedAfterDeclNameArguments, ]) } @@ -14988,7 +14867,7 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "type" case 2: return nil case 3: @@ -14996,189 +14875,197 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return nil + return "declaration base name" case 6: return nil + case 7: + return "declaration name arguments" + case 8: + return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamsSyntax: CustomReflectable { +extension ImplementsAttributeArgumentsSyntax: 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, + "unexpectedBeforeType": unexpectedBeforeType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "type": Syntax(type).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenTypeAndComma": unexpectedBetweenTypeAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCommaAndDeclBaseName": unexpectedBetweenCommaAndDeclBaseName.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: - DifferentiabilityParamSyntax +// MARK: - ObjCSelectorPieceSyntax /// -/// A differentiability parameter: either the "self" identifier, a function -/// parameter name, or a function parameter index. +/// A piece of an Objective-C selector. Either consisting of just an +/// identifier for a nullary selector, an identifier and a colon for a +/// labeled argument or just a colon for an unlabeled argument /// -public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { +public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParam else { return nil } + guard node.raw.kind == .objCSelectorPiece else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ObjCSelectorPieceSyntax` 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) { - assert(data.raw.kind == .differentiabilityParam) + assert(data.raw.kind == .objCSelectorPiece) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, - parameter: TokenSyntax, - _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax? = nil, + _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ 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(), (unexpectedBeforeParameter, parameter, unexpectedBetweenParameterAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndColon, colon, unexpectedAfterColon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeParameter?.raw, - parameter.raw, - unexpectedBetweenParameterAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeName?.raw, + name?.raw, + unexpectedBetweenNameAndColon?.raw, + colon?.raw, + unexpectedAfterColon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParam, from: layout, arena: arena, + kind: SyntaxKind.objCSelectorPiece, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeParameter: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeParameter(value) + self = withUnexpectedBeforeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeParameter` replaced. - /// - param newChild: The new `unexpectedBeforeParameter` to replace the node's - /// current `unexpectedBeforeParameter`, if present. - public func withUnexpectedBeforeParameter(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. + /// - param newChild: The new `unexpectedBeforeName` to replace the node's + /// current `unexpectedBeforeName`, if present. + public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> ObjCSelectorPieceSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DifferentiabilityParamSyntax(newData) + return ObjCSelectorPieceSyntax(newData) } - public var parameter: TokenSyntax { + public var name: TokenSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withParameter(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `parameter` replaced. - /// - param newChild: The new `parameter` to replace the node's - /// current `parameter`, if present. - public func withParameter(_ newChild: TokenSyntax) -> DifferentiabilityParamSyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax?) -> ObjCSelectorPieceSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DifferentiabilityParamSyntax(newData) + return ObjCSelectorPieceSyntax(newData) } - public var unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenParameterAndTrailingComma(value) + self = withUnexpectedBetweenNameAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenParameterAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenParameterAndTrailingComma` to replace the node's - /// current `unexpectedBetweenParameterAndTrailingComma`, if present. - public func withUnexpectedBetweenParameterAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndColon` to replace the node's + /// current `unexpectedBetweenNameAndColon`, if present. + public func withUnexpectedBetweenNameAndColon(_ newChild: UnexpectedNodesSyntax?) -> ObjCSelectorPieceSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DifferentiabilityParamSyntax(newData) + return ObjCSelectorPieceSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var colon: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> DifferentiabilityParamSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax?) -> ObjCSelectorPieceSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DifferentiabilityParamSyntax(newData) + return ObjCSelectorPieceSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedAfterColon(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterColon` replaced. + /// - param newChild: The new `unexpectedAfterColon` to replace the node's + /// current `unexpectedAfterColon`, if present. + public func withUnexpectedAfterColon(_ newChild: UnexpectedNodesSyntax?) -> ObjCSelectorPieceSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DifferentiabilityParamSyntax(newData) + return ObjCSelectorPieceSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeParameter, - \Self.parameter, - \Self.unexpectedBetweenParameterAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndColon, + \Self.colon, + \Self.unexpectedAfterColon, ]) } @@ -15187,7 +15074,7 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "name" case 2: return nil case 3: @@ -15200,428 +15087,625 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { } } -extension DifferentiabilityParamSyntax: CustomReflectable { +extension ObjCSelectorPieceSyntax: 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, + "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": name.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenNameAndColon": unexpectedBetweenNameAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterColon": unexpectedAfterColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DerivativeRegistrationAttributeArgumentsSyntax +// MARK: - DifferentiableAttributeArgumentsSyntax /// -/// The arguments for the '@derivative(of:)' and '@transpose(of:)' -/// attributes: the 'of:' label, the original declaration name, and an -/// optional differentiability parameter list. +/// The arguments for the `@differentiable` attribute: an optional +/// differentiability kind, an optional differentiability parameter clause, +/// and an optional 'where' clause. /// -public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .derivativeRegistrationAttributeArguments else { return nil } + guard node.raw.kind == .differentiableAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DerivativeRegistrationAttributeArgumentsSyntax` 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) { - assert(data.raw.kind == .derivativeRegistrationAttributeArguments) + assert(data.raw.kind == .differentiableAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, - ofLabel: TokenSyntax = .identifier("of"), - _ unexpectedBetweenOfLabelAndColon: 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, + _ unexpectedBeforeDiffKind: UnexpectedNodesSyntax? = nil, + diffKind: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? = nil, + diffKindComma: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? = nil, diffParams: DifferentiabilityParamsClauseSyntax? = nil, - _ unexpectedAfterDiffParams: UnexpectedNodesSyntax? = 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(), (unexpectedBeforeOfLabel, ofLabel, unexpectedBetweenOfLabelAndColon, colon, unexpectedBetweenColonAndOriginalDeclName, originalDeclName, unexpectedBetweenOriginalDeclNameAndPeriod, period, unexpectedBetweenPeriodAndAccessorKind, accessorKind, unexpectedBetweenAccessorKindAndComma, comma, unexpectedBetweenCommaAndDiffParams, diffParams, unexpectedAfterDiffParams))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDiffKind, diffKind, unexpectedBetweenDiffKindAndDiffKindComma, diffKindComma, unexpectedBetweenDiffKindCommaAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndDiffParamsComma, diffParamsComma, unexpectedBetweenDiffParamsCommaAndWhereClause, whereClause, unexpectedAfterWhereClause))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeOfLabel?.raw, - ofLabel.raw, - unexpectedBetweenOfLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndOriginalDeclName?.raw, - originalDeclName.raw, - unexpectedBetweenOriginalDeclNameAndPeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndAccessorKind?.raw, - accessorKind?.raw, - unexpectedBetweenAccessorKindAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndDiffParams?.raw, + unexpectedBeforeDiffKind?.raw, + diffKind?.raw, + unexpectedBetweenDiffKindAndDiffKindComma?.raw, + diffKindComma?.raw, + unexpectedBetweenDiffKindCommaAndDiffParams?.raw, diffParams?.raw, - unexpectedAfterDiffParams?.raw, + unexpectedBetweenDiffParamsAndDiffParamsComma?.raw, + diffParamsComma?.raw, + unexpectedBetweenDiffParamsCommaAndWhereClause?.raw, + whereClause?.raw, + unexpectedAfterWhereClause?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.derivativeRegistrationAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.differentiableAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeOfLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeDiffKind: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeOfLabel(value) + self = withUnexpectedBeforeDiffKind(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeOfLabel` replaced. - /// - param newChild: The new `unexpectedBeforeOfLabel` to replace the node's - /// current `unexpectedBeforeOfLabel`, if present. - public func withUnexpectedBeforeOfLabel(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeDiffKind` replaced. + /// - param newChild: The new `unexpectedBeforeDiffKind` to replace the node's + /// current `unexpectedBeforeDiffKind`, if present. + public func withUnexpectedBeforeDiffKind(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + return DifferentiableAttributeArgumentsSyntax(newData) } - /// The "of" label. - public var ofLabel: TokenSyntax { + public var diffKind: TokenSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withOfLabel(value) + self = withDiffKind(value) } } - /// Returns a copy of the receiver with its `ofLabel` replaced. - /// - param newChild: The new `ofLabel` to replace the node's - /// current `ofLabel`, if present. - public func withOfLabel(_ newChild: TokenSyntax) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `diffKind` replaced. + /// - param newChild: The new `diffKind` to replace the node's + /// current `diffKind`, if present. + public func withDiffKind(_ newChild: TokenSyntax?) -> DifferentiableAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenOfLabelAndColon(value) + self = withUnexpectedBetweenDiffKindAndDiffKindComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenOfLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenOfLabelAndColon` to replace the node's - /// current `unexpectedBetweenOfLabelAndColon`, if present. - public func withUnexpectedBetweenOfLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDiffKindAndDiffKindComma` replaced. + /// - param newChild: The new `unexpectedBetweenDiffKindAndDiffKindComma` to replace the node's + /// current `unexpectedBetweenDiffKindAndDiffKindComma`, if present. + public func withUnexpectedBetweenDiffKindAndDiffKindComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + return DifferentiableAttributeArgumentsSyntax(newData) } /// - /// The colon separating the "of" label and the original - /// declaration name. + /// The comma following the differentiability kind, if it exists. /// - public var colon: TokenSyntax { + public var diffKindComma: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withDiffKindComma(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `diffKindComma` replaced. + /// - param newChild: The new `diffKindComma` to replace the node's + /// current `diffKindComma`, if present. + public func withDiffKindComma(_ newChild: TokenSyntax?) -> DifferentiableAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndOriginalDeclName(value) + self = withUnexpectedBetweenDiffKindCommaAndDiffParams(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndOriginalDeclName` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndOriginalDeclName` to replace the node's - /// current `unexpectedBetweenColonAndOriginalDeclName`, if present. - public func withUnexpectedBetweenColonAndOriginalDeclName(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDiffKindCommaAndDiffParams` replaced. + /// - param newChild: The new `unexpectedBetweenDiffKindCommaAndDiffParams` to replace the node's + /// current `unexpectedBetweenDiffKindCommaAndDiffParams`, if present. + public func withUnexpectedBetweenDiffKindCommaAndDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) + } + + public var diffParams: DifferentiabilityParamsClauseSyntax? { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } + return DifferentiabilityParamsClauseSyntax(childData!) + } + set(value) { + self = withDiffParams(value) + } + } + + /// Returns a copy of the receiver with its `diffParams` replaced. + /// - param newChild: The new `diffParams` to replace the node's + /// current `diffParams`, if present. + public func withDiffParams(_ newChild: DifferentiabilityParamsClauseSyntax?) -> DifferentiableAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) + } + + public var unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenDiffParamsAndDiffParamsComma(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenDiffParamsAndDiffParamsComma` replaced. + /// - param newChild: The new `unexpectedBetweenDiffParamsAndDiffParamsComma` to replace the node's + /// current `unexpectedBetweenDiffParamsAndDiffParamsComma`, if present. + public func withUnexpectedBetweenDiffParamsAndDiffParamsComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) + } + + /// + /// The comma following the differentiability parameters clause, + /// if it exists. + /// + public var diffParamsComma: TokenSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withDiffParamsComma(value) + } + } + + /// Returns a copy of the receiver with its `diffParamsComma` replaced. + /// - param newChild: The new `diffParamsComma` to replace the node's + /// current `diffParamsComma`, if present. + public func withDiffParamsComma(_ newChild: TokenSyntax?) -> DifferentiableAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) + } + + public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenDiffParamsCommaAndWhereClause(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenDiffParamsCommaAndWhereClause` replaced. + /// - param newChild: The new `unexpectedBetweenDiffParamsCommaAndWhereClause` to replace the node's + /// current `unexpectedBetweenDiffParamsCommaAndWhereClause`, if present. + public func withUnexpectedBetweenDiffParamsCommaAndWhereClause(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - /// The referenced original declaration name. - public var originalDeclName: QualifiedDeclNameSyntax { + public var whereClause: GenericWhereClauseSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) - return QualifiedDeclNameSyntax(childData!) + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return GenericWhereClauseSyntax(childData!) } set(value) { - self = withOriginalDeclName(value) + self = withWhereClause(value) } } - /// Returns a copy of the receiver with its `originalDeclName` replaced. - /// - param newChild: The new `originalDeclName` to replace the node's - /// current `originalDeclName`, if present. - public func withOriginalDeclName(_ newChild: QualifiedDeclNameSyntax) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `whereClause` replaced. + /// - param newChild: The new `whereClause` to replace the node's + /// current `whereClause`, if present. + public func withWhereClause(_ newChild: GenericWhereClauseSyntax?) -> DifferentiableAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? { + public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenOriginalDeclNameAndPeriod(value) + self = withUnexpectedAfterWhereClause(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenOriginalDeclNameAndPeriod` replaced. - /// - param newChild: The new `unexpectedBetweenOriginalDeclNameAndPeriod` to replace the node's - /// current `unexpectedBetweenOriginalDeclNameAndPeriod`, if present. - public func withUnexpectedBetweenOriginalDeclNameAndPeriod(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterWhereClause` replaced. + /// - param newChild: The new `unexpectedAfterWhereClause` to replace the node's + /// current `unexpectedAfterWhereClause`, if present. + public func withUnexpectedAfterWhereClause(_ newChild: UnexpectedNodesSyntax?) -> DifferentiableAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - /// - /// The period separating the original declaration name and the - /// accessor name. - /// - public var period: TokenSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + 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, + ]) + } + + 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 + 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") } - set(value) { - self = withPeriod(value) + } +} + +extension DifferentiableAttributeArgumentsSyntax: 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, + ]) + } +} + +// 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), + ]) } } - /// Returns a copy of the receiver with its `period` replaced. - /// - param newChild: The new `period` to replace the node's - /// current `period`, if present. - public func withPeriod(_ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .differentiabilityParamsClause else { return nil } + self._syntaxNode = node._syntaxNode } - public var unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? { + /// 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) { + assert(data.raw.kind == .differentiabilityParamsClause) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, + wrtLabel: TokenSyntax = .identifier("wrt"), + _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ 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(), (unexpectedBeforeWrtLabel, wrtLabel, unexpectedBetweenWrtLabelAndColon, colon, unexpectedBetweenColonAndParameters, parameters, unexpectedAfterParameters))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeWrtLabel?.raw, + wrtLabel.raw, + unexpectedBetweenWrtLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndParameters?.raw, + parameters.raw, + unexpectedAfterParameters?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.differentiabilityParamsClause, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPeriodAndAccessorKind(value) + self = withUnexpectedBeforeWrtLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPeriodAndAccessorKind` replaced. - /// - param newChild: The new `unexpectedBetweenPeriodAndAccessorKind` to replace the node's - /// current `unexpectedBetweenPeriodAndAccessorKind`, if present. - public func withUnexpectedBetweenPeriodAndAccessorKind(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeWrtLabel` replaced. + /// - param newChild: The new `unexpectedBeforeWrtLabel` to replace the node's + /// current `unexpectedBeforeWrtLabel`, if present. + public func withUnexpectedBeforeWrtLabel(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - /// The accessor name. - public var accessorKind: TokenSyntax? { + /// The "wrt" label. + public var wrtLabel: TokenSyntax { get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withAccessorKind(value) + self = withWrtLabel(value) } } - /// Returns a copy of the receiver with its `accessorKind` replaced. - /// - param newChild: The new `accessorKind` to replace the node's - /// current `accessorKind`, if present. - public func withAccessorKind(_ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `wrtLabel` replaced. + /// - param newChild: The new `wrtLabel` to replace the node's + /// current `wrtLabel`, if present. + public func withWrtLabel(_ newChild: TokenSyntax) -> DifferentiabilityParamsClauseSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - public var unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAccessorKindAndComma(value) + self = withUnexpectedBetweenWrtLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAccessorKindAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenAccessorKindAndComma` to replace the node's - /// current `unexpectedBetweenAccessorKindAndComma`, if present. - public func withUnexpectedBetweenAccessorKindAndComma(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenWrtLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenWrtLabelAndColon` to replace the node's + /// current `unexpectedBetweenWrtLabelAndColon`, if present. + public func withUnexpectedBetweenWrtLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - public var comma: TokenSyntax? { + /// + /// The colon separating "wrt" and the parameter list. + /// + public var colon: TokenSyntax { get { - let childData = data.child(at: 11, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withComma(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `comma` replaced. - /// - param newChild: The new `comma` to replace the node's - /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> DifferentiabilityParamsClauseSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 11, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - public var unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 12, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndDiffParams(value) + self = withUnexpectedBetweenColonAndParameters(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndDiffParams` replaced. - /// - param newChild: The new `unexpectedBetweenCommaAndDiffParams` to replace the node's - /// current `unexpectedBetweenCommaAndDiffParams`, if present. - public func withUnexpectedBetweenCommaAndDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndParameters` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndParameters` to replace the node's + /// current `unexpectedBetweenColonAndParameters`, if present. + public func withUnexpectedBetweenColonAndParameters(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 12, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - public var diffParams: DifferentiabilityParamsClauseSyntax? { + public var parameters: Parameters { get { - let childData = data.child(at: 13, parent: Syntax(self)) - if childData == nil { return nil } - return DifferentiabilityParamsClauseSyntax(childData!) + let childData = data.child(at: 5, parent: Syntax(self)) + return Parameters(childData!) } set(value) { - self = withDiffParams(value) + self = withParameters(value) } } - /// Returns a copy of the receiver with its `diffParams` replaced. - /// - param newChild: The new `diffParams` to replace the node's - /// current `diffParams`, if present. - public func withDiffParams(_ newChild: DifferentiabilityParamsClauseSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `parameters` replaced. + /// - param newChild: The new `parameters` to replace the node's + /// current `parameters`, if present. + public func withParameters(_ newChild: Parameters) -> DifferentiabilityParamsClauseSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 13, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - public var unexpectedAfterDiffParams: UnexpectedNodesSyntax? { + public var unexpectedAfterParameters: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 14, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterDiffParams(value) + self = withUnexpectedAfterParameters(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterDiffParams` replaced. - /// - param newChild: The new `unexpectedAfterDiffParams` to replace the node's - /// current `unexpectedAfterDiffParams`, if present. - public func withUnexpectedAfterDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterParameters` replaced. + /// - param newChild: The new `unexpectedAfterParameters` to replace the node's + /// current `unexpectedAfterParameters`, if present. + public func withUnexpectedAfterParameters(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 14, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeOfLabel, - \Self.ofLabel, - \Self.unexpectedBetweenOfLabelAndColon, + \Self.unexpectedBeforeWrtLabel, + \Self.wrtLabel, + \Self.unexpectedBetweenWrtLabelAndColon, \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.unexpectedBetweenColonAndParameters, + \Self.parameters, + \Self.unexpectedAfterParameters, ]) } @@ -15638,357 +15722,252 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy case 4: return nil case 5: - return nil + return "parameters" 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 DifferentiabilityParamsClauseSyntax: 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, + "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), - "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, + "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: - QualifiedDeclNameSyntax +// MARK: - DifferentiabilityParamsSyntax -/// -/// An optionally qualified function declaration name (e.g. `+(_:_:)`, -/// `A.B.C.foo(_:_:)`). -/// -public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { +/// The differentiability parameters. +public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .qualifiedDeclName else { return nil } + guard node.raw.kind == .differentiabilityParams else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `QualifiedDeclNameSyntax` 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) { - assert(data.raw.kind == .qualifiedDeclName) + assert(data.raw.kind == .differentiabilityParams) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, - baseType: B? = nil, - _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax? = nil, - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, - arguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterArguments: 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(), (unexpectedBeforeBaseType, baseType, unexpectedBetweenBaseTypeAndDot, dot, unexpectedBetweenDotAndName, name, unexpectedBetweenNameAndArguments, arguments, unexpectedAfterArguments))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeBaseType?.raw, - baseType?.raw, - unexpectedBetweenBaseTypeAndDot?.raw, - dot?.raw, - unexpectedBetweenDotAndName?.raw, - name.raw, - unexpectedBetweenNameAndArguments?.raw, - arguments?.raw, - unexpectedAfterArguments?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.qualifiedDeclName, 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, - _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, - baseType: MissingTypeSyntax? = nil, - _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax? = nil, - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, - arguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeBaseType, - baseType: Optional.none, - unexpectedBetweenBaseTypeAndDot, - dot: dot, - unexpectedBetweenDotAndName, - name: name, - unexpectedBetweenNameAndArguments, - arguments: arguments, - unexpectedAfterArguments, - trailingTrivia: trailingTrivia - ) + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndDiffParams?.raw, + diffParams.raw, + unexpectedBetweenDiffParamsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.differentiabilityParams, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) } - public var unexpectedBeforeBaseType: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeBaseType(value) + self = withUnexpectedBeforeLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeBaseType` replaced. - /// - param newChild: The new `unexpectedBeforeBaseType` to replace the node's - /// current `unexpectedBeforeBaseType`, if present. - public func withUnexpectedBeforeBaseType(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. + /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's + /// current `unexpectedBeforeLeftParen`, if present. + public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - /// - /// The base type of the qualified name, optionally specified. - /// - public var baseType: TypeSyntax? { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } - return TypeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withBaseType(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `baseType` replaced. - /// - param newChild: The new `baseType` to replace the node's - /// current `baseType`, if present. - public func withBaseType(_ newChild: TypeSyntax?) -> QualifiedDeclNameSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> DifferentiabilityParamsSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenBaseTypeAndDot(value) + self = withUnexpectedBetweenLeftParenAndDiffParams(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenBaseTypeAndDot` replaced. - /// - param newChild: The new `unexpectedBetweenBaseTypeAndDot` to replace the node's - /// current `unexpectedBetweenBaseTypeAndDot`, if present. - public func withUnexpectedBetweenBaseTypeAndDot(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndDiffParams` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndDiffParams` to replace the node's + /// current `unexpectedBetweenLeftParenAndDiffParams`, if present. + public func withUnexpectedBetweenLeftParenAndDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - public var dot: TokenSyntax? { + /// The parameters for differentiation. + public var diffParams: DifferentiabilityParamListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return DifferentiabilityParamListSyntax(childData!) } set(value) { - self = withDot(value) + self = withDiffParams(value) } } - /// Returns a copy of the receiver with its `dot` replaced. - /// - param newChild: The new `dot` to replace the node's - /// current `dot`, if present. - public func withDot(_ newChild: TokenSyntax?) -> QualifiedDeclNameSyntax { + /// 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() - let raw = newChild?.raw + 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) + } + + /// Returns a copy of the receiver with its `diffParams` replaced. + /// - param newChild: The new `diffParams` to replace the node's + /// current `diffParams`, if present. + public func withDiffParams(_ newChild: DifferentiabilityParamListSyntax) -> DifferentiabilityParamsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDotAndName(value) + self = withUnexpectedBetweenDiffParamsAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDotAndName` replaced. - /// - param newChild: The new `unexpectedBetweenDotAndName` to replace the node's - /// current `unexpectedBetweenDotAndName`, if present. - public func withUnexpectedBetweenDotAndName(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDiffParamsAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenDiffParamsAndRightParen` to replace the node's + /// current `unexpectedBetweenDiffParamsAndRightParen`, if present. + public func withUnexpectedBetweenDiffParamsAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - /// - /// The base name of the referenced function. - /// - public var name: TokenSyntax { + public var rightParen: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withRightParen(value) } } - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax) -> QualifiedDeclNameSyntax { + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> DifferentiabilityParamsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndArguments(value) + self = withUnexpectedAfterRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndArguments` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndArguments` to replace the node's - /// current `unexpectedBetweenNameAndArguments`, if present. - public func withUnexpectedBetweenNameAndArguments(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) - } - - /// - /// The argument labels of the referenced function, optionally - /// specified. - /// - public var arguments: DeclNameArgumentsSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) - } - set(value) { - self = withArguments(value) - } - } - - /// Returns a copy of the receiver with its `arguments` replaced. - /// - param newChild: The new `arguments` to replace the node's - /// current `arguments`, if present. - public func withArguments(_ newChild: DeclNameArgumentsSyntax?) -> QualifiedDeclNameSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) - } - - public var unexpectedAfterArguments: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterArguments(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterArguments` replaced. - /// - param newChild: The new `unexpectedAfterArguments` to replace the node's - /// current `unexpectedAfterArguments`, if present. - public func withUnexpectedAfterArguments(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeBaseType, - \Self.baseType, - \Self.unexpectedBetweenBaseTypeAndDot, - \Self.dot, - \Self.unexpectedBetweenDotAndName, - \Self.name, - \Self.unexpectedBetweenNameAndArguments, - \Self.arguments, - \Self.unexpectedAfterArguments, + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDiffParams, + \Self.diffParams, + \Self.unexpectedBetweenDiffParamsAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -15997,7 +15976,7 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "base type" + return nil case 2: return nil case 3: @@ -16005,12 +15984,8 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return "base name" - case 6: return nil - case 7: - return "arguments" - case 8: + case 6: return nil default: fatalError("Invalid index") @@ -16018,254 +15993,180 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { } } -extension QualifiedDeclNameSyntax: CustomReflectable { +extension DifferentiabilityParamsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeBaseType": unexpectedBeforeBaseType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "baseType": baseType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenBaseTypeAndDot": unexpectedBetweenBaseTypeAndDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "dot": dot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenDotAndName": unexpectedBetweenDotAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenNameAndArguments": unexpectedBetweenNameAndArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "arguments": arguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterArguments": unexpectedAfterArguments.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: - BackDeployAttributeSpecListSyntax +// MARK: - DifferentiabilityParamSyntax /// -/// A collection of arguments for the `@_backDeploy` attribute +/// A differentiability parameter: either the "self" identifier, a function +/// parameter name, or a function parameter index. /// -public struct BackDeployAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashable { +public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .backDeployAttributeSpecList else { return nil } + guard node.raw.kind == .differentiabilityParam else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `BackDeployAttributeSpecListSyntax` 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) { - assert(data.raw.kind == .backDeployAttributeSpecList) + assert(data.raw.kind == .differentiabilityParam) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, - beforeLabel: TokenSyntax = .identifier("before"), - _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, - versionList: AvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterVersionList: 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(), (unexpectedBeforeBeforeLabel, beforeLabel, unexpectedBetweenBeforeLabelAndColon, colon, unexpectedBetweenColonAndVersionList, versionList, unexpectedAfterVersionList))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeParameter, parameter, unexpectedBetweenParameterAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeBeforeLabel?.raw, - beforeLabel.raw, - unexpectedBetweenBeforeLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndVersionList?.raw, - versionList.raw, - unexpectedAfterVersionList?.raw, + unexpectedBeforeParameter?.raw, + parameter.raw, + unexpectedBetweenParameterAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.backDeployAttributeSpecList, from: layout, arena: arena, + kind: SyntaxKind.differentiabilityParam, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeParameter: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeBeforeLabel(value) + self = withUnexpectedBeforeParameter(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeBeforeLabel` replaced. - /// - param newChild: The new `unexpectedBeforeBeforeLabel` to replace the node's - /// current `unexpectedBeforeBeforeLabel`, if present. - public func withUnexpectedBeforeBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeParameter` replaced. + /// - param newChild: The new `unexpectedBeforeParameter` to replace the node's + /// current `unexpectedBeforeParameter`, if present. + public func withUnexpectedBeforeParameter(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) + return DifferentiabilityParamSyntax(newData) } - /// The "before" label. - public var beforeLabel: TokenSyntax { + public var parameter: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withBeforeLabel(value) + self = withParameter(value) } } - /// Returns a copy of the receiver with its `beforeLabel` replaced. - /// - param newChild: The new `beforeLabel` to replace the node's - /// current `beforeLabel`, if present. - public func withBeforeLabel(_ newChild: TokenSyntax) -> BackDeployAttributeSpecListSyntax { + /// Returns a copy of the receiver with its `parameter` replaced. + /// - param newChild: The new `parameter` to replace the node's + /// current `parameter`, if present. + public func withParameter(_ newChild: TokenSyntax) -> DifferentiabilityParamSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) + return DifferentiabilityParamSyntax(newData) } - public var unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenBeforeLabelAndColon(value) + self = withUnexpectedBetweenParameterAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenBeforeLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenBeforeLabelAndColon` to replace the node's - /// current `unexpectedBetweenBeforeLabelAndColon`, if present. - public func withUnexpectedBetweenBeforeLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenParameterAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenParameterAndTrailingComma` to replace the node's + /// current `unexpectedBetweenParameterAndTrailingComma`, if present. + public func withUnexpectedBetweenParameterAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) + return DifferentiabilityParamSyntax(newData) } - /// - /// The colon separating "before" and the parameter list. - /// - public var colon: TokenSyntax { + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> BackDeployAttributeSpecListSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> DifferentiabilityParamSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) + return DifferentiabilityParamSyntax(newData) } - public var unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndVersionList(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndVersionList` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndVersionList` to replace the node's - /// current `unexpectedBetweenColonAndVersionList`, if present. - public func withUnexpectedBetweenColonAndVersionList(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DifferentiabilityParamSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) - } - - /// - /// The list of OS versions in which the declaration became ABI - /// stable. - /// - public var versionList: AvailabilityVersionRestrictionListSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return AvailabilityVersionRestrictionListSyntax(childData!) - } - set(value) { - self = withVersionList(value) - } - } - - /// Adds the provided `Availability` to the node's `versionList` - /// collection. - /// - param element: The new `Availability` to add to the node's - /// `versionList` collection. - /// - returns: A copy of the receiver with the provided `Availability` - /// appended to its `versionList` collection. - public func addAvailability(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> BackDeployAttributeSpecListSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[5] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) - } - - /// Returns a copy of the receiver with its `versionList` replaced. - /// - param newChild: The new `versionList` to replace the node's - /// current `versionList`, if present. - public func withVersionList(_ newChild: AvailabilityVersionRestrictionListSyntax) -> BackDeployAttributeSpecListSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) - } - - public var unexpectedAfterVersionList: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterVersionList(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterVersionList` replaced. - /// - param newChild: The new `unexpectedAfterVersionList` to replace the node's - /// current `unexpectedAfterVersionList`, if present. - public func withUnexpectedAfterVersionList(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) + return DifferentiabilityParamSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeBeforeLabel, - \Self.beforeLabel, - \Self.unexpectedBetweenBeforeLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndVersionList, - \Self.versionList, - \Self.unexpectedAfterVersionList, + \Self.unexpectedBeforeParameter, + \Self.parameter, + \Self.unexpectedBetweenParameterAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -16281,344 +16182,337 @@ public struct BackDeployAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashable return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension BackDeployAttributeSpecListSyntax: CustomReflectable { +extension DifferentiabilityParamSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeBeforeLabel": unexpectedBeforeBeforeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "beforeLabel": Syntax(beforeLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenBeforeLabelAndColon": unexpectedBetweenBeforeLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndVersionList": unexpectedBetweenColonAndVersionList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "versionList": Syntax(versionList).asProtocol(SyntaxProtocol.self), - "unexpectedAfterVersionList": unexpectedAfterVersionList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - AvailabilityVersionRestrictionListEntrySyntax +// MARK: - DerivativeRegistrationAttributeArgumentsSyntax /// -/// A single platform/version pair in an attribute, e.g. `iOS 10.1`. +/// 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 AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityVersionRestrictionListEntry else { return nil } + guard node.raw.kind == .derivativeRegistrationAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AvailabilityVersionRestrictionListEntrySyntax` 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) { - assert(data.raw.kind == .availabilityVersionRestrictionListEntry) + assert(data.raw.kind == .derivativeRegistrationAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? = nil, - availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax, - _ unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, + ofLabel: TokenSyntax = .identifier("of"), + _ unexpectedBetweenOfLabelAndColon: 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, 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(), (unexpectedBeforeAvailabilityVersionRestriction, availabilityVersionRestriction, unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeOfLabel, ofLabel, unexpectedBetweenOfLabelAndColon, colon, unexpectedBetweenColonAndOriginalDeclName, originalDeclName, unexpectedBetweenOriginalDeclNameAndPeriod, period, unexpectedBetweenPeriodAndAccessorKind, accessorKind, unexpectedBetweenAccessorKindAndComma, comma, unexpectedBetweenCommaAndDiffParams, diffParams, unexpectedAfterDiffParams))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAvailabilityVersionRestriction?.raw, - availabilityVersionRestriction.raw, - unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeOfLabel?.raw, + ofLabel.raw, + unexpectedBetweenOfLabelAndColon?.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.availabilityVersionRestrictionListEntry, from: layout, arena: arena, + kind: SyntaxKind.derivativeRegistrationAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? { + public var unexpectedBeforeOfLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeAvailabilityVersionRestriction(value) + self = withUnexpectedBeforeOfLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeAvailabilityVersionRestriction` replaced. - /// - param newChild: The new `unexpectedBeforeAvailabilityVersionRestriction` to replace the node's - /// current `unexpectedBeforeAvailabilityVersionRestriction`, if present. - public func withUnexpectedBeforeAvailabilityVersionRestriction(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeOfLabel` replaced. + /// - param newChild: The new `unexpectedBeforeOfLabel` to replace the node's + /// current `unexpectedBeforeOfLabel`, if present. + public func withUnexpectedBeforeOfLabel(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AvailabilityVersionRestrictionListEntrySyntax(newData) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public var availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax { + /// The "of" label. + public var ofLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return AvailabilityVersionRestrictionSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withAvailabilityVersionRestriction(value) + self = withOfLabel(value) } } - /// Returns a copy of the receiver with its `availabilityVersionRestriction` replaced. - /// - param newChild: The new `availabilityVersionRestriction` to replace the node's - /// current `availabilityVersionRestriction`, if present. - public func withAvailabilityVersionRestriction(_ newChild: AvailabilityVersionRestrictionSyntax) -> AvailabilityVersionRestrictionListEntrySyntax { + /// Returns a copy of the receiver with its `ofLabel` replaced. + /// - param newChild: The new `ofLabel` to replace the node's + /// current `ofLabel`, if present. + public func withOfLabel(_ newChild: TokenSyntax) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AvailabilityVersionRestrictionListEntrySyntax(newData) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma(value) + self = withUnexpectedBetweenOfLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma` to replace the node's - /// current `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma`, if present. - public func withUnexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenOfLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenOfLabelAndColon` to replace the node's + /// current `unexpectedBetweenOfLabelAndColon`, if present. + public func withUnexpectedBetweenOfLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AvailabilityVersionRestrictionListEntrySyntax(newData) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } /// - /// A trailing comma if the argument is followed by another - /// argument + /// The colon separating the "of" label and the original + /// declaration name. /// - public var trailingComma: TokenSyntax? { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AvailabilityVersionRestrictionListEntrySyntax(newData) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenColonAndOriginalDeclName(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndOriginalDeclName` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndOriginalDeclName` to replace the node's + /// current `unexpectedBetweenColonAndOriginalDeclName`, if present. + public func withUnexpectedBetweenColonAndOriginalDeclName(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AvailabilityVersionRestrictionListEntrySyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeAvailabilityVersionRestriction, - \Self.availabilityVersionRestriction, - \Self.unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, - ]) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - 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 { + let childData = data.child(at: 5, parent: Syntax(self)) + return QualifiedDeclNameSyntax(childData!) + } + set(value) { + self = withOriginalDeclName(value) } } -} -extension AvailabilityVersionRestrictionListEntrySyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeAvailabilityVersionRestriction": unexpectedBeforeAvailabilityVersionRestriction.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "availabilityVersionRestriction": Syntax(availabilityVersionRestriction).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma": unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma.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, - ]) + /// Returns a copy of the receiver with its `originalDeclName` replaced. + /// - param newChild: The new `originalDeclName` to replace the node's + /// current `originalDeclName`, if present. + public func withOriginalDeclName(_ newChild: QualifiedDeclNameSyntax) -> DerivativeRegistrationAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } -} - -// MARK: - OpaqueReturnTypeOfAttributeArgumentsSyntax -/// -/// The arguments for the '@_opaqueReturnTypeOf()'. -/// -public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { return nil } - self._syntaxNode = node._syntaxNode + public var unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenOriginalDeclNameAndPeriod(value) + } } - /// Creates a `OpaqueReturnTypeOfAttributeArgumentsSyntax` 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) { - assert(data.raw.kind == .opaqueReturnTypeOfAttributeArguments) - self._syntaxNode = Syntax(data) + /// Returns a copy of the receiver with its `unexpectedBetweenOriginalDeclNameAndPeriod` replaced. + /// - param newChild: The new `unexpectedBetweenOriginalDeclNameAndPeriod` to replace the node's + /// current `unexpectedBetweenOriginalDeclNameAndPeriod`, if present. + public func withUnexpectedBetweenOriginalDeclNameAndPeriod(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, - mangledName: TokenSyntax, - _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, - ordinal: TokenSyntax, - _ unexpectedAfterOrdinal: 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(), (unexpectedBeforeMangledName, mangledName, unexpectedBetweenMangledNameAndComma, comma, unexpectedBetweenCommaAndOrdinal, ordinal, unexpectedAfterOrdinal))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeMangledName?.raw, - mangledName.raw, - unexpectedBetweenMangledNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndOrdinal?.raw, - ordinal.raw, - unexpectedAfterOrdinal?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) + /// + /// The period separating the original declaration name and the + /// accessor name. + /// + public var period: TokenSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withPeriod(value) } - self.init(data) } - public var unexpectedBeforeMangledName: UnexpectedNodesSyntax? { + /// Returns a copy of the receiver with its `period` replaced. + /// - param newChild: The new `period` to replace the node's + /// current `period`, if present. + public func withPeriod(_ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) + } + + public var unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeMangledName(value) + self = withUnexpectedBetweenPeriodAndAccessorKind(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeMangledName` replaced. - /// - param newChild: The new `unexpectedBeforeMangledName` to replace the node's - /// current `unexpectedBeforeMangledName`, if present. - public func withUnexpectedBeforeMangledName(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPeriodAndAccessorKind` replaced. + /// - param newChild: The new `unexpectedBetweenPeriodAndAccessorKind` to replace the node's + /// current `unexpectedBetweenPeriodAndAccessorKind`, if present. + public func withUnexpectedBetweenPeriodAndAccessorKind(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - /// The mangled name of a declaration. - public var mangledName: TokenSyntax { + /// The accessor name. + public var accessorKind: TokenSyntax? { get { - let childData = data.child(at: 1, parent: Syntax(self)) + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withMangledName(value) + self = withAccessorKind(value) } } - /// Returns a copy of the receiver with its `mangledName` replaced. - /// - param newChild: The new `mangledName` to replace the node's - /// current `mangledName`, if present. - public func withMangledName(_ newChild: TokenSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `accessorKind` replaced. + /// - param newChild: The new `accessorKind` to replace the node's + /// current `accessorKind`, if present. + public func withAccessorKind(_ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenMangledNameAndComma(value) + self = withUnexpectedBetweenAccessorKindAndComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenMangledNameAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenMangledNameAndComma` to replace the node's - /// current `unexpectedBetweenMangledNameAndComma`, if present. - public func withUnexpectedBetweenMangledNameAndComma(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAccessorKindAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenAccessorKindAndComma` to replace the node's + /// current `unexpectedBetweenAccessorKindAndComma`, if present. + public func withUnexpectedBetweenAccessorKindAndComma(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public var comma: TokenSyntax { + public var comma: TokenSyntax? { get { - let childData = data.child(at: 3, parent: Syntax(self)) + let childData = data.child(at: 11, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { @@ -16629,85 +16523,93 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax /// Returns a copy of the receiver with its `comma` replaced. /// - param newChild: The new `comma` to replace the node's /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + public func withComma(_ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 11, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 12, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndOrdinal(value) + self = withUnexpectedBetweenCommaAndDiffParams(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndOrdinal` replaced. - /// - param newChild: The new `unexpectedBetweenCommaAndOrdinal` to replace the node's - /// current `unexpectedBetweenCommaAndOrdinal`, if present. - public func withUnexpectedBetweenCommaAndOrdinal(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndDiffParams` replaced. + /// - param newChild: The new `unexpectedBetweenCommaAndDiffParams` to replace the node's + /// current `unexpectedBetweenCommaAndDiffParams`, if present. + public func withUnexpectedBetweenCommaAndDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 12, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - /// The ordinal corresponding to the 'some' keyword that introduced this opaque type. - public var ordinal: TokenSyntax { + public var diffParams: DifferentiabilityParamsClauseSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 13, parent: Syntax(self)) + if childData == nil { return nil } + return DifferentiabilityParamsClauseSyntax(childData!) } set(value) { - self = withOrdinal(value) + self = withDiffParams(value) } } - /// Returns a copy of the receiver with its `ordinal` replaced. - /// - param newChild: The new `ordinal` to replace the node's - /// current `ordinal`, if present. - public func withOrdinal(_ newChild: TokenSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `diffParams` replaced. + /// - param newChild: The new `diffParams` to replace the node's + /// current `diffParams`, if present. + public func withDiffParams(_ newChild: DifferentiabilityParamsClauseSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 13, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } - public var unexpectedAfterOrdinal: UnexpectedNodesSyntax? { + public var unexpectedAfterDiffParams: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 14, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterOrdinal(value) + self = withUnexpectedAfterDiffParams(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterOrdinal` replaced. - /// - param newChild: The new `unexpectedAfterOrdinal` to replace the node's - /// current `unexpectedAfterOrdinal`, if present. - public func withUnexpectedAfterOrdinal(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterDiffParams` replaced. + /// - param newChild: The new `unexpectedAfterDiffParams` to replace the node's + /// current `unexpectedAfterDiffParams`, if present. + public func withUnexpectedAfterDiffParams(_ newChild: UnexpectedNodesSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 14, with: raw, arena: arena) + return DerivativeRegistrationAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeMangledName, - \Self.mangledName, - \Self.unexpectedBetweenMangledNameAndComma, + \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.unexpectedBetweenCommaAndOrdinal, - \Self.ordinal, - \Self.unexpectedAfterOrdinal, + \Self.unexpectedBetweenCommaAndDiffParams, + \Self.diffParams, + \Self.unexpectedAfterDiffParams, ]) } @@ -16727,330 +16629,354 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax 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 OpaqueReturnTypeOfAttributeArgumentsSyntax: CustomReflectable { +extension DerivativeRegistrationAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeMangledName": unexpectedBeforeMangledName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "mangledName": Syntax(mangledName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenMangledNameAndComma": unexpectedBetweenMangledNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCommaAndOrdinal": unexpectedBetweenCommaAndOrdinal.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "ordinal": Syntax(ordinal).asProtocol(SyntaxProtocol.self), - "unexpectedAfterOrdinal": unexpectedAfterOrdinal.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - ConventionAttributeArgumentsSyntax +// MARK: - QualifiedDeclNameSyntax /// -/// The arguments for the '@convention(...)'. +/// An optionally qualified function declaration name (e.g. `+(_:_:)`, +/// `A.B.C.foo(_:_:)`). /// -public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionAttributeArguments else { return nil } + guard node.raw.kind == .qualifiedDeclName else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConventionAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `QualifiedDeclNameSyntax` 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) { - assert(data.raw.kind == .conventionAttributeArguments) + assert(data.raw.kind == .qualifiedDeclName) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? = nil, - conventionLabel: TokenSyntax, - _ unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? = nil, - cTypeLabel: TokenSyntax? = nil, - _ unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? = nil, - cTypeString: TokenSyntax? = nil, - _ unexpectedAfterCTypeString: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, + baseType: B? = nil, + _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax? = nil, + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeConventionLabel, conventionLabel, unexpectedBetweenConventionLabelAndComma, comma, unexpectedBetweenCommaAndCTypeLabel, cTypeLabel, unexpectedBetweenCTypeLabelAndColon, colon, unexpectedBetweenColonAndCTypeString, cTypeString, unexpectedAfterCTypeString))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBaseType, baseType, unexpectedBetweenBaseTypeAndDot, dot, unexpectedBetweenDotAndName, name, unexpectedBetweenNameAndArguments, arguments, unexpectedAfterArguments))) { (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, + unexpectedBeforeBaseType?.raw, + baseType?.raw, + unexpectedBetweenBaseTypeAndDot?.raw, + dot?.raw, + unexpectedBetweenDotAndName?.raw, + name.raw, + unexpectedBetweenNameAndArguments?.raw, + arguments?.raw, + unexpectedAfterArguments?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.qualifiedDeclName, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? { + /// 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, + _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, + baseType: MissingTypeSyntax? = nil, + _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax? = nil, + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeBaseType, + baseType: Optional.none, + unexpectedBetweenBaseTypeAndDot, + dot: dot, + unexpectedBetweenDotAndName, + name: name, + unexpectedBetweenNameAndArguments, + arguments: arguments, + unexpectedAfterArguments, + trailingTrivia: trailingTrivia + ) + } + + public var unexpectedBeforeBaseType: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeConventionLabel(value) + self = withUnexpectedBeforeBaseType(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeConventionLabel` replaced. - /// - param newChild: The new `unexpectedBeforeConventionLabel` to replace the node's - /// current `unexpectedBeforeConventionLabel`, if present. - public func withUnexpectedBeforeConventionLabel(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeBaseType` replaced. + /// - param newChild: The new `unexpectedBeforeBaseType` to replace the node's + /// current `unexpectedBeforeBaseType`, if present. + public func withUnexpectedBeforeBaseType(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - /// The convention label. - public var conventionLabel: TokenSyntax { + /// + /// The base type of the qualified name, optionally specified. + /// + public var baseType: TypeSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return TypeSyntax(childData!) } set(value) { - self = withConventionLabel(value) + self = withBaseType(value) } } - /// Returns a copy of the receiver with its `conventionLabel` replaced. - /// - param newChild: The new `conventionLabel` to replace the node's - /// current `conventionLabel`, if present. - public func withConventionLabel(_ newChild: TokenSyntax) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `baseType` replaced. + /// - param newChild: The new `baseType` to replace the node's + /// current `baseType`, if present. + public func withBaseType(_ newChild: TypeSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - public var unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenConventionLabelAndComma(value) + self = withUnexpectedBetweenBaseTypeAndDot(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenConventionLabelAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenConventionLabelAndComma` to replace the node's - /// current `unexpectedBetweenConventionLabelAndComma`, if present. - public func withUnexpectedBetweenConventionLabelAndComma(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenBaseTypeAndDot` replaced. + /// - param newChild: The new `unexpectedBetweenBaseTypeAndDot` to replace the node's + /// current `unexpectedBetweenBaseTypeAndDot`, if present. + public func withUnexpectedBetweenBaseTypeAndDot(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - public var comma: TokenSyntax? { + public var dot: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withComma(value) + self = withDot(value) } } - /// Returns a copy of the receiver with its `comma` replaced. - /// - param newChild: The new `comma` to replace the node's - /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `dot` replaced. + /// - param newChild: The new `dot` to replace the node's + /// current `dot`, if present. + public func withDot(_ newChild: TokenSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - public var unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? { + public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndCTypeLabel(value) + self = withUnexpectedBetweenDotAndName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndCTypeLabel` replaced. - /// - param newChild: The new `unexpectedBetweenCommaAndCTypeLabel` to replace the node's - /// current `unexpectedBetweenCommaAndCTypeLabel`, if present. - public func withUnexpectedBetweenCommaAndCTypeLabel(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDotAndName` replaced. + /// - param newChild: The new `unexpectedBetweenDotAndName` to replace the node's + /// current `unexpectedBetweenDotAndName`, if present. + public func withUnexpectedBetweenDotAndName(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - public var cTypeLabel: TokenSyntax? { + /// + /// The base name of the referenced function. + /// + public var name: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withCTypeLabel(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `cTypeLabel` replaced. - /// - param newChild: The new `cTypeLabel` to replace the node's - /// current `cTypeLabel`, if present. - public func withCTypeLabel(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - public var unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCTypeLabelAndColon(value) + self = withUnexpectedBetweenNameAndArguments(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCTypeLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenCTypeLabelAndColon` to replace the node's - /// current `unexpectedBetweenCTypeLabelAndColon`, if present. - public func withUnexpectedBetweenCTypeLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndArguments` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndArguments` to replace the node's + /// current `unexpectedBetweenNameAndArguments`, if present. + public func withUnexpectedBetweenNameAndArguments(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - public var colon: TokenSyntax? { + /// + /// The argument labels of the referenced function, optionally + /// specified. + /// + public var arguments: DeclNameArgumentsSyntax? { get { let childData = data.child(at: 7, parent: Syntax(self)) if childData == nil { return nil } - return TokenSyntax(childData!) + return DeclNameArgumentsSyntax(childData!) } set(value) { - self = withColon(value) + self = withArguments(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `arguments` replaced. + /// - param newChild: The new `arguments` to replace the node's + /// current `arguments`, if present. + public func withArguments(_ newChild: DeclNameArgumentsSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } - public var unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? { + public var unexpectedAfterArguments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndCTypeString(value) + self = withUnexpectedAfterArguments(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndCTypeString` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndCTypeString` to replace the node's - /// current `unexpectedBetweenColonAndCTypeString`, if present. - public func withUnexpectedBetweenColonAndCTypeString(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterArguments` replaced. + /// - param newChild: The new `unexpectedAfterArguments` to replace the node's + /// current `unexpectedAfterArguments`, if present. + public func withUnexpectedAfterArguments(_ newChild: UnexpectedNodesSyntax?) -> QualifiedDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) - } - - public var cTypeString: TokenSyntax? { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withCTypeString(value) - } - } - - /// Returns a copy of the receiver with its `cTypeString` replaced. - /// - param newChild: The new `cTypeString` to replace the node's - /// current `cTypeString`, if present. - public func withCTypeString(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) - } - - public var unexpectedAfterCTypeString: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 10, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterCTypeString(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterCTypeString` replaced. - /// - param newChild: The new `unexpectedAfterCTypeString` to replace the node's - /// current `unexpectedAfterCTypeString`, if present. - public func withUnexpectedAfterCTypeString(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + return QualifiedDeclNameSyntax(newData) } 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.unexpectedBeforeBaseType, + \Self.baseType, + \Self.unexpectedBetweenBaseTypeAndDot, + \Self.dot, + \Self.unexpectedBetweenDotAndName, + \Self.name, + \Self.unexpectedBetweenNameAndArguments, + \Self.arguments, + \Self.unexpectedAfterArguments, ]) } @@ -17059,7 +16985,7 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 0: return nil case 1: - return nil + return "base type" case 2: return nil case 3: @@ -17067,155 +16993,153 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 4: return nil case 5: - return nil + return "base name" case 6: return nil case 7: - return nil + return "arguments" case 8: return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension ConventionAttributeArgumentsSyntax: CustomReflectable { +extension QualifiedDeclNameSyntax: 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, + "unexpectedBeforeBaseType": unexpectedBeforeBaseType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "baseType": baseType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenBaseTypeAndDot": unexpectedBetweenBaseTypeAndDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "dot": dot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenDotAndName": unexpectedBetweenDotAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenNameAndArguments": unexpectedBetweenNameAndArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "arguments": arguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterArguments": unexpectedAfterArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ConventionWitnessMethodAttributeArgumentsSyntax +// MARK: - BackDeployAttributeSpecListSyntax /// -/// The arguments for the '@convention(witness_method: ...)'. +/// A collection of arguments for the `@_backDeploy` attribute /// -public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct BackDeployAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { return nil } + guard node.raw.kind == .backDeployAttributeSpecList else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConventionWitnessMethodAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `BackDeployAttributeSpecListSyntax` 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) { - assert(data.raw.kind == .conventionWitnessMethodAttributeArguments) + assert(data.raw.kind == .backDeployAttributeSpecList) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, - witnessMethodLabel: TokenSyntax, - _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, + beforeLabel: TokenSyntax = .identifier("before"), + _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, - protocolName: TokenSyntax, - _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, + versionList: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterVersionList: 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))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBeforeLabel, beforeLabel, unexpectedBetweenBeforeLabelAndColon, colon, unexpectedBetweenColonAndVersionList, versionList, unexpectedAfterVersionList))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWitnessMethodLabel?.raw, - witnessMethodLabel.raw, - unexpectedBetweenWitnessMethodLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndProtocolName?.raw, - protocolName.raw, - unexpectedAfterProtocolName?.raw, + unexpectedBeforeBeforeLabel?.raw, + beforeLabel.raw, + unexpectedBetweenBeforeLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndVersionList?.raw, + versionList.raw, + unexpectedAfterVersionList?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionWitnessMethodAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.backDeployAttributeSpecList, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeWitnessMethodLabel(value) + self = withUnexpectedBeforeBeforeLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeWitnessMethodLabel` replaced. - /// - param newChild: The new `unexpectedBeforeWitnessMethodLabel` to replace the node's - /// current `unexpectedBeforeWitnessMethodLabel`, if present. - public func withUnexpectedBeforeWitnessMethodLabel(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeBeforeLabel` replaced. + /// - param newChild: The new `unexpectedBeforeBeforeLabel` to replace the node's + /// current `unexpectedBeforeBeforeLabel`, if present. + public func withUnexpectedBeforeBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var witnessMethodLabel: TokenSyntax { + /// The "before" label. + public var beforeLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withWitnessMethodLabel(value) + self = withBeforeLabel(value) } } - /// Returns a copy of the receiver with its `witnessMethodLabel` replaced. - /// - param newChild: The new `witnessMethodLabel` to replace the node's - /// current `witnessMethodLabel`, if present. - public func withWitnessMethodLabel(_ newChild: TokenSyntax) -> ConventionWitnessMethodAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `beforeLabel` replaced. + /// - param newChild: The new `beforeLabel` to replace the node's + /// current `beforeLabel`, if present. + public func withBeforeLabel(_ newChild: TokenSyntax) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenWitnessMethodLabelAndColon(value) + self = withUnexpectedBetweenBeforeLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenWitnessMethodLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenWitnessMethodLabelAndColon` to replace the node's - /// current `unexpectedBetweenWitnessMethodLabelAndColon`, if present. - public func withUnexpectedBetweenWitnessMethodLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenBeforeLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenBeforeLabelAndColon` to replace the node's + /// current `unexpectedBetweenBeforeLabelAndColon`, if present. + public func withUnexpectedBetweenBeforeLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } + /// + /// The colon separating "before" and the parameter list. + /// public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) @@ -17229,84 +17153,107 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S /// Returns a copy of the receiver with its `colon` replaced. /// - param newChild: The new `colon` to replace the node's /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> ConventionWitnessMethodAttributeArgumentsSyntax { + public func withColon(_ newChild: TokenSyntax) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndProtocolName(value) + self = withUnexpectedBetweenColonAndVersionList(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndProtocolName` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndProtocolName` to replace the node's - /// current `unexpectedBetweenColonAndProtocolName`, if present. - public func withUnexpectedBetweenColonAndProtocolName(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndVersionList` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndVersionList` to replace the node's + /// current `unexpectedBetweenColonAndVersionList`, if present. + public func withUnexpectedBetweenColonAndVersionList(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var protocolName: TokenSyntax { + /// + /// The list of OS versions in which the declaration became ABI + /// stable. + /// + public var versionList: AvailabilityVersionRestrictionListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + return AvailabilityVersionRestrictionListSyntax(childData!) } set(value) { - self = withProtocolName(value) + self = withVersionList(value) } } - /// Returns a copy of the receiver with its `protocolName` replaced. - /// - param newChild: The new `protocolName` to replace the node's - /// current `protocolName`, if present. - public func withProtocolName(_ newChild: TokenSyntax) -> ConventionWitnessMethodAttributeArgumentsSyntax { + /// Adds the provided `Availability` to the node's `versionList` + /// collection. + /// - param element: The new `Availability` to add to the node's + /// `versionList` collection. + /// - returns: A copy of the receiver with the provided `Availability` + /// appended to its `versionList` collection. + public func addAvailability(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> BackDeployAttributeSpecListSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return BackDeployAttributeSpecListSyntax(newData) + } + + /// Returns a copy of the receiver with its `versionList` replaced. + /// - param newChild: The new `versionList` to replace the node's + /// current `versionList`, if present. + public func withVersionList(_ newChild: AvailabilityVersionRestrictionListSyntax) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var unexpectedAfterProtocolName: UnexpectedNodesSyntax? { + public var unexpectedAfterVersionList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterProtocolName(value) + self = withUnexpectedAfterVersionList(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterProtocolName` replaced. - /// - param newChild: The new `unexpectedAfterProtocolName` to replace the node's - /// current `unexpectedAfterProtocolName`, if present. - public func withUnexpectedAfterProtocolName(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterVersionList` replaced. + /// - param newChild: The new `unexpectedAfterVersionList` to replace the node's + /// current `unexpectedAfterVersionList`, if present. + public func withUnexpectedAfterVersionList(_ newChild: UnexpectedNodesSyntax?) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWitnessMethodLabel, - \Self.witnessMethodLabel, - \Self.unexpectedBetweenWitnessMethodLabelAndColon, + \Self.unexpectedBeforeBeforeLabel, + \Self.beforeLabel, + \Self.unexpectedBetweenBeforeLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndProtocolName, - \Self.protocolName, - \Self.unexpectedAfterProtocolName, + \Self.unexpectedBetweenColonAndVersionList, + \Self.versionList, + \Self.unexpectedAfterVersionList, ]) } @@ -17332,227 +17279,183 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S } } -extension ConventionWitnessMethodAttributeArgumentsSyntax: CustomReflectable { +extension BackDeployAttributeSpecListSyntax: 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, + "unexpectedBeforeBeforeLabel": unexpectedBeforeBeforeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "beforeLabel": Syntax(beforeLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenBeforeLabelAndColon": unexpectedBetweenBeforeLabelAndColon.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, + "unexpectedBetweenColonAndVersionList": unexpectedBetweenColonAndVersionList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "versionList": Syntax(versionList).asProtocol(SyntaxProtocol.self), + "unexpectedAfterVersionList": unexpectedAfterVersionList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ExposeAttributeArgumentsSyntax +// MARK: - AvailabilityVersionRestrictionListEntrySyntax /// -/// The arguments for the '@_expose' attribute +/// A single platform/version pair in an attribute, e.g. `iOS 10.1`. /// -public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .exposeAttributeArguments else { return nil } + guard node.raw.kind == .availabilityVersionRestrictionListEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ExposeAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AvailabilityVersionRestrictionListEntrySyntax` 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) { - assert(data.raw.kind == .exposeAttributeArguments) + assert(data.raw.kind == .availabilityVersionRestrictionListEntry) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLanguage: UnexpectedNodesSyntax? = nil, - language: TokenSyntax, - _ unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? = nil, - cxxName: TokenSyntax? = nil, - _ unexpectedAfterCxxName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? = nil, + availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax, + _ unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: 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(), (unexpectedBeforeLanguage, language, unexpectedBetweenLanguageAndComma, comma, unexpectedBetweenCommaAndCxxName, cxxName, unexpectedAfterCxxName))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAvailabilityVersionRestriction, availabilityVersionRestriction, unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLanguage?.raw, - language.raw, - unexpectedBetweenLanguageAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndCxxName?.raw, - cxxName?.raw, - unexpectedAfterCxxName?.raw, + unexpectedBeforeAvailabilityVersionRestriction?.raw, + availabilityVersionRestriction.raw, + unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.exposeAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.availabilityVersionRestrictionListEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLanguage: UnexpectedNodesSyntax? { + public var unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLanguage(value) + self = withUnexpectedBeforeAvailabilityVersionRestriction(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLanguage` replaced. - /// - param newChild: The new `unexpectedBeforeLanguage` to replace the node's - /// current `unexpectedBeforeLanguage`, if present. - public func withUnexpectedBeforeLanguage(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAvailabilityVersionRestriction` replaced. + /// - param newChild: The new `unexpectedBeforeAvailabilityVersionRestriction` to replace the node's + /// current `unexpectedBeforeAvailabilityVersionRestriction`, if present. + public func withUnexpectedBeforeAvailabilityVersionRestriction(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ExposeAttributeArgumentsSyntax(newData) + return AvailabilityVersionRestrictionListEntrySyntax(newData) } - public var language: TokenSyntax { + public var availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withLanguage(value) - } - } - - /// Returns a copy of the receiver with its `language` replaced. - /// - param newChild: The new `language` to replace the node's - /// current `language`, if present. - public func withLanguage(_ newChild: TokenSyntax) -> ExposeAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ExposeAttributeArgumentsSyntax(newData) - } - - public var unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLanguageAndComma(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLanguageAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenLanguageAndComma` to replace the node's - /// current `unexpectedBetweenLanguageAndComma`, if present. - public func withUnexpectedBetweenLanguageAndComma(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ExposeAttributeArgumentsSyntax(newData) - } - - public var comma: TokenSyntax? { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return AvailabilityVersionRestrictionSyntax(childData!) } set(value) { - self = withComma(value) + self = withAvailabilityVersionRestriction(value) } } - /// Returns a copy of the receiver with its `comma` replaced. - /// - param newChild: The new `comma` to replace the node's - /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax?) -> ExposeAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `availabilityVersionRestriction` replaced. + /// - param newChild: The new `availabilityVersionRestriction` to replace the node's + /// current `availabilityVersionRestriction`, if present. + public func withAvailabilityVersionRestriction(_ newChild: AvailabilityVersionRestrictionSyntax) -> AvailabilityVersionRestrictionListEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ExposeAttributeArgumentsSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return AvailabilityVersionRestrictionListEntrySyntax(newData) } - public var unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndCxxName(value) + self = withUnexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndCxxName` replaced. - /// - param newChild: The new `unexpectedBetweenCommaAndCxxName` to replace the node's - /// current `unexpectedBetweenCommaAndCxxName`, if present. - public func withUnexpectedBetweenCommaAndCxxName(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma` to replace the node's + /// current `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma`, if present. + public func withUnexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ExposeAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return AvailabilityVersionRestrictionListEntrySyntax(newData) } - public var cxxName: TokenSyntax? { + /// + /// A trailing comma if the argument is followed by another + /// argument + /// + public var trailingComma: TokenSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withCxxName(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `cxxName` replaced. - /// - param newChild: The new `cxxName` to replace the node's - /// current `cxxName`, if present. - public func withCxxName(_ newChild: TokenSyntax?) -> ExposeAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ExposeAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return AvailabilityVersionRestrictionListEntrySyntax(newData) } - public var unexpectedAfterCxxName: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterCxxName(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterCxxName` replaced. - /// - param newChild: The new `unexpectedAfterCxxName` to replace the node's - /// current `unexpectedAfterCxxName`, if present. - public func withUnexpectedAfterCxxName(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityVersionRestrictionListEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ExposeAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return AvailabilityVersionRestrictionListEntrySyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLanguage, - \Self.language, - \Self.unexpectedBetweenLanguageAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndCxxName, - \Self.cxxName, - \Self.unexpectedAfterCxxName, + \Self.unexpectedBeforeAvailabilityVersionRestriction, + \Self.availabilityVersionRestriction, + \Self.unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -17568,237 +17471,142 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension ExposeAttributeArgumentsSyntax: CustomReflectable { +extension AvailabilityVersionRestrictionListEntrySyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLanguage": unexpectedBeforeLanguage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "language": Syntax(language).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLanguageAndComma": unexpectedBetweenLanguageAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenCommaAndCxxName": unexpectedBetweenCommaAndCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "cxxName": cxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterCxxName": unexpectedAfterCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeAvailabilityVersionRestriction": unexpectedBeforeAvailabilityVersionRestriction.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "availabilityVersionRestriction": Syntax(availabilityVersionRestriction).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma": unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma.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: - OriginallyDefinedInArgumentsSyntax +// MARK: - OpaqueReturnTypeOfAttributeArgumentsSyntax /// -/// The arguments for the '@_originallyDefinedIn' attribute +/// The arguments for the '@_opaqueReturnTypeOf()'. /// -public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .originallyDefinedInArguments else { return nil } + guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OriginallyDefinedInArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `OpaqueReturnTypeOfAttributeArgumentsSyntax` 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) { - assert(data.raw.kind == .originallyDefinedInArguments) + assert(data.raw.kind == .opaqueReturnTypeOfAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? = nil, - moduleLabel: TokenSyntax = .identifier("module"), - _ unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? = nil, - moduleName: TokenSyntax, - _ unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, + mangledName: TokenSyntax, + _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? = nil, - platforms: AvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterPlatforms: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, + ordinal: TokenSyntax, + _ unexpectedAfterOrdinal: 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(), (unexpectedBeforeModuleLabel, moduleLabel, unexpectedBetweenModuleLabelAndColon, colon, unexpectedBetweenColonAndModuleName, moduleName, unexpectedBetweenModuleNameAndComma, comma, unexpectedBetweenCommaAndPlatforms, platforms, unexpectedAfterPlatforms))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeMangledName, mangledName, unexpectedBetweenMangledNameAndComma, comma, unexpectedBetweenCommaAndOrdinal, ordinal, unexpectedAfterOrdinal))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeModuleLabel?.raw, - moduleLabel.raw, - unexpectedBetweenModuleLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndModuleName?.raw, - moduleName.raw, - unexpectedBetweenModuleNameAndComma?.raw, + unexpectedBeforeMangledName?.raw, + mangledName.raw, + unexpectedBetweenMangledNameAndComma?.raw, comma.raw, - unexpectedBetweenCommaAndPlatforms?.raw, - platforms.raw, - unexpectedAfterPlatforms?.raw, + unexpectedBetweenCommaAndOrdinal?.raw, + ordinal.raw, + unexpectedAfterOrdinal?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.originallyDefinedInArguments, from: layout, arena: arena, + kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeMangledName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeModuleLabel(value) + self = withUnexpectedBeforeMangledName(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeModuleLabel` replaced. - /// - param newChild: The new `unexpectedBeforeModuleLabel` to replace the node's - /// current `unexpectedBeforeModuleLabel`, if present. - public func withUnexpectedBeforeModuleLabel(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeMangledName` replaced. + /// - param newChild: The new `unexpectedBeforeMangledName` to replace the node's + /// current `unexpectedBeforeMangledName`, if present. + public func withUnexpectedBeforeMangledName(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var moduleLabel: TokenSyntax { + /// The mangled name of a declaration. + public var mangledName: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withModuleLabel(value) - } - } - - /// Returns a copy of the receiver with its `moduleLabel` replaced. - /// - param newChild: The new `moduleLabel` to replace the node's - /// current `moduleLabel`, if present. - public func withModuleLabel(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) - } - - public var unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenModuleLabelAndColon(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenModuleLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenModuleLabelAndColon` to replace the node's - /// current `unexpectedBetweenModuleLabelAndColon`, if present. - public func withUnexpectedBetweenModuleLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) - } - - public var colon: TokenSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withColon(value) - } - } - - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) - } - - public var unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenColonAndModuleName(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndModuleName` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndModuleName` to replace the node's - /// current `unexpectedBetweenColonAndModuleName`, if present. - public func withUnexpectedBetweenColonAndModuleName(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) - } - - public var moduleName: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withModuleName(value) + self = withMangledName(value) } } - /// Returns a copy of the receiver with its `moduleName` replaced. - /// - param newChild: The new `moduleName` to replace the node's - /// current `moduleName`, if present. - public func withModuleName(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { + /// Returns a copy of the receiver with its `mangledName` replaced. + /// - param newChild: The new `mangledName` to replace the node's + /// current `mangledName`, if present. + public func withMangledName(_ newChild: TokenSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenModuleNameAndComma(value) + self = withUnexpectedBetweenMangledNameAndComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenModuleNameAndComma` replaced. - /// - param newChild: The new `unexpectedBetweenModuleNameAndComma` to replace the node's - /// current `unexpectedBetweenModuleNameAndComma`, if present. - public func withUnexpectedBetweenModuleNameAndComma(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenMangledNameAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenMangledNameAndComma` to replace the node's + /// current `unexpectedBetweenMangledNameAndComma`, if present. + public func withUnexpectedBetweenMangledNameAndComma(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } public var comma: TokenSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { @@ -17809,107 +17617,85 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable /// Returns a copy of the receiver with its `comma` replaced. /// - param newChild: The new `comma` to replace the node's /// current `comma`, if present. - public func withComma(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { + public func withComma(_ newChild: TokenSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndPlatforms(value) + self = withUnexpectedBetweenCommaAndOrdinal(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndPlatforms` replaced. - /// - param newChild: The new `unexpectedBetweenCommaAndPlatforms` to replace the node's - /// current `unexpectedBetweenCommaAndPlatforms`, if present. - public func withUnexpectedBetweenCommaAndPlatforms(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndOrdinal` replaced. + /// - param newChild: The new `unexpectedBetweenCommaAndOrdinal` to replace the node's + /// current `unexpectedBetweenCommaAndOrdinal`, if present. + public func withUnexpectedBetweenCommaAndOrdinal(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var platforms: AvailabilityVersionRestrictionListSyntax { + /// The ordinal corresponding to the 'some' keyword that introduced this opaque type. + public var ordinal: TokenSyntax { get { - let childData = data.child(at: 9, parent: Syntax(self)) - return AvailabilityVersionRestrictionListSyntax(childData!) + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) } set(value) { - self = withPlatforms(value) - } - } - - /// Adds the provided `Platform` to the node's `platforms` - /// collection. - /// - param element: The new `Platform` to add to the node's - /// `platforms` collection. - /// - returns: A copy of the receiver with the provided `Platform` - /// appended to its `platforms` collection. - public func addPlatform(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> OriginallyDefinedInArgumentsSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[9] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, - from: [element.raw], arena: arena) + self = withOrdinal(value) } - let newData = data.replacingChild(at: 9, with: collection, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) } - /// Returns a copy of the receiver with its `platforms` replaced. - /// - param newChild: The new `platforms` to replace the node's - /// current `platforms`, if present. - public func withPlatforms(_ newChild: AvailabilityVersionRestrictionListSyntax) -> OriginallyDefinedInArgumentsSyntax { + /// Returns a copy of the receiver with its `ordinal` replaced. + /// - param newChild: The new `ordinal` to replace the node's + /// current `ordinal`, if present. + public func withOrdinal(_ newChild: TokenSyntax) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var unexpectedAfterPlatforms: UnexpectedNodesSyntax? { + public var unexpectedAfterOrdinal: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPlatforms(value) + self = withUnexpectedAfterOrdinal(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPlatforms` replaced. - /// - param newChild: The new `unexpectedAfterPlatforms` to replace the node's - /// current `unexpectedAfterPlatforms`, if present. - public func withUnexpectedAfterPlatforms(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterOrdinal` replaced. + /// - param newChild: The new `unexpectedAfterOrdinal` to replace the node's + /// current `unexpectedAfterOrdinal`, if present. + public func withUnexpectedAfterOrdinal(_ newChild: UnexpectedNodesSyntax?) -> OpaqueReturnTypeOfAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeModuleLabel, - \Self.moduleLabel, - \Self.unexpectedBetweenModuleLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndModuleName, - \Self.moduleName, - \Self.unexpectedBetweenModuleNameAndComma, + \Self.unexpectedBeforeMangledName, + \Self.mangledName, + \Self.unexpectedBetweenMangledNameAndComma, \Self.comma, - \Self.unexpectedBetweenCommaAndPlatforms, - \Self.platforms, - \Self.unexpectedAfterPlatforms, + \Self.unexpectedBetweenCommaAndOrdinal, + \Self.ordinal, + \Self.unexpectedAfterOrdinal, ]) } @@ -17929,155 +17715,237 @@ public struct OriginallyDefinedInArgumentsSyntax: 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 OriginallyDefinedInArgumentsSyntax: CustomReflectable { +extension OpaqueReturnTypeOfAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeModuleLabel": unexpectedBeforeModuleLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "moduleLabel": Syntax(moduleLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenModuleLabelAndColon": unexpectedBetweenModuleLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndModuleName": unexpectedBetweenColonAndModuleName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "moduleName": Syntax(moduleName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenModuleNameAndComma": unexpectedBetweenModuleNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeMangledName": unexpectedBeforeMangledName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "mangledName": Syntax(mangledName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenMangledNameAndComma": unexpectedBetweenMangledNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCommaAndPlatforms": unexpectedBetweenCommaAndPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "platforms": Syntax(platforms).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPlatforms": unexpectedAfterPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenCommaAndOrdinal": unexpectedBetweenCommaAndOrdinal.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "ordinal": Syntax(ordinal).asProtocol(SyntaxProtocol.self), + "unexpectedAfterOrdinal": unexpectedAfterOrdinal.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - UnderscorePrivateAttributeArgumentsSyntax +// MARK: - ConventionAttributeArgumentsSyntax /// -/// The arguments for the '@_private' attribute +/// The arguments for the '@convention(...)'. /// -public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .underscorePrivateAttributeArguments else { return nil } + guard node.raw.kind == .conventionAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `UnderscorePrivateAttributeArgumentsSyntax` 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) { - assert(data.raw.kind == .underscorePrivateAttributeArguments) + assert(data.raw.kind == .conventionAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? = nil, - sourceFileLabel: TokenSyntax = .identifier("sourceFile"), - _ unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? = nil, - filename: TokenSyntax, - _ unexpectedAfterFilename: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? = nil, + conventionLabel: TokenSyntax, + _ unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? = nil, + cTypeLabel: TokenSyntax? = nil, + _ unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? = nil, + cTypeString: TokenSyntax? = 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(), (unexpectedBeforeSourceFileLabel, sourceFileLabel, unexpectedBetweenSourceFileLabelAndColon, colon, unexpectedBetweenColonAndFilename, filename, unexpectedAfterFilename))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeConventionLabel, conventionLabel, unexpectedBetweenConventionLabelAndComma, comma, unexpectedBetweenCommaAndCTypeLabel, cTypeLabel, unexpectedBetweenCTypeLabelAndColon, colon, unexpectedBetweenColonAndCTypeString, cTypeString, unexpectedAfterCTypeString))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSourceFileLabel?.raw, - sourceFileLabel.raw, - unexpectedBetweenSourceFileLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndFilename?.raw, - filename.raw, - unexpectedAfterFilename?.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.underscorePrivateAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.conventionAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } - self.init(data) + self.init(data) + } + + public var unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 0, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBeforeConventionLabel(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBeforeConventionLabel` replaced. + /// - param newChild: The new `unexpectedBeforeConventionLabel` to replace the node's + /// current `unexpectedBeforeConventionLabel`, if present. + public func withUnexpectedBeforeConventionLabel(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) + } + + /// The convention label. + public var conventionLabel: TokenSyntax { + get { + let childData = data.child(at: 1, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withConventionLabel(value) + } + } + + /// Returns a copy of the receiver with its `conventionLabel` replaced. + /// - param newChild: The new `conventionLabel` to replace the node's + /// current `conventionLabel`, if present. + public func withConventionLabel(_ newChild: TokenSyntax) -> ConventionAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) + } + + public var unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 2, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenConventionLabelAndComma(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenConventionLabelAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenConventionLabelAndComma` to replace the node's + /// current `unexpectedBetweenConventionLabelAndComma`, if present. + public func withUnexpectedBetweenConventionLabelAndComma(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) + } + + public var comma: TokenSyntax? { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withComma(value) + } } - public var unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? { + /// Returns a copy of the receiver with its `comma` replaced. + /// - param newChild: The new `comma` to replace the node's + /// current `comma`, if present. + public func withComma(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) + } + + public var unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeSourceFileLabel(value) + self = withUnexpectedBetweenCommaAndCTypeLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeSourceFileLabel` replaced. - /// - param newChild: The new `unexpectedBeforeSourceFileLabel` to replace the node's - /// current `unexpectedBeforeSourceFileLabel`, if present. - public func withUnexpectedBeforeSourceFileLabel(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndCTypeLabel` replaced. + /// - param newChild: The new `unexpectedBetweenCommaAndCTypeLabel` to replace the node's + /// current `unexpectedBetweenCommaAndCTypeLabel`, if present. + public func withUnexpectedBetweenCommaAndCTypeLabel(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return UnderscorePrivateAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) } - public var sourceFileLabel: TokenSyntax { + public var cTypeLabel: TokenSyntax? { get { - let childData = data.child(at: 1, parent: Syntax(self)) + let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withSourceFileLabel(value) + self = withCTypeLabel(value) } } - /// Returns a copy of the receiver with its `sourceFileLabel` replaced. - /// - param newChild: The new `sourceFileLabel` to replace the node's - /// current `sourceFileLabel`, if present. - public func withSourceFileLabel(_ newChild: TokenSyntax) -> UnderscorePrivateAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `cTypeLabel` replaced. + /// - param newChild: The new `cTypeLabel` to replace the node's + /// current `cTypeLabel`, if present. + public func withCTypeLabel(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return UnderscorePrivateAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenSourceFileLabelAndColon(value) + self = withUnexpectedBetweenCTypeLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenSourceFileLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenSourceFileLabelAndColon` to replace the node's - /// current `unexpectedBetweenSourceFileLabelAndColon`, if present. - public func withUnexpectedBetweenSourceFileLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCTypeLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenCTypeLabelAndColon` to replace the node's + /// current `unexpectedBetweenCTypeLabelAndColon`, if present. + public func withUnexpectedBetweenCTypeLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return UnderscorePrivateAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) } - public var colon: TokenSyntax { + public var colon: TokenSyntax? { get { - let childData = data.child(at: 3, parent: Syntax(self)) + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { @@ -18088,84 +17956,89 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH /// Returns a copy of the receiver with its `colon` replaced. /// - param newChild: The new `colon` to replace the node's /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> UnderscorePrivateAttributeArgumentsSyntax { + public func withColon(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return UnderscorePrivateAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndFilename(value) + self = withUnexpectedBetweenColonAndCTypeString(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndFilename` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndFilename` to replace the node's - /// current `unexpectedBetweenColonAndFilename`, if present. - public func withUnexpectedBetweenColonAndFilename(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndCTypeString` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndCTypeString` to replace the node's + /// current `unexpectedBetweenColonAndCTypeString`, if present. + public func withUnexpectedBetweenColonAndCTypeString(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return UnderscorePrivateAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) } - public var filename: TokenSyntax { + public var cTypeString: TokenSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withFilename(value) + self = withCTypeString(value) } } - /// Returns a copy of the receiver with its `filename` replaced. - /// - param newChild: The new `filename` to replace the node's - /// current `filename`, if present. - public func withFilename(_ newChild: TokenSyntax) -> UnderscorePrivateAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `cTypeString` replaced. + /// - param newChild: The new `cTypeString` to replace the node's + /// current `cTypeString`, if present. + public func withCTypeString(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return UnderscorePrivateAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) } - public var unexpectedAfterFilename: UnexpectedNodesSyntax? { + public var unexpectedAfterCTypeString: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterFilename(value) + self = withUnexpectedAfterCTypeString(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterFilename` replaced. - /// - param newChild: The new `unexpectedAfterFilename` to replace the node's - /// current `unexpectedAfterFilename`, if present. - public func withUnexpectedAfterFilename(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterCTypeString` replaced. + /// - param newChild: The new `unexpectedAfterCTypeString` to replace the node's + /// current `unexpectedAfterCTypeString`, if present. + public func withUnexpectedAfterCTypeString(_ newChild: UnexpectedNodesSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return UnderscorePrivateAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return ConventionAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeSourceFileLabel, - \Self.sourceFileLabel, - \Self.unexpectedBetweenSourceFileLabelAndColon, + \Self.unexpectedBeforeConventionLabel, + \Self.conventionLabel, + \Self.unexpectedBetweenConventionLabelAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndCTypeLabel, + \Self.cTypeLabel, + \Self.unexpectedBetweenCTypeLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndFilename, - \Self.filename, - \Self.unexpectedAfterFilename, + \Self.unexpectedBetweenColonAndCTypeString, + \Self.cTypeString, + \Self.unexpectedAfterCTypeString, ]) } @@ -18185,138 +18058,150 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH 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 UnderscorePrivateAttributeArgumentsSyntax: CustomReflectable { +extension ConventionAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeSourceFileLabel": unexpectedBeforeSourceFileLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "sourceFileLabel": Syntax(sourceFileLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenSourceFileLabelAndColon": unexpectedBetweenSourceFileLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndFilename": unexpectedBetweenColonAndFilename.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "filename": Syntax(filename).asProtocol(SyntaxProtocol.self), - "unexpectedAfterFilename": unexpectedAfterFilename.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: - DynamicReplacementArgumentsSyntax +// MARK: - ConventionWitnessMethodAttributeArgumentsSyntax /// -/// The arguments for the '@_dynamicReplacement' attribute +/// The arguments for the '@convention(witness_method: ...)'. /// -public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dynamicReplacementArguments else { return nil } + guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DynamicReplacementArgumentsSyntax` 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) { - assert(data.raw.kind == .dynamicReplacementArguments) + assert(data.raw.kind == .conventionWitnessMethodAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, - forLabel: TokenSyntax = .identifier("for"), - _ unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, + witnessMethodLabel: TokenSyntax, + _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, - declname: DeclNameSyntax, - _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, + protocolName: TokenSyntax, + _ 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(), (unexpectedBeforeForLabel, forLabel, unexpectedBetweenForLabelAndColon, colon, unexpectedBetweenColonAndDeclname, declname, unexpectedAfterDeclname))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWitnessMethodLabel, witnessMethodLabel, unexpectedBetweenWitnessMethodLabelAndColon, colon, unexpectedBetweenColonAndProtocolName, protocolName, unexpectedAfterProtocolName))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeForLabel?.raw, - forLabel.raw, - unexpectedBetweenForLabelAndColon?.raw, + unexpectedBeforeWitnessMethodLabel?.raw, + witnessMethodLabel.raw, + unexpectedBetweenWitnessMethodLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndDeclname?.raw, - declname.raw, - unexpectedAfterDeclname?.raw, + unexpectedBetweenColonAndProtocolName?.raw, + protocolName.raw, + unexpectedAfterProtocolName?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dynamicReplacementArguments, from: layout, arena: arena, + kind: SyntaxKind.conventionWitnessMethodAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeForLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeForLabel(value) + self = withUnexpectedBeforeWitnessMethodLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeForLabel` replaced. - /// - param newChild: The new `unexpectedBeforeForLabel` to replace the node's - /// current `unexpectedBeforeForLabel`, if present. - public func withUnexpectedBeforeForLabel(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeWitnessMethodLabel` replaced. + /// - param newChild: The new `unexpectedBeforeWitnessMethodLabel` to replace the node's + /// current `unexpectedBeforeWitnessMethodLabel`, if present. + public func withUnexpectedBeforeWitnessMethodLabel(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DynamicReplacementArgumentsSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } - public var forLabel: TokenSyntax { + public var witnessMethodLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withForLabel(value) + self = withWitnessMethodLabel(value) } } - /// Returns a copy of the receiver with its `forLabel` replaced. - /// - param newChild: The new `forLabel` to replace the node's - /// current `forLabel`, if present. - public func withForLabel(_ newChild: TokenSyntax) -> DynamicReplacementArgumentsSyntax { + /// Returns a copy of the receiver with its `witnessMethodLabel` replaced. + /// - param newChild: The new `witnessMethodLabel` to replace the node's + /// current `witnessMethodLabel`, if present. + public func withWitnessMethodLabel(_ newChild: TokenSyntax) -> ConventionWitnessMethodAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DynamicReplacementArgumentsSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenForLabelAndColon(value) + self = withUnexpectedBetweenWitnessMethodLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenForLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenForLabelAndColon` to replace the node's - /// current `unexpectedBetweenForLabelAndColon`, if present. - public func withUnexpectedBetweenForLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenWitnessMethodLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenWitnessMethodLabelAndColon` to replace the node's + /// current `unexpectedBetweenWitnessMethodLabelAndColon`, if present. + public func withUnexpectedBetweenWitnessMethodLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DynamicReplacementArgumentsSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } public var colon: TokenSyntax { @@ -18332,84 +18217,84 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable /// Returns a copy of the receiver with its `colon` replaced. /// - param newChild: The new `colon` to replace the node's /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> DynamicReplacementArgumentsSyntax { + public func withColon(_ newChild: TokenSyntax) -> ConventionWitnessMethodAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DynamicReplacementArgumentsSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndDeclname(value) + self = withUnexpectedBetweenColonAndProtocolName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndDeclname` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndDeclname` to replace the node's - /// current `unexpectedBetweenColonAndDeclname`, if present. - public func withUnexpectedBetweenColonAndDeclname(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndProtocolName` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndProtocolName` to replace the node's + /// current `unexpectedBetweenColonAndProtocolName`, if present. + public func withUnexpectedBetweenColonAndProtocolName(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DynamicReplacementArgumentsSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } - public var declname: DeclNameSyntax { + public var protocolName: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return DeclNameSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withDeclname(value) + self = withProtocolName(value) } } - /// Returns a copy of the receiver with its `declname` replaced. - /// - param newChild: The new `declname` to replace the node's - /// current `declname`, if present. - public func withDeclname(_ newChild: DeclNameSyntax) -> DynamicReplacementArgumentsSyntax { + /// Returns a copy of the receiver with its `protocolName` replaced. + /// - param newChild: The new `protocolName` to replace the node's + /// current `protocolName`, if present. + public func withProtocolName(_ newChild: TokenSyntax) -> ConventionWitnessMethodAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DynamicReplacementArgumentsSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } - public var unexpectedAfterDeclname: UnexpectedNodesSyntax? { + public var unexpectedAfterProtocolName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterDeclname(value) + self = withUnexpectedAfterProtocolName(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterDeclname` replaced. - /// - param newChild: The new `unexpectedAfterDeclname` to replace the node's - /// current `unexpectedAfterDeclname`, if present. - public func withUnexpectedAfterDeclname(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterProtocolName` replaced. + /// - param newChild: The new `unexpectedAfterProtocolName` to replace the node's + /// current `unexpectedAfterProtocolName`, if present. + public func withUnexpectedAfterProtocolName(_ newChild: UnexpectedNodesSyntax?) -> ConventionWitnessMethodAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DynamicReplacementArgumentsSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeForLabel, - \Self.forLabel, - \Self.unexpectedBetweenForLabelAndColon, + \Self.unexpectedBeforeWitnessMethodLabel, + \Self.witnessMethodLabel, + \Self.unexpectedBetweenWitnessMethodLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndDeclname, - \Self.declname, - \Self.unexpectedAfterDeclname, + \Self.unexpectedBetweenColonAndProtocolName, + \Self.protocolName, + \Self.unexpectedAfterProtocolName, ]) } @@ -18435,225 +18320,227 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } -extension DynamicReplacementArgumentsSyntax: CustomReflectable { +extension ConventionWitnessMethodAttributeArgumentsSyntax: 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, + "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), - "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, + "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: - UnavailableFromAsyncArgumentsSyntax +// MARK: - ExposeAttributeArgumentsSyntax /// -/// The arguments for the '@_unavailableFromAsync' attribute +/// The arguments for the '@_expose' attribute /// -public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unavailableFromAsyncArguments else { return nil } + guard node.raw.kind == .exposeAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `UnavailableFromAsyncArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ExposeAttributeArgumentsSyntax` 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) { - assert(data.raw.kind == .unavailableFromAsyncArguments) + assert(data.raw.kind == .exposeAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? = nil, - messageLabel: TokenSyntax = .identifier("message"), - _ unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? = nil, - message: TokenSyntax, - _ unexpectedAfterMessage: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLanguage: UnexpectedNodesSyntax? = nil, + language: TokenSyntax, + _ unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? = nil, + cxxName: TokenSyntax? = nil, + _ unexpectedAfterCxxName: 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(), (unexpectedBeforeMessageLabel, messageLabel, unexpectedBetweenMessageLabelAndColon, colon, unexpectedBetweenColonAndMessage, message, unexpectedAfterMessage))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLanguage, language, unexpectedBetweenLanguageAndComma, comma, unexpectedBetweenCommaAndCxxName, cxxName, unexpectedAfterCxxName))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeMessageLabel?.raw, - messageLabel.raw, - unexpectedBetweenMessageLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndMessage?.raw, - message.raw, - unexpectedAfterMessage?.raw, + unexpectedBeforeLanguage?.raw, + language.raw, + unexpectedBetweenLanguageAndComma?.raw, + comma?.raw, + unexpectedBetweenCommaAndCxxName?.raw, + cxxName?.raw, + unexpectedAfterCxxName?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unavailableFromAsyncArguments, from: layout, arena: arena, + kind: SyntaxKind.exposeAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeLanguage: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeMessageLabel(value) + self = withUnexpectedBeforeLanguage(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeMessageLabel` replaced. - /// - param newChild: The new `unexpectedBeforeMessageLabel` to replace the node's - /// current `unexpectedBeforeMessageLabel`, if present. - public func withUnexpectedBeforeMessageLabel(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLanguage` replaced. + /// - param newChild: The new `unexpectedBeforeLanguage` to replace the node's + /// current `unexpectedBeforeLanguage`, if present. + public func withUnexpectedBeforeLanguage(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return UnavailableFromAsyncArgumentsSyntax(newData) + return ExposeAttributeArgumentsSyntax(newData) } - public var messageLabel: TokenSyntax { + public var language: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withMessageLabel(value) + self = withLanguage(value) } } - /// Returns a copy of the receiver with its `messageLabel` replaced. - /// - param newChild: The new `messageLabel` to replace the node's - /// current `messageLabel`, if present. - public func withMessageLabel(_ newChild: TokenSyntax) -> UnavailableFromAsyncArgumentsSyntax { + /// Returns a copy of the receiver with its `language` replaced. + /// - param newChild: The new `language` to replace the node's + /// current `language`, if present. + public func withLanguage(_ newChild: TokenSyntax) -> ExposeAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return UnavailableFromAsyncArgumentsSyntax(newData) + return ExposeAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenMessageLabelAndColon(value) + self = withUnexpectedBetweenLanguageAndComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenMessageLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenMessageLabelAndColon` to replace the node's - /// current `unexpectedBetweenMessageLabelAndColon`, if present. - public func withUnexpectedBetweenMessageLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLanguageAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenLanguageAndComma` to replace the node's + /// current `unexpectedBetweenLanguageAndComma`, if present. + public func withUnexpectedBetweenLanguageAndComma(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return UnavailableFromAsyncArgumentsSyntax(newData) + return ExposeAttributeArgumentsSyntax(newData) } - public var colon: TokenSyntax { + public var comma: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withComma(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> UnavailableFromAsyncArgumentsSyntax { + /// Returns a copy of the receiver with its `comma` replaced. + /// - param newChild: The new `comma` to replace the node's + /// current `comma`, if present. + public func withComma(_ newChild: TokenSyntax?) -> ExposeAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return UnavailableFromAsyncArgumentsSyntax(newData) + return ExposeAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndMessage(value) + self = withUnexpectedBetweenCommaAndCxxName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndMessage` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndMessage` to replace the node's - /// current `unexpectedBetweenColonAndMessage`, if present. - public func withUnexpectedBetweenColonAndMessage(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndCxxName` replaced. + /// - param newChild: The new `unexpectedBetweenCommaAndCxxName` to replace the node's + /// current `unexpectedBetweenCommaAndCxxName`, if present. + public func withUnexpectedBetweenCommaAndCxxName(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return UnavailableFromAsyncArgumentsSyntax(newData) + return ExposeAttributeArgumentsSyntax(newData) } - public var message: TokenSyntax { + public var cxxName: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withMessage(value) + self = withCxxName(value) } } - /// Returns a copy of the receiver with its `message` replaced. - /// - param newChild: The new `message` to replace the node's - /// current `message`, if present. - public func withMessage(_ newChild: TokenSyntax) -> UnavailableFromAsyncArgumentsSyntax { + /// Returns a copy of the receiver with its `cxxName` replaced. + /// - param newChild: The new `cxxName` to replace the node's + /// current `cxxName`, if present. + public func withCxxName(_ newChild: TokenSyntax?) -> ExposeAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return UnavailableFromAsyncArgumentsSyntax(newData) + return ExposeAttributeArgumentsSyntax(newData) } - public var unexpectedAfterMessage: UnexpectedNodesSyntax? { + public var unexpectedAfterCxxName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterMessage(value) + self = withUnexpectedAfterCxxName(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterMessage` replaced. - /// - param newChild: The new `unexpectedAfterMessage` to replace the node's - /// current `unexpectedAfterMessage`, if present. - public func withUnexpectedAfterMessage(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterCxxName` replaced. + /// - param newChild: The new `unexpectedAfterCxxName` to replace the node's + /// current `unexpectedAfterCxxName`, if present. + public func withUnexpectedAfterCxxName(_ newChild: UnexpectedNodesSyntax?) -> ExposeAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return UnavailableFromAsyncArgumentsSyntax(newData) + return ExposeAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeMessageLabel, - \Self.messageLabel, - \Self.unexpectedBetweenMessageLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndMessage, - \Self.message, - \Self.unexpectedAfterMessage, + \Self.unexpectedBeforeLanguage, + \Self.language, + \Self.unexpectedBetweenLanguageAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndCxxName, + \Self.cxxName, + \Self.unexpectedAfterCxxName, ]) } @@ -18679,133 +18566,140 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl } } -extension UnavailableFromAsyncArgumentsSyntax: CustomReflectable { +extension ExposeAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeMessageLabel": unexpectedBeforeMessageLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "messageLabel": Syntax(messageLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenMessageLabelAndColon": unexpectedBetweenMessageLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndMessage": unexpectedBetweenColonAndMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "message": Syntax(message).asProtocol(SyntaxProtocol.self), - "unexpectedAfterMessage": unexpectedAfterMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLanguage": unexpectedBeforeLanguage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "language": Syntax(language).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLanguageAndComma": unexpectedBetweenLanguageAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenCommaAndCxxName": unexpectedBetweenCommaAndCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "cxxName": cxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterCxxName": unexpectedAfterCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DocumentationAttributeArgumentSyntax +// MARK: - OriginallyDefinedInArgumentsSyntax -public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the '@_originallyDefinedIn' attribute +/// +public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .documentationAttributeArgument else { return nil } + guard node.raw.kind == .originallyDefinedInArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DocumentationAttributeArgumentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `OriginallyDefinedInArgumentsSyntax` 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) { - assert(data.raw.kind == .documentationAttributeArgument) + assert(data.raw.kind == .originallyDefinedInArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? = nil, + moduleLabel: TokenSyntax = .identifier("module"), + _ unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? = nil, + moduleName: TokenSyntax, + _ unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? = nil, + platforms: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterPlatforms: 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, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeModuleLabel, moduleLabel, unexpectedBetweenModuleLabelAndColon, colon, unexpectedBetweenColonAndModuleName, moduleName, unexpectedBetweenModuleNameAndComma, comma, unexpectedBetweenCommaAndPlatforms, platforms, unexpectedAfterPlatforms))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, + unexpectedBeforeModuleLabel?.raw, + moduleLabel.raw, + unexpectedBetweenModuleLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBetweenColonAndModuleName?.raw, + moduleName.raw, + unexpectedBetweenModuleNameAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndPlatforms?.raw, + platforms.raw, + unexpectedAfterPlatforms?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.documentationAttributeArgument, from: layout, arena: arena, + kind: SyntaxKind.originallyDefinedInArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLabel(value) + self = withUnexpectedBeforeModuleLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. - /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's - /// current `unexpectedBeforeLabel`, if present. - public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeModuleLabel` replaced. + /// - param newChild: The new `unexpectedBeforeModuleLabel` to replace the node's + /// current `unexpectedBeforeModuleLabel`, if present. + public func withUnexpectedBeforeModuleLabel(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } - public var label: TokenSyntax { + public var moduleLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLabel(value) + self = withModuleLabel(value) } } - /// Returns a copy of the receiver with its `label` replaced. - /// - param newChild: The new `label` to replace the node's - /// current `label`, if present. - public func withLabel(_ newChild: TokenSyntax) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `moduleLabel` replaced. + /// - param newChild: The new `moduleLabel` to replace the node's + /// current `moduleLabel`, if present. + public func withModuleLabel(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLabelAndColon(value) + self = withUnexpectedBetweenModuleLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's - /// current `unexpectedBetweenLabelAndColon`, if present. - public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenModuleLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenModuleLabelAndColon` to replace the node's + /// current `unexpectedBetweenModuleLabelAndColon`, if present. + public func withUnexpectedBetweenModuleLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } public var colon: TokenSyntax { @@ -18821,131 +18715,189 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab /// Returns a copy of the receiver with its `colon` replaced. /// - param newChild: The new `colon` to replace the node's /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> DocumentationAttributeArgumentSyntax { + public func withColon(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } - public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndValue(value) + self = withUnexpectedBetweenColonAndModuleName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndValue` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndValue` to replace the node's - /// current `unexpectedBetweenColonAndValue`, if present. - public func withUnexpectedBetweenColonAndValue(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndModuleName` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndModuleName` to replace the node's + /// current `unexpectedBetweenColonAndModuleName`, if present. + public func withUnexpectedBetweenColonAndModuleName(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } - public var value: TokenSyntax { + public var moduleName: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withValue(value) + self = withModuleName(value) } } - /// Returns a copy of the receiver with its `value` replaced. - /// - param newChild: The new `value` to replace the node's - /// current `value`, if present. - public func withValue(_ newChild: TokenSyntax) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `moduleName` replaced. + /// - param newChild: The new `moduleName` to replace the node's + /// current `moduleName`, if present. + public func withModuleName(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } - public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenValueAndTrailingComma(value) + self = withUnexpectedBetweenModuleNameAndComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenValueAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenValueAndTrailingComma` to replace the node's - /// current `unexpectedBetweenValueAndTrailingComma`, if present. - public func withUnexpectedBetweenValueAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenModuleNameAndComma` replaced. + /// - param newChild: The new `unexpectedBetweenModuleNameAndComma` to replace the node's + /// current `unexpectedBetweenModuleNameAndComma`, if present. + public func withUnexpectedBetweenModuleNameAndComma(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } - /// - /// A trailing comma if this argument is followed by another one - /// - public var trailingComma: TokenSyntax? { + public var comma: TokenSyntax { get { let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withComma(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `comma` replaced. + /// - param newChild: The new `comma` to replace the node's + /// current `comma`, if present. + public func withComma(_ newChild: TokenSyntax) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? { get { let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenCommaAndPlatforms(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndPlatforms` replaced. + /// - param newChild: The new `unexpectedBetweenCommaAndPlatforms` to replace the node's + /// current `unexpectedBetweenCommaAndPlatforms`, if present. + public func withUnexpectedBetweenCommaAndPlatforms(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return DocumentationAttributeArgumentSyntax(newData) + return OriginallyDefinedInArgumentsSyntax(newData) + } + + public var platforms: AvailabilityVersionRestrictionListSyntax { + get { + let childData = data.child(at: 9, parent: Syntax(self)) + return AvailabilityVersionRestrictionListSyntax(childData!) + } + set(value) { + self = withPlatforms(value) + } + } + + /// Adds the provided `Platform` to the node's `platforms` + /// collection. + /// - param element: The new `Platform` to add to the node's + /// `platforms` collection. + /// - returns: A copy of the receiver with the provided `Platform` + /// appended to its `platforms` collection. + public func addPlatform(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> OriginallyDefinedInArgumentsSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[9] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 9, with: collection, arena: arena) + return OriginallyDefinedInArgumentsSyntax(newData) + } + + /// Returns a copy of the receiver with its `platforms` replaced. + /// - param newChild: The new `platforms` to replace the node's + /// current `platforms`, if present. + public func withPlatforms(_ newChild: AvailabilityVersionRestrictionListSyntax) -> OriginallyDefinedInArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return OriginallyDefinedInArgumentsSyntax(newData) + } + + public var unexpectedAfterPlatforms: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 10, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterPlatforms(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterPlatforms` replaced. + /// - param newChild: The new `unexpectedAfterPlatforms` to replace the node's + /// current `unexpectedAfterPlatforms`, if present. + public func withUnexpectedAfterPlatforms(_ newChild: UnexpectedNodesSyntax?) -> OriginallyDefinedInArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return OriginallyDefinedInArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, + \Self.unexpectedBeforeModuleLabel, + \Self.moduleLabel, + \Self.unexpectedBetweenModuleLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedBetweenValueAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBetweenColonAndModuleName, + \Self.moduleName, + \Self.unexpectedBetweenModuleNameAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndPlatforms, + \Self.platforms, + \Self.unexpectedAfterPlatforms, ]) } @@ -18954,7 +18906,7 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -18962,190 +18914,246 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab case 4: return nil case 5: - return "value" + 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 DocumentationAttributeArgumentSyntax: CustomReflectable { +extension OriginallyDefinedInArgumentsSyntax: 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, + "unexpectedBeforeModuleLabel": unexpectedBeforeModuleLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "moduleLabel": Syntax(moduleLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenModuleLabelAndColon": unexpectedBetweenModuleLabelAndColon.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, + "unexpectedBetweenColonAndModuleName": unexpectedBetweenColonAndModuleName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "moduleName": Syntax(moduleName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenModuleNameAndComma": unexpectedBetweenModuleNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCommaAndPlatforms": unexpectedBetweenCommaAndPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "platforms": Syntax(platforms).asProtocol(SyntaxProtocol.self), + "unexpectedAfterPlatforms": unexpectedAfterPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - WhereClauseSyntax +// MARK: - UnderscorePrivateAttributeArgumentsSyntax -public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the '@_private' attribute +/// +public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .whereClause else { return nil } + guard node.raw.kind == .underscorePrivateAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `WhereClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnderscorePrivateAttributeArgumentsSyntax` 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) { - assert(data.raw.kind == .whereClause) + assert(data.raw.kind == .underscorePrivateAttributeArguments) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, - whereKeyword: TokenSyntax = .keyword(.where), - _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, - guardResult: G, - _ unexpectedAfterGuardResult: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? = nil, + sourceFileLabel: TokenSyntax = .identifier("sourceFile"), + _ unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? = nil, + filename: TokenSyntax, + _ unexpectedAfterFilename: 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(), (unexpectedBeforeWhereKeyword, whereKeyword, unexpectedBetweenWhereKeywordAndGuardResult, guardResult, unexpectedAfterGuardResult))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSourceFileLabel, sourceFileLabel, unexpectedBetweenSourceFileLabelAndColon, colon, unexpectedBetweenColonAndFilename, filename, unexpectedAfterFilename))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWhereKeyword?.raw, - whereKeyword.raw, - unexpectedBetweenWhereKeywordAndGuardResult?.raw, - guardResult.raw, - unexpectedAfterGuardResult?.raw, + unexpectedBeforeSourceFileLabel?.raw, + sourceFileLabel.raw, + unexpectedBetweenSourceFileLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndFilename?.raw, + filename.raw, + unexpectedAfterFilename?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.whereClause, from: layout, arena: arena, + kind: SyntaxKind.underscorePrivateAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeWhereKeyword(value) + self = withUnexpectedBeforeSourceFileLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeWhereKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeWhereKeyword` to replace the node's - /// current `unexpectedBeforeWhereKeyword`, if present. - public func withUnexpectedBeforeWhereKeyword(_ newChild: UnexpectedNodesSyntax?) -> WhereClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeSourceFileLabel` replaced. + /// - param newChild: The new `unexpectedBeforeSourceFileLabel` to replace the node's + /// current `unexpectedBeforeSourceFileLabel`, if present. + public func withUnexpectedBeforeSourceFileLabel(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return WhereClauseSyntax(newData) + return UnderscorePrivateAttributeArgumentsSyntax(newData) } - public var whereKeyword: TokenSyntax { + public var sourceFileLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withWhereKeyword(value) + self = withSourceFileLabel(value) } } - /// Returns a copy of the receiver with its `whereKeyword` replaced. - /// - param newChild: The new `whereKeyword` to replace the node's - /// current `whereKeyword`, if present. - public func withWhereKeyword(_ newChild: TokenSyntax) -> WhereClauseSyntax { + /// Returns a copy of the receiver with its `sourceFileLabel` replaced. + /// - param newChild: The new `sourceFileLabel` to replace the node's + /// current `sourceFileLabel`, if present. + public func withSourceFileLabel(_ newChild: TokenSyntax) -> UnderscorePrivateAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return WhereClauseSyntax(newData) + return UnderscorePrivateAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? { + public var unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenWhereKeywordAndGuardResult(value) + self = withUnexpectedBetweenSourceFileLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenWhereKeywordAndGuardResult` replaced. - /// - param newChild: The new `unexpectedBetweenWhereKeywordAndGuardResult` to replace the node's - /// current `unexpectedBetweenWhereKeywordAndGuardResult`, if present. - public func withUnexpectedBetweenWhereKeywordAndGuardResult(_ newChild: UnexpectedNodesSyntax?) -> WhereClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenSourceFileLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenSourceFileLabelAndColon` to replace the node's + /// current `unexpectedBetweenSourceFileLabelAndColon`, if present. + public func withUnexpectedBetweenSourceFileLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return WhereClauseSyntax(newData) + return UnderscorePrivateAttributeArgumentsSyntax(newData) } - public var guardResult: ExprSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return ExprSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withGuardResult(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `guardResult` replaced. - /// - param newChild: The new `guardResult` to replace the node's - /// current `guardResult`, if present. - public func withGuardResult(_ newChild: ExprSyntax) -> WhereClauseSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> UnderscorePrivateAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return WhereClauseSyntax(newData) + return UnderscorePrivateAttributeArgumentsSyntax(newData) } - public var unexpectedAfterGuardResult: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterGuardResult(value) + self = withUnexpectedBetweenColonAndFilename(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterGuardResult` replaced. - /// - param newChild: The new `unexpectedAfterGuardResult` to replace the node's - /// current `unexpectedAfterGuardResult`, if present. - public func withUnexpectedAfterGuardResult(_ newChild: UnexpectedNodesSyntax?) -> WhereClauseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndFilename` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndFilename` to replace the node's + /// current `unexpectedBetweenColonAndFilename`, if present. + public func withUnexpectedBetweenColonAndFilename(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return WhereClauseSyntax(newData) + return UnderscorePrivateAttributeArgumentsSyntax(newData) + } + + public var filename: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withFilename(value) + } + } + + /// Returns a copy of the receiver with its `filename` replaced. + /// - param newChild: The new `filename` to replace the node's + /// current `filename`, if present. + public func withFilename(_ newChild: TokenSyntax) -> UnderscorePrivateAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return UnderscorePrivateAttributeArgumentsSyntax(newData) + } + + public var unexpectedAfterFilename: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterFilename(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterFilename` replaced. + /// - param newChild: The new `unexpectedAfterFilename` to replace the node's + /// current `unexpectedAfterFilename`, if present. + public func withUnexpectedAfterFilename(_ newChild: UnexpectedNodesSyntax?) -> UnderscorePrivateAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return UnderscorePrivateAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWhereKeyword, - \Self.whereKeyword, - \Self.unexpectedBetweenWhereKeywordAndGuardResult, - \Self.guardResult, - \Self.unexpectedAfterGuardResult, + \Self.unexpectedBeforeSourceFileLabel, + \Self.sourceFileLabel, + \Self.unexpectedBetweenSourceFileLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndFilename, + \Self.filename, + \Self.unexpectedAfterFilename, ]) } @@ -19161,506 +19169,479 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension WhereClauseSyntax: CustomReflectable { +extension UnderscorePrivateAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeWhereKeyword": unexpectedBeforeWhereKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "whereKeyword": Syntax(whereKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenWhereKeywordAndGuardResult": unexpectedBetweenWhereKeywordAndGuardResult.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "guardResult": Syntax(guardResult).asProtocol(SyntaxProtocol.self), - "unexpectedAfterGuardResult": unexpectedAfterGuardResult.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeSourceFileLabel": unexpectedBeforeSourceFileLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "sourceFileLabel": Syntax(sourceFileLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenSourceFileLabelAndColon": unexpectedBetweenSourceFileLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndFilename": unexpectedBetweenColonAndFilename.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "filename": Syntax(filename).asProtocol(SyntaxProtocol.self), + "unexpectedAfterFilename": unexpectedAfterFilename.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - YieldListSyntax +// MARK: - DynamicReplacementArgumentsSyntax -public struct YieldListSyntax: 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 == .yieldList else { return nil } + guard node.raw.kind == .dynamicReplacementArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `YieldListSyntax` 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) { - assert(data.raw.kind == .yieldList) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, - elementList: YieldExprListSyntax, - _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + assert(data.raw.kind == .dynamicReplacementArguments) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, + forLabel: TokenSyntax = .identifier("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(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndElementList, elementList, unexpectedBetweenElementListAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeForLabel, forLabel, unexpectedBetweenForLabelAndColon, colon, unexpectedBetweenColonAndDeclname, declname, unexpectedAfterDeclname))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElementList?.raw, - elementList.raw, - unexpectedBetweenElementListAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeForLabel?.raw, + forLabel.raw, + unexpectedBetweenForLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndDeclname?.raw, + declname.raw, + unexpectedAfterDeclname?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldList, from: layout, arena: arena, + kind: SyntaxKind.dynamicReplacementArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeForLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftParen(value) + self = withUnexpectedBeforeForLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. - /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's - /// current `unexpectedBeforeLeftParen`, if present. - public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeForLabel` replaced. + /// - param newChild: The new `unexpectedBeforeForLabel` to replace the node's + /// current `unexpectedBeforeForLabel`, if present. + public func withUnexpectedBeforeForLabel(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return YieldListSyntax(newData) + return DynamicReplacementArgumentsSyntax(newData) } - public var leftParen: TokenSyntax { + public var forLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withForLabel(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> YieldListSyntax { + /// Returns a copy of the receiver with its `forLabel` replaced. + /// - param newChild: The new `forLabel` to replace the node's + /// current `forLabel`, if present. + public func withForLabel(_ newChild: TokenSyntax) -> DynamicReplacementArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return YieldListSyntax(newData) + return DynamicReplacementArgumentsSyntax(newData) } - public var unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? { + public var unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndElementList(value) + self = withUnexpectedBetweenForLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndElementList` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndElementList` to replace the node's - /// current `unexpectedBetweenLeftParenAndElementList`, if present. - public func withUnexpectedBetweenLeftParenAndElementList(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenForLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenForLabelAndColon` to replace the node's + /// current `unexpectedBetweenForLabelAndColon`, if present. + public func withUnexpectedBetweenForLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return YieldListSyntax(newData) + return DynamicReplacementArgumentsSyntax(newData) } - public var elementList: YieldExprListSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return YieldExprListSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withElementList(value) - } - } - - /// Adds the provided `Element` to the node's `elementList` - /// collection. - /// - param element: The new `Element` to add to the node's - /// `elementList` collection. - /// - returns: A copy of the receiver with the provided `Element` - /// appended to its `elementList` collection. - public func addElement(_ element: YieldExprListElementSyntax) -> YieldListSyntax { - 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.yieldExprList, - from: [element.raw], arena: arena) + self = withColon(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return YieldListSyntax(newData) } - /// Returns a copy of the receiver with its `elementList` replaced. - /// - param newChild: The new `elementList` to replace the node's - /// current `elementList`, if present. - public func withElementList(_ newChild: YieldExprListSyntax) -> YieldListSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> DynamicReplacementArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return YieldListSyntax(newData) + return DynamicReplacementArgumentsSyntax(newData) } - public var unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenElementListAndRightParen(value) + self = withUnexpectedBetweenColonAndDeclname(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenElementListAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenElementListAndRightParen` to replace the node's - /// current `unexpectedBetweenElementListAndRightParen`, if present. - public func withUnexpectedBetweenElementListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndDeclname` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndDeclname` to replace the node's + /// current `unexpectedBetweenColonAndDeclname`, if present. + public func withUnexpectedBetweenColonAndDeclname(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return YieldListSyntax(newData) + return DynamicReplacementArgumentsSyntax(newData) } - public var rightParen: TokenSyntax { + public var declname: DeclNameSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + return DeclNameSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withDeclname(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> YieldListSyntax { + /// Returns a copy of the receiver with its `declname` replaced. + /// - param newChild: The new `declname` to replace the node's + /// current `declname`, if present. + public func withDeclname(_ newChild: DeclNameSyntax) -> DynamicReplacementArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return YieldListSyntax(newData) + return DynamicReplacementArgumentsSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterDeclname: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedAfterDeclname(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterDeclname` replaced. + /// - param newChild: The new `unexpectedAfterDeclname` to replace the node's + /// current `unexpectedAfterDeclname`, if present. + public func withUnexpectedAfterDeclname(_ newChild: UnexpectedNodesSyntax?) -> DynamicReplacementArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return YieldListSyntax(newData) + return DynamicReplacementArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndElementList, - \Self.elementList, - \Self.unexpectedBetweenElementListAndRightParen, - \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 nil - case 4: - return nil - case 5: - return nil - case 6: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension YieldListSyntax: 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), - "unexpectedBetweenLeftParenAndElementList": unexpectedBetweenLeftParenAndElementList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "elementList": Syntax(elementList).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenElementListAndRightParen": unexpectedBetweenElementListAndRightParen.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: - ConditionElementSyntax - -public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { - public enum Condition: SyntaxChildChoices { - case `expression`(ExprSyntax) - case `availability`(AvailabilityConditionSyntax) - case `matchingPattern`(MatchingPatternConditionSyntax) - case `optionalBinding`(OptionalBindingConditionSyntax) - case `hasSymbol`(HasSymbolConditionSyntax) - 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 - case .hasSymbol(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: HasSymbolConditionSyntax) { - self = .hasSymbol(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 - } - if let node = node.as(HasSymbolConditionSyntax.self) { - self = .hasSymbol(node) - return - } + \Self.unexpectedBeforeForLabel, + \Self.forLabel, + \Self.unexpectedBetweenForLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndDeclname, + \Self.declname, + \Self.unexpectedAfterDeclname, + ]) + } + + 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 + case 5: + return nil + case 6: + return nil + default: + fatalError("Invalid index") } + } +} - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(ExprSyntax.self), - .node(AvailabilityConditionSyntax.self), - .node(MatchingPatternConditionSyntax.self), - .node(OptionalBindingConditionSyntax.self), - .node(HasSymbolConditionSyntax.self), - ]) - } +extension DynamicReplacementArgumentsSyntax: 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, + ]) } +} + +// MARK: - UnavailableFromAsyncArgumentsSyntax +/// +/// The arguments for the '@_unavailableFromAsync' attribute +/// +public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conditionElement else { return nil } + guard node.raw.kind == .unavailableFromAsyncArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConditionElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnavailableFromAsyncArgumentsSyntax` 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) { - assert(data.raw.kind == .conditionElement) + assert(data.raw.kind == .unavailableFromAsyncArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, - condition: Condition, - _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? = nil, + messageLabel: TokenSyntax = .identifier("message"), + _ unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? = nil, + message: TokenSyntax, + _ unexpectedAfterMessage: 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))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeMessageLabel, messageLabel, unexpectedBetweenMessageLabelAndColon, colon, unexpectedBetweenColonAndMessage, message, unexpectedAfterMessage))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeCondition?.raw, - condition.raw, - unexpectedBetweenConditionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeMessageLabel?.raw, + messageLabel.raw, + unexpectedBetweenMessageLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndMessage?.raw, + message.raw, + unexpectedAfterMessage?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conditionElement, from: layout, arena: arena, + kind: SyntaxKind.unavailableFromAsyncArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { + public var unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeCondition(value) + self = withUnexpectedBeforeMessageLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeCondition` replaced. - /// - param newChild: The new `unexpectedBeforeCondition` to replace the node's - /// current `unexpectedBeforeCondition`, if present. - public func withUnexpectedBeforeCondition(_ newChild: UnexpectedNodesSyntax?) -> ConditionElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeMessageLabel` replaced. + /// - param newChild: The new `unexpectedBeforeMessageLabel` to replace the node's + /// current `unexpectedBeforeMessageLabel`, if present. + public func withUnexpectedBeforeMessageLabel(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return UnavailableFromAsyncArgumentsSyntax(newData) } - public var condition: Condition { + public var messageLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return Condition(childData!) + return TokenSyntax(childData!) } set(value) { - self = withCondition(value) + self = withMessageLabel(value) } } - /// Returns a copy of the receiver with its `condition` replaced. - /// - param newChild: The new `condition` to replace the node's - /// current `condition`, if present. - public func withCondition(_ newChild: Condition) -> ConditionElementSyntax { + /// Returns a copy of the receiver with its `messageLabel` replaced. + /// - param newChild: The new `messageLabel` to replace the node's + /// current `messageLabel`, if present. + public func withMessageLabel(_ newChild: TokenSyntax) -> UnavailableFromAsyncArgumentsSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return UnavailableFromAsyncArgumentsSyntax(newData) } - public var unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenConditionAndTrailingComma(value) + self = withUnexpectedBetweenMessageLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenConditionAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenConditionAndTrailingComma` to replace the node's - /// current `unexpectedBetweenConditionAndTrailingComma`, if present. - public func withUnexpectedBetweenConditionAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ConditionElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenMessageLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenMessageLabelAndColon` to replace the node's + /// current `unexpectedBetweenMessageLabelAndColon`, if present. + public func withUnexpectedBetweenMessageLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return UnavailableFromAsyncArgumentsSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> ConditionElementSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> UnavailableFromAsyncArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return UnavailableFromAsyncArgumentsSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenColonAndMessage(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ConditionElementSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndMessage` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndMessage` to replace the node's + /// current `unexpectedBetweenColonAndMessage`, if present. + public func withUnexpectedBetweenColonAndMessage(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return UnavailableFromAsyncArgumentsSyntax(newData) + } + + public var message: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withMessage(value) + } + } + + /// Returns a copy of the receiver with its `message` replaced. + /// - param newChild: The new `message` to replace the node's + /// current `message`, if present. + public func withMessage(_ newChild: TokenSyntax) -> UnavailableFromAsyncArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return UnavailableFromAsyncArgumentsSyntax(newData) + } + + public var unexpectedAfterMessage: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterMessage(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterMessage` replaced. + /// - param newChild: The new `unexpectedAfterMessage` to replace the node's + /// current `unexpectedAfterMessage`, if present. + public func withUnexpectedAfterMessage(_ newChild: UnexpectedNodesSyntax?) -> UnavailableFromAsyncArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return UnavailableFromAsyncArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeCondition, - \Self.condition, - \Self.unexpectedBetweenConditionAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeMessageLabel, + \Self.messageLabel, + \Self.unexpectedBetweenMessageLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndMessage, + \Self.message, + \Self.unexpectedAfterMessage, ]) } @@ -19676,292 +19657,283 @@ 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 UnavailableFromAsyncArgumentsSyntax: 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, + "unexpectedBeforeMessageLabel": unexpectedBeforeMessageLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "messageLabel": Syntax(messageLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenMessageLabelAndColon": unexpectedBetweenMessageLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndMessage": unexpectedBetweenColonAndMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "message": Syntax(message).asProtocol(SyntaxProtocol.self), + "unexpectedAfterMessage": unexpectedAfterMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - AvailabilityConditionSyntax +// MARK: - DocumentationAttributeArgumentSyntax -public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { +public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityCondition else { return nil } + guard node.raw.kind == .documentationAttributeArgument else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AvailabilityConditionSyntax` 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) { - assert(data.raw.kind == .availabilityCondition) + assert(data.raw.kind == .documentationAttributeArgument) self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? = nil, - availabilityKeyword: TokenSyntax, - _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, - availabilitySpec: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ 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(), (unexpectedBeforeAvailabilityKeyword, availabilityKeyword, unexpectedBetweenAvailabilityKeywordAndLeftParen, leftParen, unexpectedBetweenLeftParenAndAvailabilitySpec, availabilitySpec, unexpectedBetweenAvailabilitySpecAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAvailabilityKeyword?.raw, - availabilityKeyword.raw, - unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, - availabilitySpec.raw, - unexpectedBetweenAvailabilitySpecAndRightParen?.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.availabilityCondition, from: layout, arena: arena, + kind: SyntaxKind.documentationAttributeArgument, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeAvailabilityKeyword(value) + self = withUnexpectedBeforeLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeAvailabilityKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeAvailabilityKeyword` to replace the node's - /// current `unexpectedBeforeAvailabilityKeyword`, if present. - public func withUnexpectedBeforeAvailabilityKeyword(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLabel` replaced. + /// - param newChild: The new `unexpectedBeforeLabel` to replace the node's + /// current `unexpectedBeforeLabel`, if present. + public func withUnexpectedBeforeLabel(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var availabilityKeyword: TokenSyntax { + public var label: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withAvailabilityKeyword(value) + self = withLabel(value) } } - /// Returns a copy of the receiver with its `availabilityKeyword` replaced. - /// - param newChild: The new `availabilityKeyword` to replace the node's - /// current `availabilityKeyword`, if present. - public func withAvailabilityKeyword(_ newChild: TokenSyntax) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel(_ newChild: TokenSyntax) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAvailabilityKeywordAndLeftParen(value) + self = withUnexpectedBetweenLabelAndColon(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilityKeywordAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenAvailabilityKeywordAndLeftParen` to replace the node's - /// current `unexpectedBetweenAvailabilityKeywordAndLeftParen`, if present. - public func withUnexpectedBetweenAvailabilityKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenLabelAndColon` to replace the node's + /// current `unexpectedBetweenLabelAndColon`, if present. + public func withUnexpectedBetweenLabelAndColon(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var leftParen: TokenSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withColon(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndAvailabilitySpec(value) + self = withUnexpectedBetweenColonAndValue(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndAvailabilitySpec` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndAvailabilitySpec` to replace the node's - /// current `unexpectedBetweenLeftParenAndAvailabilitySpec`, if present. - public func withUnexpectedBetweenLeftParenAndAvailabilitySpec(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonAndValue` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndValue` to replace the node's + /// current `unexpectedBetweenColonAndValue`, if present. + public func withUnexpectedBetweenColonAndValue(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var availabilitySpec: AvailabilitySpecListSyntax { + public var value: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return AvailabilitySpecListSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withAvailabilitySpec(value) - } - } - - /// Adds the provided `AvailabilityArgument` to the node's `availabilitySpec` - /// collection. - /// - param element: The new `AvailabilityArgument` to add to the node's - /// `availabilitySpec` collection. - /// - returns: A copy of the receiver with the provided `AvailabilityArgument` - /// appended to its `availabilitySpec` collection. - public func addAvailabilityArgument(_ element: AvailabilityArgumentSyntax) -> AvailabilityConditionSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[5] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, - from: [element.raw], arena: arena) + self = withValue(value) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return AvailabilityConditionSyntax(newData) } - /// Returns a copy of the receiver with its `availabilitySpec` replaced. - /// - param newChild: The new `availabilitySpec` to replace the node's - /// current `availabilitySpec`, if present. - public func withAvailabilitySpec(_ newChild: AvailabilitySpecListSyntax) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `value` replaced. + /// - param newChild: The new `value` to replace the node's + /// current `value`, if present. + public func withValue(_ newChild: TokenSyntax) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAvailabilitySpecAndRightParen(value) + self = withUnexpectedBetweenValueAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilitySpecAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenAvailabilitySpecAndRightParen` to replace the node's - /// current `unexpectedBetweenAvailabilitySpecAndRightParen`, if present. - public func withUnexpectedBetweenAvailabilitySpecAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenValueAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenValueAndTrailingComma` to replace the node's + /// current `unexpectedBetweenValueAndTrailingComma`, if present. + public func withUnexpectedBetweenValueAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var rightParen: TokenSyntax { + /// + /// A trailing comma if this argument is followed by another one + /// + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> DocumentationAttributeArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return DocumentationAttributeArgumentSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAvailabilityKeyword, - \Self.availabilityKeyword, - \Self.unexpectedBetweenAvailabilityKeywordAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, - \Self.availabilitySpec, - \Self.unexpectedBetweenAvailabilitySpecAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedBetweenValueAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -19970,7 +19942,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: @@ -19978,7 +19950,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return nil + return "value" case 6: return nil case 7: @@ -19991,272 +19963,177 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AvailabilityConditionSyntax: CustomReflectable { +extension DocumentationAttributeArgumentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAvailabilityKeyword": unexpectedBeforeAvailabilityKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "availabilityKeyword": Syntax(availabilityKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAvailabilityKeywordAndLeftParen": unexpectedBetweenAvailabilityKeywordAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndAvailabilitySpec": unexpectedBetweenLeftParenAndAvailabilitySpec.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "availabilitySpec": Syntax(availabilitySpec).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAvailabilitySpecAndRightParen": unexpectedBetweenAvailabilitySpecAndRightParen.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: - MatchingPatternConditionSyntax +// MARK: - WhereClauseSyntax -public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { +public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .matchingPatternCondition else { return nil } + guard node.raw.kind == .whereClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `MatchingPatternConditionSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `WhereClauseSyntax` 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) { - assert(data.raw.kind == .matchingPatternCondition) + assert(data.raw.kind == .whereClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .keyword(.case), - _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax, - _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, + whereKeyword: TokenSyntax = .keyword(.where), + _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, + guardResult: G, + _ unexpectedAfterGuardResult: 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(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWhereKeyword, whereKeyword, unexpectedBetweenWhereKeywordAndGuardResult, guardResult, unexpectedAfterGuardResult))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer.raw, - unexpectedAfterInitializer?.raw, + unexpectedBeforeWhereKeyword?.raw, + whereKeyword.raw, + unexpectedBetweenWhereKeywordAndGuardResult?.raw, + guardResult.raw, + unexpectedAfterGuardResult?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.matchingPatternCondition, from: layout, arena: arena, + kind: SyntaxKind.whereClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeCaseKeyword(value) + self = withUnexpectedBeforeWhereKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeCaseKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeCaseKeyword` to replace the node's - /// current `unexpectedBeforeCaseKeyword`, if present. - public func withUnexpectedBeforeCaseKeyword(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeWhereKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeWhereKeyword` to replace the node's + /// current `unexpectedBeforeWhereKeyword`, if present. + public func withUnexpectedBeforeWhereKeyword(_ newChild: UnexpectedNodesSyntax?) -> WhereClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + return WhereClauseSyntax(newData) } - public var caseKeyword: TokenSyntax { + public var whereKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withCaseKeyword(value) + self = withWhereKeyword(value) } } - /// Returns a copy of the receiver with its `caseKeyword` replaced. - /// - param newChild: The new `caseKeyword` to replace the node's - /// current `caseKeyword`, if present. - public func withCaseKeyword(_ newChild: TokenSyntax) -> MatchingPatternConditionSyntax { + /// Returns a copy of the receiver with its `whereKeyword` replaced. + /// - param newChild: The new `whereKeyword` to replace the node's + /// current `whereKeyword`, if present. + public func withWhereKeyword(_ newChild: TokenSyntax) -> WhereClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + return WhereClauseSyntax(newData) } - public var unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? { + public var unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCaseKeywordAndPattern(value) + self = withUnexpectedBetweenWhereKeywordAndGuardResult(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCaseKeywordAndPattern` replaced. - /// - param newChild: The new `unexpectedBetweenCaseKeywordAndPattern` to replace the node's - /// current `unexpectedBetweenCaseKeywordAndPattern`, if present. - public func withUnexpectedBetweenCaseKeywordAndPattern(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenWhereKeywordAndGuardResult` replaced. + /// - param newChild: The new `unexpectedBetweenWhereKeywordAndGuardResult` to replace the node's + /// current `unexpectedBetweenWhereKeywordAndGuardResult`, if present. + public func withUnexpectedBetweenWhereKeywordAndGuardResult(_ newChild: UnexpectedNodesSyntax?) -> WhereClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + return WhereClauseSyntax(newData) } - public var pattern: PatternSyntax { + public var guardResult: ExprSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return PatternSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withPattern(value) + self = withGuardResult(value) } } - /// Returns a copy of the receiver with its `pattern` replaced. - /// - param newChild: The new `pattern` to replace the node's - /// current `pattern`, if present. - public func withPattern(_ newChild: PatternSyntax) -> MatchingPatternConditionSyntax { + /// Returns a copy of the receiver with its `guardResult` replaced. + /// - param newChild: The new `guardResult` to replace the node's + /// current `guardResult`, if present. + public func withGuardResult(_ newChild: ExprSyntax) -> WhereClauseSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + return WhereClauseSyntax(newData) } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + public var unexpectedAfterGuardResult: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPatternAndTypeAnnotation(value) + self = withUnexpectedAfterGuardResult(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndTypeAnnotation` replaced. - /// - param newChild: The new `unexpectedBetweenPatternAndTypeAnnotation` to replace the node's - /// current `unexpectedBetweenPatternAndTypeAnnotation`, if present. - public func withUnexpectedBetweenPatternAndTypeAnnotation(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterGuardResult` replaced. + /// - param newChild: The new `unexpectedAfterGuardResult` to replace the node's + /// current `unexpectedAfterGuardResult`, if present. + public func withUnexpectedAfterGuardResult(_ newChild: UnexpectedNodesSyntax?) -> WhereClauseSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) - } - - public var typeAnnotation: TypeAnnotationSyntax? { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TypeAnnotationSyntax(childData!) - } - set(value) { - self = withTypeAnnotation(value) - } - } - - /// Returns a copy of the receiver with its `typeAnnotation` replaced. - /// - param newChild: The new `typeAnnotation` to replace the node's - /// current `typeAnnotation`, if present. - public func withTypeAnnotation(_ newChild: TypeAnnotationSyntax?) -> MatchingPatternConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) - } - - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenTypeAnnotationAndInitializer(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenTypeAnnotationAndInitializer` replaced. - /// - param newChild: The new `unexpectedBetweenTypeAnnotationAndInitializer` to replace the node's - /// current `unexpectedBetweenTypeAnnotationAndInitializer`, if present. - public func withUnexpectedBetweenTypeAnnotationAndInitializer(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) - } - - public var initializer: InitializerClauseSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return InitializerClauseSyntax(childData!) - } - set(value) { - self = withInitializer(value) - } - } - - /// Returns a copy of the receiver with its `initializer` replaced. - /// - param newChild: The new `initializer` to replace the node's - /// current `initializer`, if present. - public func withInitializer(_ newChild: InitializerClauseSyntax) -> MatchingPatternConditionSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) - } - - public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterInitializer(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterInitializer` replaced. - /// - param newChild: The new `unexpectedAfterInitializer` to replace the node's - /// current `unexpectedAfterInitializer`, if present. - public func withUnexpectedAfterInitializer(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + return WhereClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeCaseKeyword, - \Self.caseKeyword, - \Self.unexpectedBetweenCaseKeywordAndPattern, - \Self.pattern, - \Self.unexpectedBetweenPatternAndTypeAnnotation, - \Self.typeAnnotation, - \Self.unexpectedBetweenTypeAnnotationAndInitializer, - \Self.initializer, - \Self.unexpectedAfterInitializer, + \Self.unexpectedBeforeWhereKeyword, + \Self.whereKeyword, + \Self.unexpectedBetweenWhereKeywordAndGuardResult, + \Self.guardResult, + \Self.unexpectedAfterGuardResult, ]) } @@ -20272,287 +20149,245 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension MatchingPatternConditionSyntax: CustomReflectable { +extension WhereClauseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeCaseKeyword": unexpectedBeforeCaseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "caseKeyword": Syntax(caseKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCaseKeywordAndPattern": unexpectedBetweenCaseKeywordAndPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "initializer": Syntax(initializer).asProtocol(SyntaxProtocol.self), - "unexpectedAfterInitializer": unexpectedAfterInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeWhereKeyword": unexpectedBeforeWhereKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "whereKeyword": Syntax(whereKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenWhereKeywordAndGuardResult": unexpectedBetweenWhereKeywordAndGuardResult.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "guardResult": Syntax(guardResult).asProtocol(SyntaxProtocol.self), + "unexpectedAfterGuardResult": unexpectedAfterGuardResult.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - OptionalBindingConditionSyntax +// MARK: - YieldListSyntax -public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { +public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .optionalBindingCondition else { return nil } + guard node.raw.kind == .yieldList else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OptionalBindingConditionSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `YieldListSyntax` 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) { - assert(data.raw.kind == .optionalBindingCondition) + assert(data.raw.kind == .yieldList) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLetOrVarKeyword: UnexpectedNodesSyntax? = nil, - letOrVarKeyword: TokenSyntax, - _ unexpectedBetweenLetOrVarKeywordAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax? = nil, - _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, + elementList: YieldExprListSyntax, + _ unexpectedBetweenElementListAndRightParen: 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(), (unexpectedBeforeLetOrVarKeyword, letOrVarKeyword, unexpectedBetweenLetOrVarKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndElementList, elementList, unexpectedBetweenElementListAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLetOrVarKeyword?.raw, - letOrVarKeyword.raw, - unexpectedBetweenLetOrVarKeywordAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer?.raw, - unexpectedAfterInitializer?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndElementList?.raw, + elementList.raw, + unexpectedBetweenElementListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.optionalBindingCondition, from: layout, arena: arena, + kind: SyntaxKind.yieldList, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLetOrVarKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLetOrVarKeyword(value) + self = withUnexpectedBeforeLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLetOrVarKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeLetOrVarKeyword` to replace the node's - /// current `unexpectedBeforeLetOrVarKeyword`, if present. - public func withUnexpectedBeforeLetOrVarKeyword(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. + /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's + /// current `unexpectedBeforeLeftParen`, if present. + public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) + return YieldListSyntax(newData) } - public var letOrVarKeyword: TokenSyntax { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLetOrVarKeyword(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `letOrVarKeyword` replaced. - /// - param newChild: The new `letOrVarKeyword` to replace the node's - /// current `letOrVarKeyword`, if present. - public func withLetOrVarKeyword(_ newChild: TokenSyntax) -> OptionalBindingConditionSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> YieldListSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) + return YieldListSyntax(newData) } - public var unexpectedBetweenLetOrVarKeywordAndPattern: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLetOrVarKeywordAndPattern(value) + self = withUnexpectedBetweenLeftParenAndElementList(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLetOrVarKeywordAndPattern` replaced. - /// - param newChild: The new `unexpectedBetweenLetOrVarKeywordAndPattern` to replace the node's - /// current `unexpectedBetweenLetOrVarKeywordAndPattern`, if present. - public func withUnexpectedBetweenLetOrVarKeywordAndPattern(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndElementList` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndElementList` to replace the node's + /// current `unexpectedBetweenLeftParenAndElementList`, if present. + public func withUnexpectedBetweenLeftParenAndElementList(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) + return YieldListSyntax(newData) } - public var pattern: PatternSyntax { + public var elementList: YieldExprListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return PatternSyntax(childData!) + return YieldExprListSyntax(childData!) } set(value) { - self = withPattern(value) + self = withElementList(value) } } - /// Returns a copy of the receiver with its `pattern` replaced. - /// - param newChild: The new `pattern` to replace the node's - /// current `pattern`, if present. - public func withPattern(_ newChild: PatternSyntax) -> OptionalBindingConditionSyntax { + /// Adds the provided `Element` to the node's `elementList` + /// collection. + /// - param element: The new `Element` to add to the node's + /// `elementList` collection. + /// - returns: A copy of the receiver with the provided `Element` + /// appended to its `elementList` collection. + public func addElement(_ element: YieldExprListElementSyntax) -> YieldListSyntax { + 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.yieldExprList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return YieldListSyntax(newData) + } + + /// Returns a copy of the receiver with its `elementList` replaced. + /// - param newChild: The new `elementList` to replace the node's + /// current `elementList`, if present. + public func withElementList(_ newChild: YieldExprListSyntax) -> YieldListSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) + return YieldListSyntax(newData) } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + public var unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPatternAndTypeAnnotation(value) + self = withUnexpectedBetweenElementListAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndTypeAnnotation` replaced. - /// - param newChild: The new `unexpectedBetweenPatternAndTypeAnnotation` to replace the node's - /// current `unexpectedBetweenPatternAndTypeAnnotation`, if present. - public func withUnexpectedBetweenPatternAndTypeAnnotation(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenElementListAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenElementListAndRightParen` to replace the node's + /// current `unexpectedBetweenElementListAndRightParen`, if present. + public func withUnexpectedBetweenElementListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) + return YieldListSyntax(newData) } - public var typeAnnotation: TypeAnnotationSyntax? { + public var rightParen: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TypeAnnotationSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withTypeAnnotation(value) + self = withRightParen(value) } } - /// Returns a copy of the receiver with its `typeAnnotation` replaced. - /// - param newChild: The new `typeAnnotation` to replace the node's - /// current `typeAnnotation`, if present. - public func withTypeAnnotation(_ newChild: TypeAnnotationSyntax?) -> OptionalBindingConditionSyntax { + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> YieldListSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) + return YieldListSyntax(newData) } - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenTypeAnnotationAndInitializer(value) + self = withUnexpectedAfterRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenTypeAnnotationAndInitializer` replaced. - /// - param newChild: The new `unexpectedBetweenTypeAnnotationAndInitializer` to replace the node's - /// current `unexpectedBetweenTypeAnnotationAndInitializer`, if present. - public func withUnexpectedBetweenTypeAnnotationAndInitializer(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> YieldListSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) - } - - public var initializer: InitializerClauseSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return InitializerClauseSyntax(childData!) - } - set(value) { - self = withInitializer(value) - } - } - - /// Returns a copy of the receiver with its `initializer` replaced. - /// - param newChild: The new `initializer` to replace the node's - /// current `initializer`, if present. - public func withInitializer(_ newChild: InitializerClauseSyntax?) -> OptionalBindingConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) - } - - public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterInitializer(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterInitializer` replaced. - /// - param newChild: The new `unexpectedAfterInitializer` to replace the node's - /// current `unexpectedAfterInitializer`, if present. - public func withUnexpectedAfterInitializer(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return OptionalBindingConditionSyntax(newData) + return YieldListSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLetOrVarKeyword, - \Self.letOrVarKeyword, - \Self.unexpectedBetweenLetOrVarKeywordAndPattern, - \Self.pattern, - \Self.unexpectedBetweenPatternAndTypeAnnotation, - \Self.typeAnnotation, - \Self.unexpectedBetweenTypeAnnotationAndInitializer, - \Self.initializer, - \Self.unexpectedAfterInitializer, + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndElementList, + \Self.elementList, + \Self.unexpectedBetweenElementListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -20572,281 +20407,248 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil - case 7: - return nil - case 8: + default: + fatalError("Invalid index") + } + } +} + +extension YieldListSyntax: 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), + "unexpectedBetweenLeftParenAndElementList": unexpectedBetweenLeftParenAndElementList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "elementList": Syntax(elementList).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenElementListAndRightParen": unexpectedBetweenElementListAndRightParen.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: - ConditionElementSyntax + +public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { + public enum Condition: SyntaxChildChoices { + case `expression`(ExprSyntax) + case `availability`(AvailabilityConditionSyntax) + case `matchingPattern`(MatchingPatternConditionSyntax) + case `optionalBinding`(OptionalBindingConditionSyntax) + case `hasSymbol`(HasSymbolConditionSyntax) + 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 + case .hasSymbol(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: HasSymbolConditionSyntax) { + self = .hasSymbol(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 + } + if let node = node.as(HasSymbolConditionSyntax.self) { + self = .hasSymbol(node) + return + } return nil - default: - fatalError("Invalid index") } - } -} -extension OptionalBindingConditionSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeLetOrVarKeyword": unexpectedBeforeLetOrVarKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "letOrVarKeyword": Syntax(letOrVarKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLetOrVarKeywordAndPattern": unexpectedBetweenLetOrVarKeywordAndPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "initializer": initializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterInitializer": unexpectedAfterInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(ExprSyntax.self), + .node(AvailabilityConditionSyntax.self), + .node(MatchingPatternConditionSyntax.self), + .node(OptionalBindingConditionSyntax.self), + .node(HasSymbolConditionSyntax.self), + ]) + } } -} - -// MARK: - HasSymbolConditionSyntax -public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .hasSymbolCondition else { return nil } + guard node.raw.kind == .conditionElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `HasSymbolConditionSyntax` 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) { - assert(data.raw.kind == .hasSymbolCondition) + assert(data.raw.kind == .conditionElement) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeHasSymbolKeyword: UnexpectedNodesSyntax? = nil, - hasSymbolKeyword: TokenSyntax, - _ unexpectedBetweenHasSymbolKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: 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(), (unexpectedBeforeHasSymbolKeyword, hasSymbolKeyword, unexpectedBetweenHasSymbolKeywordAndLeftParen, leftParen, unexpectedBetweenLeftParenAndExpression, expression, unexpectedBetweenExpressionAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCondition, condition, unexpectedBetweenConditionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeHasSymbolKeyword?.raw, - hasSymbolKeyword.raw, - unexpectedBetweenHasSymbolKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeCondition?.raw, + condition.raw, + unexpectedBetweenConditionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.hasSymbolCondition, from: layout, arena: arena, + kind: SyntaxKind.conditionElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeHasSymbolKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeHasSymbolKeyword(value) + self = withUnexpectedBeforeCondition(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeHasSymbolKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeHasSymbolKeyword` to replace the node's - /// current `unexpectedBeforeHasSymbolKeyword`, if present. - public func withUnexpectedBeforeHasSymbolKeyword(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeCondition` replaced. + /// - param newChild: The new `unexpectedBeforeCondition` to replace the node's + /// current `unexpectedBeforeCondition`, if present. + public func withUnexpectedBeforeCondition(_ newChild: UnexpectedNodesSyntax?) -> ConditionElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return ConditionElementSyntax(newData) } - public var hasSymbolKeyword: TokenSyntax { + public var condition: Condition { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return Condition(childData!) } set(value) { - self = withHasSymbolKeyword(value) + self = withCondition(value) } } - /// Returns a copy of the receiver with its `hasSymbolKeyword` replaced. - /// - param newChild: The new `hasSymbolKeyword` to replace the node's - /// current `hasSymbolKeyword`, if present. - public func withHasSymbolKeyword(_ newChild: TokenSyntax) -> HasSymbolConditionSyntax { + /// Returns a copy of the receiver with its `condition` replaced. + /// - param newChild: The new `condition` to replace the node's + /// current `condition`, if present. + public func withCondition(_ newChild: Condition) -> ConditionElementSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return ConditionElementSyntax(newData) } - public var unexpectedBetweenHasSymbolKeywordAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenHasSymbolKeywordAndLeftParen(value) + self = withUnexpectedBetweenConditionAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenHasSymbolKeywordAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenHasSymbolKeywordAndLeftParen` to replace the node's - /// current `unexpectedBetweenHasSymbolKeywordAndLeftParen`, if present. - public func withUnexpectedBetweenHasSymbolKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenConditionAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenConditionAndTrailingComma` to replace the node's + /// current `unexpectedBetweenConditionAndTrailingComma`, if present. + public func withUnexpectedBetweenConditionAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ConditionElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return ConditionElementSyntax(newData) } - public var leftParen: TokenSyntax { + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax) -> HasSymbolConditionSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> ConditionElementSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return ConditionElementSyntax(newData) } - public var unexpectedBetweenLeftParenAndExpression: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndExpression(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndExpression` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndExpression` to replace the node's - /// current `unexpectedBetweenLeftParenAndExpression`, if present. - public func withUnexpectedBetweenLeftParenAndExpression(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> ConditionElementSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) - } - - public var expression: ExprSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withExpression(value) - } - } - - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax) -> HasSymbolConditionSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) - } - - public var unexpectedBetweenExpressionAndRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenExpressionAndRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndRightParen` to replace the node's - /// current `unexpectedBetweenExpressionAndRightParen`, if present. - public func withUnexpectedBetweenExpressionAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) - } - - public var rightParen: TokenSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withRightParen(value) - } - } - - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax) -> HasSymbolConditionSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return ConditionElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeHasSymbolKeyword, - \Self.hasSymbolKeyword, - \Self.unexpectedBetweenHasSymbolKeywordAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeCondition, + \Self.condition, + \Self.unexpectedBetweenConditionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -20860,15 +20662,7 @@ public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { return nil case 3: return nil - case 4: - return nil - case 5: - return nil - case 6: - return nil - case 7: - return nil - case 8: + case 4: return nil default: fatalError("Invalid index") @@ -20876,280 +20670,286 @@ public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { } } -extension HasSymbolConditionSyntax: CustomReflectable { +extension ConditionElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeHasSymbolKeyword": unexpectedBeforeHasSymbolKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "hasSymbolKeyword": Syntax(hasSymbolKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenHasSymbolKeywordAndLeftParen": unexpectedBetweenHasSymbolKeywordAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndExpression": unexpectedBetweenLeftParenAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenExpressionAndRightParen": unexpectedBetweenExpressionAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.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: - SwitchCaseSyntax - -public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { - public enum Label: SyntaxChildChoices { - case `default`(SwitchDefaultLabelSyntax) - case `case`(SwitchCaseLabelSyntax) - public var _syntaxNode: Syntax { - switch self { - case .default(let node): return node._syntaxNode - case .case(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: SwitchDefaultLabelSyntax) { - self = .default(node) - } - public init(_ node: SwitchCaseLabelSyntax) { - self = .case(node) - } - public init?(_ node: S) { - if let node = node.as(SwitchDefaultLabelSyntax.self) { - self = .default(node) - return - } - if let node = node.as(SwitchCaseLabelSyntax.self) { - self = .case(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(SwitchDefaultLabelSyntax.self), - .node(SwitchCaseLabelSyntax.self), - ]) - } - } +// MARK: - AvailabilityConditionSyntax +public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchCase else { return nil } + guard node.raw.kind == .availabilityCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchCaseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AvailabilityConditionSyntax` 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) { - assert(data.raw.kind == .switchCase) + assert(data.raw.kind == .availabilityCondition) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, - unknownAttr: AttributeSyntax? = nil, - _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, - label: Label, - _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? = nil, + availabilityKeyword: TokenSyntax, + _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, + availabilitySpec: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // 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(), (unexpectedBeforeUnknownAttr, unknownAttr, unexpectedBetweenUnknownAttrAndLabel, label, unexpectedBetweenLabelAndStatements, statements, unexpectedAfterStatements))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAvailabilityKeyword, availabilityKeyword, unexpectedBetweenAvailabilityKeywordAndLeftParen, leftParen, unexpectedBetweenLeftParenAndAvailabilitySpec, availabilitySpec, unexpectedBetweenAvailabilitySpecAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeUnknownAttr?.raw, - unknownAttr?.raw, - unexpectedBetweenUnknownAttrAndLabel?.raw, - label.raw, - unexpectedBetweenLabelAndStatements?.raw, - statements.raw, - unexpectedAfterStatements?.raw, + unexpectedBeforeAvailabilityKeyword?.raw, + availabilityKeyword.raw, + unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, + availabilitySpec.raw, + unexpectedBetweenAvailabilitySpecAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchCase, from: layout, arena: arena, + kind: SyntaxKind.availabilityCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? { + public var unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeUnknownAttr(value) + self = withUnexpectedBeforeAvailabilityKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeUnknownAttr` replaced. - /// - param newChild: The new `unexpectedBeforeUnknownAttr` to replace the node's - /// current `unexpectedBeforeUnknownAttr`, if present. - public func withUnexpectedBeforeUnknownAttr(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAvailabilityKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeAvailabilityKeyword` to replace the node's + /// current `unexpectedBeforeAvailabilityKeyword`, if present. + public func withUnexpectedBeforeAvailabilityKeyword(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var unknownAttr: AttributeSyntax? { + public var availabilityKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } - return AttributeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withUnknownAttr(value) + self = withAvailabilityKeyword(value) } } - /// Returns a copy of the receiver with its `unknownAttr` replaced. - /// - param newChild: The new `unknownAttr` to replace the node's - /// current `unknownAttr`, if present. - public func withUnknownAttr(_ newChild: AttributeSyntax?) -> SwitchCaseSyntax { + /// Returns a copy of the receiver with its `availabilityKeyword` replaced. + /// - param newChild: The new `availabilityKeyword` to replace the node's + /// current `availabilityKeyword`, if present. + public func withAvailabilityKeyword(_ newChild: TokenSyntax) -> AvailabilityConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenUnknownAttrAndLabel(value) + self = withUnexpectedBetweenAvailabilityKeywordAndLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenUnknownAttrAndLabel` replaced. - /// - param newChild: The new `unexpectedBetweenUnknownAttrAndLabel` to replace the node's - /// current `unexpectedBetweenUnknownAttrAndLabel`, if present. - public func withUnexpectedBetweenUnknownAttrAndLabel(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilityKeywordAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenAvailabilityKeywordAndLeftParen` to replace the node's + /// current `unexpectedBetweenAvailabilityKeywordAndLeftParen`, if present. + public func withUnexpectedBetweenAvailabilityKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var label: Label { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return Label(childData!) + return TokenSyntax(childData!) } set(value) { - self = withLabel(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `label` replaced. - /// - param newChild: The new `label` to replace the node's - /// current `label`, if present. - public func withLabel(_ newChild: Label) -> SwitchCaseSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLabelAndStatements(value) + self = withUnexpectedBetweenLeftParenAndAvailabilitySpec(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLabelAndStatements` replaced. - /// - param newChild: The new `unexpectedBetweenLabelAndStatements` to replace the node's - /// current `unexpectedBetweenLabelAndStatements`, if present. - public func withUnexpectedBetweenLabelAndStatements(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndAvailabilitySpec` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndAvailabilitySpec` to replace the node's + /// current `unexpectedBetweenLeftParenAndAvailabilitySpec`, if present. + public func withUnexpectedBetweenLeftParenAndAvailabilitySpec(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var statements: CodeBlockItemListSyntax { + public var availabilitySpec: AvailabilitySpecListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return CodeBlockItemListSyntax(childData!) + return AvailabilitySpecListSyntax(childData!) } set(value) { - self = withStatements(value) + self = withAvailabilitySpec(value) } } - /// Adds the provided `Statement` to the node's `statements` + /// Adds the provided `AvailabilityArgument` to the node's `availabilitySpec` /// 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) -> SwitchCaseSyntax { + /// - param element: The new `AvailabilityArgument` to add to the node's + /// `availabilitySpec` collection. + /// - returns: A copy of the receiver with the provided `AvailabilityArgument` + /// appended to its `availabilitySpec` collection. + public func addAvailabilityArgument(_ element: AvailabilityArgumentSyntax) -> AvailabilityConditionSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return SwitchCaseSyntax(newData) + return AvailabilityConditionSyntax(newData) } - /// Returns a copy of the receiver with its `statements` replaced. - /// - param newChild: The new `statements` to replace the node's - /// current `statements`, if present. - public func withStatements(_ newChild: CodeBlockItemListSyntax) -> SwitchCaseSyntax { + /// Returns a copy of the receiver with its `availabilitySpec` replaced. + /// - param newChild: The new `availabilitySpec` to replace the node's + /// current `availabilitySpec`, if present. + public func withAvailabilitySpec(_ newChild: AvailabilitySpecListSyntax) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var unexpectedAfterStatements: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterStatements(value) + self = withUnexpectedBetweenAvailabilitySpecAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterStatements` replaced. - /// - param newChild: The new `unexpectedAfterStatements` to replace the node's - /// current `unexpectedAfterStatements`, if present. - public func withUnexpectedAfterStatements(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAvailabilitySpecAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenAvailabilitySpecAndRightParen` to replace the node's + /// current `unexpectedBetweenAvailabilitySpecAndRightParen`, if present. + public func withUnexpectedBetweenAvailabilitySpecAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return AvailabilityConditionSyntax(newData) + } + + public var rightParen: TokenSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withRightParen(value) + } + } + + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> AvailabilityConditionSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return AvailabilityConditionSyntax(newData) + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightParen(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return AvailabilityConditionSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeUnknownAttr, - \Self.unknownAttr, - \Self.unexpectedBetweenUnknownAttrAndLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndStatements, - \Self.statements, - \Self.unexpectedAfterStatements, + \Self.unexpectedBeforeAvailabilityKeyword, + \Self.availabilityKeyword, + \Self.unexpectedBetweenAvailabilityKeywordAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, + \Self.availabilitySpec, + \Self.unexpectedBetweenAvailabilitySpecAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -21162,188 +20962,289 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "label" + return nil case 4: return nil case 5: return nil case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension SwitchCaseSyntax: CustomReflectable { +extension AvailabilityConditionSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeUnknownAttr": unexpectedBeforeUnknownAttr.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unknownAttr": unknownAttr.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenUnknownAttrAndLabel": unexpectedBetweenUnknownAttrAndLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "label": Syntax(label).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLabelAndStatements": unexpectedBetweenLabelAndStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), - "unexpectedAfterStatements": unexpectedAfterStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeAvailabilityKeyword": unexpectedBeforeAvailabilityKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "availabilityKeyword": Syntax(availabilityKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAvailabilityKeywordAndLeftParen": unexpectedBetweenAvailabilityKeywordAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndAvailabilitySpec": unexpectedBetweenLeftParenAndAvailabilitySpec.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "availabilitySpec": Syntax(availabilitySpec).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAvailabilitySpecAndRightParen": unexpectedBetweenAvailabilitySpecAndRightParen.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: - SwitchDefaultLabelSyntax +// MARK: - MatchingPatternConditionSyntax -public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { +public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchDefaultLabel else { return nil } + guard node.raw.kind == .matchingPatternCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchDefaultLabelSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `MatchingPatternConditionSyntax` 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) { - assert(data.raw.kind == .switchDefaultLabel) + assert(data.raw.kind == .matchingPatternCondition) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, - defaultKeyword: TokenSyntax = .keyword(.default), - _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .keyword(.case), + _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax, + _ unexpectedAfterInitializer: 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(), (unexpectedBeforeDefaultKeyword, defaultKeyword, unexpectedBetweenDefaultKeywordAndColon, colon, unexpectedAfterColon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDefaultKeyword?.raw, - defaultKeyword.raw, - unexpectedBetweenDefaultKeywordAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, + unexpectedBeforeCaseKeyword?.raw, + caseKeyword.raw, + unexpectedBetweenCaseKeywordAndPattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer.raw, + unexpectedAfterInitializer?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchDefaultLabel, from: layout, arena: arena, + kind: SyntaxKind.matchingPatternCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeDefaultKeyword(value) + self = withUnexpectedBeforeCaseKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeDefaultKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeDefaultKeyword` to replace the node's - /// current `unexpectedBeforeDefaultKeyword`, if present. - public func withUnexpectedBeforeDefaultKeyword(_ newChild: UnexpectedNodesSyntax?) -> SwitchDefaultLabelSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeCaseKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeCaseKeyword` to replace the node's + /// current `unexpectedBeforeCaseKeyword`, if present. + public func withUnexpectedBeforeCaseKeyword(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var defaultKeyword: TokenSyntax { + public var caseKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withDefaultKeyword(value) + self = withCaseKeyword(value) } } - /// Returns a copy of the receiver with its `defaultKeyword` replaced. - /// - param newChild: The new `defaultKeyword` to replace the node's - /// current `defaultKeyword`, if present. - public func withDefaultKeyword(_ newChild: TokenSyntax) -> SwitchDefaultLabelSyntax { + /// Returns a copy of the receiver with its `caseKeyword` replaced. + /// - param newChild: The new `caseKeyword` to replace the node's + /// current `caseKeyword`, if present. + public func withCaseKeyword(_ newChild: TokenSyntax) -> MatchingPatternConditionSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDefaultKeywordAndColon(value) + self = withUnexpectedBetweenCaseKeywordAndPattern(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenDefaultKeywordAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenDefaultKeywordAndColon` to replace the node's - /// current `unexpectedBetweenDefaultKeywordAndColon`, if present. - public func withUnexpectedBetweenDefaultKeywordAndColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchDefaultLabelSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCaseKeywordAndPattern` replaced. + /// - param newChild: The new `unexpectedBetweenCaseKeywordAndPattern` to replace the node's + /// current `unexpectedBetweenCaseKeywordAndPattern`, if present. + public func withUnexpectedBetweenCaseKeywordAndPattern(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var colon: TokenSyntax { + public var pattern: PatternSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + return PatternSyntax(childData!) } set(value) { - self = withColon(value) + self = withPattern(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> SwitchDefaultLabelSyntax { + /// Returns a copy of the receiver with its `pattern` replaced. + /// - param newChild: The new `pattern` to replace the node's + /// current `pattern`, if present. + public func withPattern(_ newChild: PatternSyntax) -> MatchingPatternConditionSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var unexpectedAfterColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterColon(value) + self = withUnexpectedBetweenPatternAndTypeAnnotation(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterColon` replaced. - /// - param newChild: The new `unexpectedAfterColon` to replace the node's - /// current `unexpectedAfterColon`, if present. - public func withUnexpectedAfterColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchDefaultLabelSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndTypeAnnotation` replaced. + /// - param newChild: The new `unexpectedBetweenPatternAndTypeAnnotation` to replace the node's + /// current `unexpectedBetweenPatternAndTypeAnnotation`, if present. + public func withUnexpectedBetweenPatternAndTypeAnnotation(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return MatchingPatternConditionSyntax(newData) + } + + public var typeAnnotation: TypeAnnotationSyntax? { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } + return TypeAnnotationSyntax(childData!) + } + set(value) { + self = withTypeAnnotation(value) + } + } + + /// Returns a copy of the receiver with its `typeAnnotation` replaced. + /// - param newChild: The new `typeAnnotation` to replace the node's + /// current `typeAnnotation`, if present. + public func withTypeAnnotation(_ newChild: TypeAnnotationSyntax?) -> MatchingPatternConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return MatchingPatternConditionSyntax(newData) + } + + public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenTypeAnnotationAndInitializer(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenTypeAnnotationAndInitializer` replaced. + /// - param newChild: The new `unexpectedBetweenTypeAnnotationAndInitializer` to replace the node's + /// current `unexpectedBetweenTypeAnnotationAndInitializer`, if present. + public func withUnexpectedBetweenTypeAnnotationAndInitializer(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return MatchingPatternConditionSyntax(newData) + } + + public var initializer: InitializerClauseSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return InitializerClauseSyntax(childData!) + } + set(value) { + self = withInitializer(value) + } + } + + /// Returns a copy of the receiver with its `initializer` replaced. + /// - param newChild: The new `initializer` to replace the node's + /// current `initializer`, if present. + public func withInitializer(_ newChild: InitializerClauseSyntax) -> MatchingPatternConditionSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return MatchingPatternConditionSyntax(newData) + } + + public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterInitializer(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterInitializer` replaced. + /// - param newChild: The new `unexpectedAfterInitializer` to replace the node's + /// current `unexpectedAfterInitializer`, if present. + public func withUnexpectedAfterInitializer(_ newChild: UnexpectedNodesSyntax?) -> MatchingPatternConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return MatchingPatternConditionSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDefaultKeyword, - \Self.defaultKeyword, - \Self.unexpectedBetweenDefaultKeywordAndColon, - \Self.colon, - \Self.unexpectedAfterColon, + \Self.unexpectedBeforeCaseKeyword, + \Self.caseKeyword, + \Self.unexpectedBetweenCaseKeywordAndPattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedAfterInitializer, ]) } @@ -21359,228 +21260,287 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension SwitchDefaultLabelSyntax: CustomReflectable { +extension MatchingPatternConditionSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeDefaultKeyword": unexpectedBeforeDefaultKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "defaultKeyword": Syntax(defaultKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDefaultKeywordAndColon": unexpectedBetweenDefaultKeywordAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedAfterColon": unexpectedAfterColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeCaseKeyword": unexpectedBeforeCaseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "caseKeyword": Syntax(caseKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCaseKeywordAndPattern": unexpectedBetweenCaseKeywordAndPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "initializer": Syntax(initializer).asProtocol(SyntaxProtocol.self), + "unexpectedAfterInitializer": unexpectedAfterInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - CaseItemSyntax +// MARK: - OptionalBindingConditionSyntax -public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { +public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .caseItem else { return nil } + guard node.raw.kind == .optionalBindingCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `CaseItemSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `OptionalBindingConditionSyntax` 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) { - assert(data.raw.kind == .caseItem) + assert(data.raw.kind == .optionalBindingCondition) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLetOrVarKeyword: UnexpectedNodesSyntax? = nil, + letOrVarKeyword: TokenSyntax, + _ unexpectedBetweenLetOrVarKeywordAndPattern: UnexpectedNodesSyntax? = nil, pattern: P, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax? = nil, + _ unexpectedAfterInitializer: 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(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndWhereClause, whereClause, unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLetOrVarKeyword, letOrVarKeyword, unexpectedBetweenLetOrVarKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, + unexpectedBeforeLetOrVarKeyword?.raw, + letOrVarKeyword.raw, + unexpectedBetweenLetOrVarKeywordAndPattern?.raw, pattern.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer?.raw, + unexpectedAfterInitializer?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.caseItem, from: layout, arena: arena, + kind: SyntaxKind.optionalBindingCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePattern: UnexpectedNodesSyntax? { + public var unexpectedBeforeLetOrVarKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePattern(value) + self = withUnexpectedBeforeLetOrVarKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. - /// - param newChild: The new `unexpectedBeforePattern` to replace the node's - /// current `unexpectedBeforePattern`, if present. - public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLetOrVarKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeLetOrVarKeyword` to replace the node's + /// current `unexpectedBeforeLetOrVarKeyword`, if present. + public func withUnexpectedBeforeLetOrVarKeyword(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return CaseItemSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var pattern: PatternSyntax { + public var letOrVarKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return PatternSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withPattern(value) + self = withLetOrVarKeyword(value) } } - /// Returns a copy of the receiver with its `pattern` replaced. - /// - param newChild: The new `pattern` to replace the node's - /// current `pattern`, if present. - public func withPattern(_ newChild: PatternSyntax) -> CaseItemSyntax { + /// Returns a copy of the receiver with its `letOrVarKeyword` replaced. + /// - param newChild: The new `letOrVarKeyword` to replace the node's + /// current `letOrVarKeyword`, if present. + public func withLetOrVarKeyword(_ newChild: TokenSyntax) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return CaseItemSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenLetOrVarKeywordAndPattern: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPatternAndWhereClause(value) + self = withUnexpectedBetweenLetOrVarKeywordAndPattern(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndWhereClause` replaced. - /// - param newChild: The new `unexpectedBetweenPatternAndWhereClause` to replace the node's - /// current `unexpectedBetweenPatternAndWhereClause`, if present. - public func withUnexpectedBetweenPatternAndWhereClause(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLetOrVarKeywordAndPattern` replaced. + /// - param newChild: The new `unexpectedBetweenLetOrVarKeywordAndPattern` to replace the node's + /// current `unexpectedBetweenLetOrVarKeywordAndPattern`, if present. + public func withUnexpectedBetweenLetOrVarKeywordAndPattern(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return CaseItemSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var whereClause: WhereClauseSyntax? { + public var pattern: PatternSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return WhereClauseSyntax(childData!) + return PatternSyntax(childData!) } set(value) { - self = withWhereClause(value) + self = withPattern(value) } } - /// Returns a copy of the receiver with its `whereClause` replaced. - /// - param newChild: The new `whereClause` to replace the node's - /// current `whereClause`, if present. - public func withWhereClause(_ newChild: WhereClauseSyntax?) -> CaseItemSyntax { + /// Returns a copy of the receiver with its `pattern` replaced. + /// - param newChild: The new `pattern` to replace the node's + /// current `pattern`, if present. + public func withPattern(_ newChild: PatternSyntax) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return CaseItemSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenWhereClauseAndTrailingComma(value) + self = withUnexpectedBetweenPatternAndTypeAnnotation(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenWhereClauseAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenWhereClauseAndTrailingComma` to replace the node's - /// current `unexpectedBetweenWhereClauseAndTrailingComma`, if present. - public func withUnexpectedBetweenWhereClauseAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndTypeAnnotation` replaced. + /// - param newChild: The new `unexpectedBetweenPatternAndTypeAnnotation` to replace the node's + /// current `unexpectedBetweenPatternAndTypeAnnotation`, if present. + public func withUnexpectedBetweenPatternAndTypeAnnotation(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return CaseItemSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var typeAnnotation: TypeAnnotationSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) if childData == nil { return nil } - return TokenSyntax(childData!) + return TypeAnnotationSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withTypeAnnotation(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> CaseItemSyntax { + /// Returns a copy of the receiver with its `typeAnnotation` replaced. + /// - param newChild: The new `typeAnnotation` to replace the node's + /// current `typeAnnotation`, if present. + public func withTypeAnnotation(_ newChild: TypeAnnotationSyntax?) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return CaseItemSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenTypeAnnotationAndInitializer(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CaseItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenTypeAnnotationAndInitializer` replaced. + /// - param newChild: The new `unexpectedBetweenTypeAnnotationAndInitializer` to replace the node's + /// current `unexpectedBetweenTypeAnnotationAndInitializer`, if present. + public func withUnexpectedBetweenTypeAnnotationAndInitializer(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return CaseItemSyntax(newData) + return OptionalBindingConditionSyntax(newData) + } + + public var initializer: InitializerClauseSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return InitializerClauseSyntax(childData!) + } + set(value) { + self = withInitializer(value) + } + } + + /// Returns a copy of the receiver with its `initializer` replaced. + /// - param newChild: The new `initializer` to replace the node's + /// current `initializer`, if present. + public func withInitializer(_ newChild: InitializerClauseSyntax?) -> OptionalBindingConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return OptionalBindingConditionSyntax(newData) + } + + public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterInitializer(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterInitializer` replaced. + /// - param newChild: The new `unexpectedAfterInitializer` to replace the node's + /// current `unexpectedAfterInitializer`, if present. + public func withUnexpectedAfterInitializer(_ newChild: UnexpectedNodesSyntax?) -> OptionalBindingConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return OptionalBindingConditionSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePattern, + \Self.unexpectedBeforeLetOrVarKeyword, + \Self.letOrVarKeyword, + \Self.unexpectedBetweenLetOrVarKeywordAndPattern, \Self.pattern, - \Self.unexpectedBetweenPatternAndWhereClause, - \Self.whereClause, - \Self.unexpectedBetweenWhereClauseAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedAfterInitializer, ]) } @@ -21600,265 +21560,281 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension CaseItemSyntax: CustomReflectable { +extension OptionalBindingConditionSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLetOrVarKeyword": unexpectedBeforeLetOrVarKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "letOrVarKeyword": Syntax(letOrVarKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLetOrVarKeywordAndPattern": unexpectedBetweenLetOrVarKeywordAndPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPatternAndWhereClause": unexpectedBetweenPatternAndWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "whereClause": whereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenWhereClauseAndTrailingComma": unexpectedBetweenWhereClauseAndTrailingComma.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, + "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "initializer": initializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterInitializer": unexpectedAfterInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - CatchItemSyntax +// MARK: - HasSymbolConditionSyntax -public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { +public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .catchItem else { return nil } + guard node.raw.kind == .hasSymbolCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `CatchItemSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `HasSymbolConditionSyntax` 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) { - assert(data.raw.kind == .catchItem) + assert(data.raw.kind == .hasSymbolCondition) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: P? = nil, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeHasSymbolKeyword: UnexpectedNodesSyntax? = nil, + hasSymbolKeyword: TokenSyntax, + _ unexpectedBetweenHasSymbolKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndRightParen: 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(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndWhereClause, whereClause, unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeHasSymbolKeyword, hasSymbolKeyword, unexpectedBetweenHasSymbolKeywordAndLeftParen, leftParen, unexpectedBetweenLeftParenAndExpression, expression, unexpectedBetweenExpressionAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern?.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeHasSymbolKeyword?.raw, + hasSymbolKeyword.raw, + unexpectedBetweenHasSymbolKeywordAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.catchItem, from: layout, arena: arena, + kind: SyntaxKind.hasSymbolCondition, 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, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: MissingPatternSyntax? = nil, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforePattern, - pattern: Optional.none, - unexpectedBetweenPatternAndWhereClause, - whereClause: whereClause, - unexpectedBetweenWhereClauseAndTrailingComma, - trailingComma: trailingComma, - unexpectedAfterTrailingComma, - trailingTrivia: trailingTrivia - ) - } - - public var unexpectedBeforePattern: UnexpectedNodesSyntax? { + public var unexpectedBeforeHasSymbolKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePattern(value) + self = withUnexpectedBeforeHasSymbolKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. - /// - param newChild: The new `unexpectedBeforePattern` to replace the node's - /// current `unexpectedBeforePattern`, if present. - public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeHasSymbolKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeHasSymbolKeyword` to replace the node's + /// current `unexpectedBeforeHasSymbolKeyword`, if present. + public func withUnexpectedBeforeHasSymbolKeyword(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return CatchItemSyntax(newData) + return HasSymbolConditionSyntax(newData) } - public var pattern: PatternSyntax? { + public var hasSymbolKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } - return PatternSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withPattern(value) + self = withHasSymbolKeyword(value) } } - /// Returns a copy of the receiver with its `pattern` replaced. - /// - param newChild: The new `pattern` to replace the node's - /// current `pattern`, if present. - public func withPattern(_ newChild: PatternSyntax?) -> CatchItemSyntax { + /// Returns a copy of the receiver with its `hasSymbolKeyword` replaced. + /// - param newChild: The new `hasSymbolKeyword` to replace the node's + /// current `hasSymbolKeyword`, if present. + public func withHasSymbolKeyword(_ newChild: TokenSyntax) -> HasSymbolConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return CatchItemSyntax(newData) + return HasSymbolConditionSyntax(newData) } - public var unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenHasSymbolKeywordAndLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPatternAndWhereClause(value) + self = withUnexpectedBetweenHasSymbolKeywordAndLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndWhereClause` replaced. - /// - param newChild: The new `unexpectedBetweenPatternAndWhereClause` to replace the node's - /// current `unexpectedBetweenPatternAndWhereClause`, if present. - public func withUnexpectedBetweenPatternAndWhereClause(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenHasSymbolKeywordAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenHasSymbolKeywordAndLeftParen` to replace the node's + /// current `unexpectedBetweenHasSymbolKeywordAndLeftParen`, if present. + public func withUnexpectedBetweenHasSymbolKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return CatchItemSyntax(newData) + return HasSymbolConditionSyntax(newData) } - public var whereClause: WhereClauseSyntax? { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return WhereClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withWhereClause(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `whereClause` replaced. - /// - param newChild: The new `whereClause` to replace the node's - /// current `whereClause`, if present. - public func withWhereClause(_ newChild: WhereClauseSyntax?) -> CatchItemSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax) -> HasSymbolConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return CatchItemSyntax(newData) + return HasSymbolConditionSyntax(newData) } - public var unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenWhereClauseAndTrailingComma(value) + self = withUnexpectedBetweenLeftParenAndExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenWhereClauseAndTrailingComma` replaced. - /// - param newChild: The new `unexpectedBetweenWhereClauseAndTrailingComma` to replace the node's - /// current `unexpectedBetweenWhereClauseAndTrailingComma`, if present. - public func withUnexpectedBetweenWhereClauseAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndExpression` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndExpression` to replace the node's + /// current `unexpectedBetweenLeftParenAndExpression`, if present. + public func withUnexpectedBetweenLeftParenAndExpression(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return CatchItemSyntax(newData) + return HasSymbolConditionSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var expression: ExprSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `trailingComma` replaced. - /// - param newChild: The new `trailingComma` to replace the node's - /// current `trailingComma`, if present. - public func withTrailingComma(_ newChild: TokenSyntax?) -> CatchItemSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax) -> HasSymbolConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return CatchItemSyntax(newData) + return HasSymbolConditionSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenExpressionAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. - /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's - /// current `unexpectedAfterTrailingComma`, if present. - public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndRightParen` to replace the node's + /// current `unexpectedBetweenExpressionAndRightParen`, if present. + public func withUnexpectedBetweenExpressionAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return CatchItemSyntax(newData) + return HasSymbolConditionSyntax(newData) + } + + public var rightParen: TokenSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withRightParen(value) + } + } + + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax) -> HasSymbolConditionSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return HasSymbolConditionSyntax(newData) + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightParen(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> HasSymbolConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return HasSymbolConditionSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePattern, - \Self.pattern, - \Self.unexpectedBetweenPatternAndWhereClause, - \Self.whereClause, - \Self.unexpectedBetweenWhereClauseAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeHasSymbolKeyword, + \Self.hasSymbolKeyword, + \Self.unexpectedBetweenHasSymbolKeywordAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -21878,247 +21854,271 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension CatchItemSyntax: CustomReflectable { +extension HasSymbolConditionSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "pattern": pattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenPatternAndWhereClause": unexpectedBetweenPatternAndWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "whereClause": whereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenWhereClauseAndTrailingComma": unexpectedBetweenWhereClauseAndTrailingComma.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, + "unexpectedBeforeHasSymbolKeyword": unexpectedBeforeHasSymbolKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "hasSymbolKeyword": Syntax(hasSymbolKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenHasSymbolKeywordAndLeftParen": unexpectedBetweenHasSymbolKeywordAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndExpression": unexpectedBetweenLeftParenAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndRightParen": unexpectedBetweenExpressionAndRightParen.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: - SwitchCaseLabelSyntax +// MARK: - CatchItemSyntax -public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { +public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchCaseLabel else { return nil } + guard node.raw.kind == .catchItem else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchCaseLabelSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `CatchItemSyntax` 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) { - assert(data.raw.kind == .switchCaseLabel) + assert(data.raw.kind == .catchItem) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .keyword(.case), - _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, - caseItems: CaseItemListSyntax, - _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P? = nil, + _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndTrailingComma: 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(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndCaseItems, caseItems, unexpectedBetweenCaseItemsAndColon, colon, unexpectedAfterColon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndWhereClause, whereClause, unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndCaseItems?.raw, - caseItems.raw, - unexpectedBetweenCaseItemsAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, + unexpectedBeforePattern?.raw, + pattern?.raw, + unexpectedBetweenPatternAndWhereClause?.raw, + whereClause?.raw, + unexpectedBetweenWhereClauseAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchCaseLabel, from: layout, arena: arena, + kind: SyntaxKind.catchItem, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { + /// 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, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: MissingPatternSyntax? = nil, + _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforePattern, + pattern: Optional.none, + unexpectedBetweenPatternAndWhereClause, + whereClause: whereClause, + unexpectedBetweenWhereClauseAndTrailingComma, + trailingComma: trailingComma, + unexpectedAfterTrailingComma, + trailingTrivia: trailingTrivia + ) + } + + public var unexpectedBeforePattern: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeCaseKeyword(value) + self = withUnexpectedBeforePattern(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeCaseKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeCaseKeyword` to replace the node's - /// current `unexpectedBeforeCaseKeyword`, if present. - public func withUnexpectedBeforeCaseKeyword(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. + /// - param newChild: The new `unexpectedBeforePattern` to replace the node's + /// current `unexpectedBeforePattern`, if present. + public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SwitchCaseLabelSyntax(newData) + return CatchItemSyntax(newData) } - public var caseKeyword: TokenSyntax { + public var pattern: PatternSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return PatternSyntax(childData!) } set(value) { - self = withCaseKeyword(value) + self = withPattern(value) } } - /// Returns a copy of the receiver with its `caseKeyword` replaced. - /// - param newChild: The new `caseKeyword` to replace the node's - /// current `caseKeyword`, if present. - public func withCaseKeyword(_ newChild: TokenSyntax) -> SwitchCaseLabelSyntax { + /// Returns a copy of the receiver with its `pattern` replaced. + /// - param newChild: The new `pattern` to replace the node's + /// current `pattern`, if present. + public func withPattern(_ newChild: PatternSyntax?) -> CatchItemSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SwitchCaseLabelSyntax(newData) + return CatchItemSyntax(newData) } - public var unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCaseKeywordAndCaseItems(value) + self = withUnexpectedBetweenPatternAndWhereClause(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCaseKeywordAndCaseItems` replaced. - /// - param newChild: The new `unexpectedBetweenCaseKeywordAndCaseItems` to replace the node's - /// current `unexpectedBetweenCaseKeywordAndCaseItems`, if present. - public func withUnexpectedBetweenCaseKeywordAndCaseItems(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenPatternAndWhereClause` replaced. + /// - param newChild: The new `unexpectedBetweenPatternAndWhereClause` to replace the node's + /// current `unexpectedBetweenPatternAndWhereClause`, if present. + public func withUnexpectedBetweenPatternAndWhereClause(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SwitchCaseLabelSyntax(newData) + return CatchItemSyntax(newData) } - public var caseItems: CaseItemListSyntax { + public var whereClause: WhereClauseSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return CaseItemListSyntax(childData!) + if childData == nil { return nil } + return WhereClauseSyntax(childData!) } set(value) { - self = withCaseItems(value) - } - } - - /// Adds the provided `CaseItem` to the node's `caseItems` - /// collection. - /// - param element: The new `CaseItem` to add to the node's - /// `caseItems` collection. - /// - returns: A copy of the receiver with the provided `CaseItem` - /// appended to its `caseItems` collection. - public func addCaseItem(_ element: CaseItemSyntax) -> SwitchCaseLabelSyntax { - 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.caseItemList, - from: [element.raw], arena: arena) + self = withWhereClause(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return SwitchCaseLabelSyntax(newData) } - /// Returns a copy of the receiver with its `caseItems` replaced. - /// - param newChild: The new `caseItems` to replace the node's - /// current `caseItems`, if present. - public func withCaseItems(_ newChild: CaseItemListSyntax) -> SwitchCaseLabelSyntax { + /// Returns a copy of the receiver with its `whereClause` replaced. + /// - param newChild: The new `whereClause` to replace the node's + /// current `whereClause`, if present. + public func withWhereClause(_ newChild: WhereClauseSyntax?) -> CatchItemSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SwitchCaseLabelSyntax(newData) + return CatchItemSyntax(newData) } - public var unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCaseItemsAndColon(value) + self = withUnexpectedBetweenWhereClauseAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCaseItemsAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenCaseItemsAndColon` to replace the node's - /// current `unexpectedBetweenCaseItemsAndColon`, if present. - public func withUnexpectedBetweenCaseItemsAndColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenWhereClauseAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenWhereClauseAndTrailingComma` to replace the node's + /// current `unexpectedBetweenWhereClauseAndTrailingComma`, if present. + public func withUnexpectedBetweenWhereClauseAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SwitchCaseLabelSyntax(newData) + return CatchItemSyntax(newData) } - public var colon: TokenSyntax { + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withTrailingComma(value) } } - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax) -> SwitchCaseLabelSyntax { + /// Returns a copy of the receiver with its `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> CatchItemSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return SwitchCaseLabelSyntax(newData) + return CatchItemSyntax(newData) } - public var unexpectedAfterColon: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterColon(value) + self = withUnexpectedAfterTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterColon` replaced. - /// - param newChild: The new `unexpectedAfterColon` to replace the node's - /// current `unexpectedAfterColon`, if present. - public func withUnexpectedAfterColon(_ newChild: UnexpectedNodesSyntax?) -> SwitchCaseLabelSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> CatchItemSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return SwitchCaseLabelSyntax(newData) + return CatchItemSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeCaseKeyword, - \Self.caseKeyword, - \Self.unexpectedBetweenCaseKeywordAndCaseItems, - \Self.caseItems, - \Self.unexpectedBetweenCaseItemsAndColon, - \Self.colon, - \Self.unexpectedAfterColon, + \Self.unexpectedBeforePattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndWhereClause, + \Self.whereClause, + \Self.unexpectedBetweenWhereClauseAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -22144,16 +22144,16 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { } } -extension SwitchCaseLabelSyntax: CustomReflectable { +extension CatchItemSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeCaseKeyword": unexpectedBeforeCaseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "caseKeyword": Syntax(caseKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCaseKeywordAndCaseItems": unexpectedBetweenCaseKeywordAndCaseItems.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "caseItems": Syntax(caseItems).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCaseItemsAndColon": unexpectedBetweenCaseItemsAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedAfterColon": unexpectedAfterColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "pattern": pattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenPatternAndWhereClause": unexpectedBetweenPatternAndWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "whereClause": whereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenWhereClauseAndTrailingComma": unexpectedBetweenWhereClauseAndTrailingComma.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, ]) } } diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift index 11397f20703..bac72b905c6 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift @@ -302,6 +302,141 @@ extension LabeledStmtSyntax: CustomReflectable { } } +// MARK: - ExpressionStmtSyntax + +public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .expressionStmt else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `ExpressionStmtSyntax` 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) { + assert(data.raw.kind == .expressionStmt) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: 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(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedAfterExpression?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.expressionStmt, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 0, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBeforeExpression(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. + /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's + /// current `unexpectedBeforeExpression`, if present. + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> ExpressionStmtSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return ExpressionStmtSyntax(newData) + } + + public var expression: ExprSyntax { + get { + let childData = data.child(at: 1, parent: Syntax(self)) + return ExprSyntax(childData!) + } + set(value) { + self = withExpression(value) + } + } + + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax) -> ExpressionStmtSyntax { + let arena = SyntaxArena() + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return ExpressionStmtSyntax(newData) + } + + public var unexpectedAfterExpression: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 2, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterExpression(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterExpression` replaced. + /// - param newChild: The new `unexpectedAfterExpression` to replace the node's + /// current `unexpectedAfterExpression`, if present. + public func withUnexpectedAfterExpression(_ newChild: UnexpectedNodesSyntax?) -> ExpressionStmtSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return ExpressionStmtSyntax(newData) + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedAfterExpression, + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + default: + fatalError("Invalid index") + } + } +} + +extension ExpressionStmtSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeExpression": unexpectedBeforeExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedAfterExpression": unexpectedAfterExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + // MARK: - ContinueStmtSyntax public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { @@ -2163,322 +2298,229 @@ extension ForInStmtSyntax: CustomReflectable { } } -// MARK: - SwitchStmtSyntax +// MARK: - DoStmtSyntax -public struct SwitchStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { +public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchStmt else { return nil } + guard node.raw.kind == .doStmt else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchStmtSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DoStmtSyntax` 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) { - assert(data.raw.kind == .switchStmt) + assert(data.raw.kind == .doStmt) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, - switchKeyword: TokenSyntax = .keyword(.switch), - _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, - cases: SwitchCaseListSyntax, - _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? = nil, + doKeyword: TokenSyntax = .keyword(.do), + _ unexpectedBetweenDoKeywordAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedBetweenBodyAndCatchClauses: UnexpectedNodesSyntax? = nil, + catchClauses: CatchClauseListSyntax? = nil, + _ unexpectedAfterCatchClauses: 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(), (unexpectedBeforeSwitchKeyword, switchKeyword, unexpectedBetweenSwitchKeywordAndExpression, expression, unexpectedBetweenExpressionAndLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndCases, cases, unexpectedBetweenCasesAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDoKeyword, doKeyword, unexpectedBetweenDoKeywordAndBody, body, unexpectedBetweenBodyAndCatchClauses, catchClauses, unexpectedAfterCatchClauses))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSwitchKeyword?.raw, - switchKeyword.raw, - unexpectedBetweenSwitchKeywordAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndCases?.raw, - cases.raw, - unexpectedBetweenCasesAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, + unexpectedBeforeDoKeyword?.raw, + doKeyword.raw, + unexpectedBetweenDoKeywordAndBody?.raw, + body.raw, + unexpectedBetweenBodyAndCatchClauses?.raw, + catchClauses?.raw, + unexpectedAfterCatchClauses?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchStmt, from: layout, arena: arena, + kind: SyntaxKind.doStmt, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeSwitchKeyword(value) + self = withUnexpectedBeforeDoKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeSwitchKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeSwitchKeyword` to replace the node's - /// current `unexpectedBeforeSwitchKeyword`, if present. - public func withUnexpectedBeforeSwitchKeyword(_ newChild: UnexpectedNodesSyntax?) -> SwitchStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeDoKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeDoKeyword` to replace the node's + /// current `unexpectedBeforeDoKeyword`, if present. + public func withUnexpectedBeforeDoKeyword(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SwitchStmtSyntax(newData) + return DoStmtSyntax(newData) } - public var switchKeyword: TokenSyntax { + public var doKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withSwitchKeyword(value) + self = withDoKeyword(value) } } - /// Returns a copy of the receiver with its `switchKeyword` replaced. - /// - param newChild: The new `switchKeyword` to replace the node's - /// current `switchKeyword`, if present. - public func withSwitchKeyword(_ newChild: TokenSyntax) -> SwitchStmtSyntax { + /// Returns a copy of the receiver with its `doKeyword` replaced. + /// - param newChild: The new `doKeyword` to replace the node's + /// current `doKeyword`, if present. + public func withDoKeyword(_ newChild: TokenSyntax) -> DoStmtSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SwitchStmtSyntax(newData) + return DoStmtSyntax(newData) } - public var unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? { + public var unexpectedBetweenDoKeywordAndBody: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenSwitchKeywordAndExpression(value) + self = withUnexpectedBetweenDoKeywordAndBody(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenSwitchKeywordAndExpression` replaced. - /// - param newChild: The new `unexpectedBetweenSwitchKeywordAndExpression` to replace the node's - /// current `unexpectedBetweenSwitchKeywordAndExpression`, if present. - public func withUnexpectedBetweenSwitchKeywordAndExpression(_ newChild: UnexpectedNodesSyntax?) -> SwitchStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDoKeywordAndBody` replaced. + /// - param newChild: The new `unexpectedBetweenDoKeywordAndBody` to replace the node's + /// current `unexpectedBetweenDoKeywordAndBody`, if present. + public func withUnexpectedBetweenDoKeywordAndBody(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SwitchStmtSyntax(newData) + return DoStmtSyntax(newData) } - public var expression: ExprSyntax { + public var body: CodeBlockSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return ExprSyntax(childData!) + return CodeBlockSyntax(childData!) } set(value) { - self = withExpression(value) + self = withBody(value) } } - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax) -> SwitchStmtSyntax { + /// Returns a copy of the receiver with its `body` replaced. + /// - param newChild: The new `body` to replace the node's + /// current `body`, if present. + public func withBody(_ newChild: CodeBlockSyntax) -> DoStmtSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SwitchStmtSyntax(newData) + return DoStmtSyntax(newData) } - public var unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenBodyAndCatchClauses: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionAndLeftBrace(value) + self = withUnexpectedBetweenBodyAndCatchClauses(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndLeftBrace` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndLeftBrace` to replace the node's - /// current `unexpectedBetweenExpressionAndLeftBrace`, if present. - public func withUnexpectedBetweenExpressionAndLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> SwitchStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenBodyAndCatchClauses` replaced. + /// - param newChild: The new `unexpectedBetweenBodyAndCatchClauses` to replace the node's + /// current `unexpectedBetweenBodyAndCatchClauses`, if present. + public func withUnexpectedBetweenBodyAndCatchClauses(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SwitchStmtSyntax(newData) + return DoStmtSyntax(newData) } - public var leftBrace: TokenSyntax { + public var catchClauses: CatchClauseListSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withLeftBrace(value) - } - } - - /// Returns a copy of the receiver with its `leftBrace` replaced. - /// - param newChild: The new `leftBrace` to replace the node's - /// current `leftBrace`, if present. - public func withLeftBrace(_ newChild: TokenSyntax) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return SwitchStmtSyntax(newData) - } - - public var unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLeftBraceAndCases(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndCases` replaced. - /// - param newChild: The new `unexpectedBetweenLeftBraceAndCases` to replace the node's - /// current `unexpectedBetweenLeftBraceAndCases`, if present. - public func withUnexpectedBetweenLeftBraceAndCases(_ newChild: UnexpectedNodesSyntax?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return SwitchStmtSyntax(newData) - } - - public var cases: SwitchCaseListSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return SwitchCaseListSyntax(childData!) + return CatchClauseListSyntax(childData!) } set(value) { - self = withCases(value) + self = withCatchClauses(value) } } - /// Adds the provided `Case` to the node's `cases` + /// Adds the provided `CatchClause` to the node's `catchClauses` /// collection. - /// - param element: The new `Case` to add to the node's - /// `cases` collection. - /// - returns: A copy of the receiver with the provided `Case` - /// appended to its `cases` collection. - public func addCase(_ element: Syntax) -> SwitchStmtSyntax { + /// - param element: The new `CatchClause` to add to the node's + /// `catchClauses` collection. + /// - returns: A copy of the receiver with the provided `CatchClause` + /// appended to its `catchClauses` collection. + public func addCatchClause(_ element: CatchClauseSyntax) -> DoStmtSyntax { var collection: RawSyntax let arena = SyntaxArena() - if let col = raw.layoutView!.children[7] { + if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, from: [element.raw], arena: arena) } - let newData = data.replacingChild(at: 7, with: collection, arena: arena) - return SwitchStmtSyntax(newData) + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return DoStmtSyntax(newData) } - /// Returns a copy of the receiver with its `cases` replaced. - /// - param newChild: The new `cases` to replace the node's - /// current `cases`, if present. - public func withCases(_ newChild: SwitchCaseListSyntax) -> SwitchStmtSyntax { + /// Returns a copy of the receiver with its `catchClauses` replaced. + /// - param newChild: The new `catchClauses` to replace the node's + /// current `catchClauses`, if present. + public func withCatchClauses(_ newChild: CatchClauseListSyntax?) -> DoStmtSyntax { let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return SwitchStmtSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return DoStmtSyntax(newData) } - public var unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedAfterCatchClauses: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCasesAndRightBrace(value) + self = withUnexpectedAfterCatchClauses(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCasesAndRightBrace` replaced. - /// - param newChild: The new `unexpectedBetweenCasesAndRightBrace` to replace the node's - /// current `unexpectedBetweenCasesAndRightBrace`, if present. - public func withUnexpectedBetweenCasesAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> SwitchStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterCatchClauses` replaced. + /// - param newChild: The new `unexpectedAfterCatchClauses` to replace the node's + /// current `unexpectedAfterCatchClauses`, if present. + public func withUnexpectedAfterCatchClauses(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return SwitchStmtSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return DoStmtSyntax(newData) } - public var rightBrace: TokenSyntax { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withRightBrace(value) - } - } - - /// Returns a copy of the receiver with its `rightBrace` replaced. - /// - param newChild: The new `rightBrace` to replace the node's - /// current `rightBrace`, if present. - public func withRightBrace(_ newChild: TokenSyntax) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return SwitchStmtSyntax(newData) - } - - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 10, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterRightBrace(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. - /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's - /// current `unexpectedAfterRightBrace`, if present. - public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return SwitchStmtSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeSwitchKeyword, - \Self.switchKeyword, - \Self.unexpectedBetweenSwitchKeywordAndExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndLeftBrace, - \Self.leftBrace, - \Self.unexpectedBetweenLeftBraceAndCases, - \Self.cases, - \Self.unexpectedBetweenCasesAndRightBrace, - \Self.rightBrace, - \Self.unexpectedAfterRightBrace, - ]) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeDoKeyword, + \Self.doKeyword, + \Self.unexpectedBetweenDoKeywordAndBody, + \Self.body, + \Self.unexpectedBetweenBodyAndCatchClauses, + \Self.catchClauses, + \Self.unexpectedAfterCatchClauses, + ]) } public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { @@ -2490,857 +2532,219 @@ public struct SwitchStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "body" 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 SwitchStmtSyntax: CustomReflectable { +extension DoStmtSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeSwitchKeyword": unexpectedBeforeSwitchKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "switchKeyword": Syntax(switchKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenSwitchKeywordAndExpression": unexpectedBetweenSwitchKeywordAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenExpressionAndLeftBrace": unexpectedBetweenExpressionAndLeftBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftBrace": Syntax(leftBrace).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftBraceAndCases": unexpectedBetweenLeftBraceAndCases.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "cases": Syntax(cases).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCasesAndRightBrace": unexpectedBetweenCasesAndRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightBrace": Syntax(rightBrace).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightBrace": unexpectedAfterRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeDoKeyword": unexpectedBeforeDoKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "doKeyword": Syntax(doKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDoKeywordAndBody": unexpectedBetweenDoKeywordAndBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "body": Syntax(body).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenBodyAndCatchClauses": unexpectedBetweenBodyAndCatchClauses.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "catchClauses": catchClauses.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterCatchClauses": unexpectedAfterCatchClauses.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DoStmtSyntax +// MARK: - ReturnStmtSyntax -public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { +public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .doStmt else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `DoStmtSyntax` 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) { - assert(data.raw.kind == .doStmt) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? = nil, - doKeyword: TokenSyntax = .keyword(.do), - _ unexpectedBetweenDoKeywordAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedBetweenBodyAndCatchClauses: UnexpectedNodesSyntax? = nil, - catchClauses: CatchClauseListSyntax? = nil, - _ unexpectedAfterCatchClauses: 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(), (unexpectedBeforeDoKeyword, doKeyword, unexpectedBetweenDoKeywordAndBody, body, unexpectedBetweenBodyAndCatchClauses, catchClauses, unexpectedAfterCatchClauses))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDoKeyword?.raw, - doKeyword.raw, - unexpectedBetweenDoKeywordAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndCatchClauses?.raw, - catchClauses?.raw, - unexpectedAfterCatchClauses?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.doStmt, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeDoKeyword(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeDoKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeDoKeyword` to replace the node's - /// current `unexpectedBeforeDoKeyword`, if present. - public func withUnexpectedBeforeDoKeyword(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DoStmtSyntax(newData) - } - - public var doKeyword: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withDoKeyword(value) - } - } - - /// Returns a copy of the receiver with its `doKeyword` replaced. - /// - param newChild: The new `doKeyword` to replace the node's - /// current `doKeyword`, if present. - public func withDoKeyword(_ newChild: TokenSyntax) -> DoStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DoStmtSyntax(newData) - } - - public var unexpectedBetweenDoKeywordAndBody: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenDoKeywordAndBody(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenDoKeywordAndBody` replaced. - /// - param newChild: The new `unexpectedBetweenDoKeywordAndBody` to replace the node's - /// current `unexpectedBetweenDoKeywordAndBody`, if present. - public func withUnexpectedBetweenDoKeywordAndBody(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DoStmtSyntax(newData) - } - - public var body: CodeBlockSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return CodeBlockSyntax(childData!) - } - set(value) { - self = withBody(value) - } - } - - /// Returns a copy of the receiver with its `body` replaced. - /// - param newChild: The new `body` to replace the node's - /// current `body`, if present. - public func withBody(_ newChild: CodeBlockSyntax) -> DoStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DoStmtSyntax(newData) - } - - public var unexpectedBetweenBodyAndCatchClauses: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenBodyAndCatchClauses(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenBodyAndCatchClauses` replaced. - /// - param newChild: The new `unexpectedBetweenBodyAndCatchClauses` to replace the node's - /// current `unexpectedBetweenBodyAndCatchClauses`, if present. - public func withUnexpectedBetweenBodyAndCatchClauses(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DoStmtSyntax(newData) - } - - public var catchClauses: CatchClauseListSyntax? { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return CatchClauseListSyntax(childData!) - } - set(value) { - self = withCatchClauses(value) - } - } - - /// Adds the provided `CatchClause` to the node's `catchClauses` - /// collection. - /// - param element: The new `CatchClause` to add to the node's - /// `catchClauses` collection. - /// - returns: A copy of the receiver with the provided `CatchClause` - /// appended to its `catchClauses` collection. - public func addCatchClause(_ element: CatchClauseSyntax) -> DoStmtSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[5] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return DoStmtSyntax(newData) - } - - /// Returns a copy of the receiver with its `catchClauses` replaced. - /// - param newChild: The new `catchClauses` to replace the node's - /// current `catchClauses`, if present. - public func withCatchClauses(_ newChild: CatchClauseListSyntax?) -> DoStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DoStmtSyntax(newData) - } - - public var unexpectedAfterCatchClauses: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterCatchClauses(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterCatchClauses` replaced. - /// - param newChild: The new `unexpectedAfterCatchClauses` to replace the node's - /// current `unexpectedAfterCatchClauses`, if present. - public func withUnexpectedAfterCatchClauses(_ newChild: UnexpectedNodesSyntax?) -> DoStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DoStmtSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeDoKeyword, - \Self.doKeyword, - \Self.unexpectedBetweenDoKeywordAndBody, - \Self.body, - \Self.unexpectedBetweenBodyAndCatchClauses, - \Self.catchClauses, - \Self.unexpectedAfterCatchClauses, - ]) - } - - 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 "body" - case 4: - return nil - case 5: - return nil - case 6: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension DoStmtSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeDoKeyword": unexpectedBeforeDoKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "doKeyword": Syntax(doKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDoKeywordAndBody": unexpectedBetweenDoKeywordAndBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "body": Syntax(body).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenBodyAndCatchClauses": unexpectedBetweenBodyAndCatchClauses.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "catchClauses": catchClauses.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterCatchClauses": unexpectedAfterCatchClauses.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - ReturnStmtSyntax - -public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .returnStmt else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `ReturnStmtSyntax` 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) { - assert(data.raw.kind == .returnStmt) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, - returnKeyword: TokenSyntax = .keyword(.return), - _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E? = nil, - _ unexpectedAfterExpression: 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(), (unexpectedBeforeReturnKeyword, returnKeyword, unexpectedBetweenReturnKeywordAndExpression, expression, unexpectedAfterExpression))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeReturnKeyword?.raw, - returnKeyword.raw, - unexpectedBetweenReturnKeywordAndExpression?.raw, - expression?.raw, - unexpectedAfterExpression?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.returnStmt, 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, - _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, - returnKeyword: TokenSyntax = .keyword(.return), - _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: MissingExprSyntax? = nil, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeReturnKeyword, - returnKeyword: returnKeyword, - unexpectedBetweenReturnKeywordAndExpression, - expression: Optional.none, - unexpectedAfterExpression, - trailingTrivia: trailingTrivia - ) - } - - public var unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeReturnKeyword(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeReturnKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeReturnKeyword` to replace the node's - /// current `unexpectedBeforeReturnKeyword`, if present. - public func withUnexpectedBeforeReturnKeyword(_ newChild: UnexpectedNodesSyntax?) -> ReturnStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ReturnStmtSyntax(newData) - } - - public var returnKeyword: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withReturnKeyword(value) - } - } - - /// Returns a copy of the receiver with its `returnKeyword` replaced. - /// - param newChild: The new `returnKeyword` to replace the node's - /// current `returnKeyword`, if present. - public func withReturnKeyword(_ newChild: TokenSyntax) -> ReturnStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ReturnStmtSyntax(newData) - } - - public var unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenReturnKeywordAndExpression(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenReturnKeywordAndExpression` replaced. - /// - param newChild: The new `unexpectedBetweenReturnKeywordAndExpression` to replace the node's - /// current `unexpectedBetweenReturnKeywordAndExpression`, if present. - public func withUnexpectedBetweenReturnKeywordAndExpression(_ newChild: UnexpectedNodesSyntax?) -> ReturnStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ReturnStmtSyntax(newData) - } - - public var expression: ExprSyntax? { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return ExprSyntax(childData!) - } - set(value) { - self = withExpression(value) - } - } - - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax?) -> ReturnStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ReturnStmtSyntax(newData) - } - - public var unexpectedAfterExpression: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterExpression(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterExpression` replaced. - /// - param newChild: The new `unexpectedAfterExpression` to replace the node's - /// current `unexpectedAfterExpression`, if present. - public func withUnexpectedAfterExpression(_ newChild: UnexpectedNodesSyntax?) -> ReturnStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ReturnStmtSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeReturnKeyword, - \Self.returnKeyword, - \Self.unexpectedBetweenReturnKeywordAndExpression, - \Self.expression, - \Self.unexpectedAfterExpression, - ]) - } - - 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 ReturnStmtSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeReturnKeyword": unexpectedBeforeReturnKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "returnKeyword": Syntax(returnKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenReturnKeywordAndExpression": unexpectedBetweenReturnKeywordAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "expression": expression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterExpression": unexpectedAfterExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - YieldStmtSyntax - -public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { - public enum Yields: SyntaxChildChoices { - case `yieldList`(YieldListSyntax) - case `simpleYield`(ExprSyntax) - public var _syntaxNode: Syntax { - switch self { - case .yieldList(let node): return node._syntaxNode - case .simpleYield(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: YieldListSyntax) { - self = .yieldList(node) - } - public init(_ node: Node) { - self = .simpleYield(ExprSyntax(node)) - } - public init?(_ node: S) { - if let node = node.as(YieldListSyntax.self) { - self = .yieldList(node) - return - } - if let node = node.as(ExprSyntax.self) { - self = .simpleYield(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(YieldListSyntax.self), - .node(ExprSyntax.self), - ]) - } - } - - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .yieldStmt else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `YieldStmtSyntax` 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) { - assert(data.raw.kind == .yieldStmt) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeYieldKeyword: UnexpectedNodesSyntax? = nil, - yieldKeyword: TokenSyntax = .keyword(.yield), - _ unexpectedBetweenYieldKeywordAndYields: UnexpectedNodesSyntax? = nil, - yields: Yields, - _ unexpectedAfterYields: 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(), (unexpectedBeforeYieldKeyword, yieldKeyword, unexpectedBetweenYieldKeywordAndYields, yields, unexpectedAfterYields))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeYieldKeyword?.raw, - yieldKeyword.raw, - unexpectedBetweenYieldKeywordAndYields?.raw, - yields.raw, - unexpectedAfterYields?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldStmt, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeYieldKeyword: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeYieldKeyword(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeYieldKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeYieldKeyword` to replace the node's - /// current `unexpectedBeforeYieldKeyword`, if present. - public func withUnexpectedBeforeYieldKeyword(_ newChild: UnexpectedNodesSyntax?) -> YieldStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return YieldStmtSyntax(newData) - } - - public var yieldKeyword: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withYieldKeyword(value) - } - } - - /// Returns a copy of the receiver with its `yieldKeyword` replaced. - /// - param newChild: The new `yieldKeyword` to replace the node's - /// current `yieldKeyword`, if present. - public func withYieldKeyword(_ newChild: TokenSyntax) -> YieldStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return YieldStmtSyntax(newData) - } - - public var unexpectedBetweenYieldKeywordAndYields: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenYieldKeywordAndYields(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenYieldKeywordAndYields` replaced. - /// - param newChild: The new `unexpectedBetweenYieldKeywordAndYields` to replace the node's - /// current `unexpectedBetweenYieldKeywordAndYields`, if present. - public func withUnexpectedBetweenYieldKeywordAndYields(_ newChild: UnexpectedNodesSyntax?) -> YieldStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return YieldStmtSyntax(newData) - } - - public var yields: Yields { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return Yields(childData!) - } - set(value) { - self = withYields(value) - } - } - - /// Returns a copy of the receiver with its `yields` replaced. - /// - param newChild: The new `yields` to replace the node's - /// current `yields`, if present. - public func withYields(_ newChild: Yields) -> YieldStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return YieldStmtSyntax(newData) - } - - public var unexpectedAfterYields: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterYields(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterYields` replaced. - /// - param newChild: The new `unexpectedAfterYields` to replace the node's - /// current `unexpectedAfterYields`, if present. - public func withUnexpectedAfterYields(_ newChild: UnexpectedNodesSyntax?) -> YieldStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return YieldStmtSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeYieldKeyword, - \Self.yieldKeyword, - \Self.unexpectedBetweenYieldKeywordAndYields, - \Self.yields, - \Self.unexpectedAfterYields, - ]) - } - - 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 YieldStmtSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeYieldKeyword": unexpectedBeforeYieldKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "yieldKeyword": Syntax(yieldKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenYieldKeywordAndYields": unexpectedBetweenYieldKeywordAndYields.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "yields": Syntax(yields).asProtocol(SyntaxProtocol.self), - "unexpectedAfterYields": unexpectedAfterYields.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - FallthroughStmtSyntax - -public struct FallthroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .fallthroughStmt else { return nil } + guard node.raw.kind == .returnStmt else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `FallthroughStmtSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ReturnStmtSyntax` 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) { - assert(data.raw.kind == .fallthroughStmt) + assert(data.raw.kind == .returnStmt) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeFallthroughKeyword: UnexpectedNodesSyntax? = nil, - fallthroughKeyword: TokenSyntax = .keyword(.fallthrough), - _ unexpectedAfterFallthroughKeyword: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, + returnKeyword: TokenSyntax = .keyword(.return), + _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E? = nil, + _ unexpectedAfterExpression: 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(), (unexpectedBeforeFallthroughKeyword, fallthroughKeyword, unexpectedAfterFallthroughKeyword))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeReturnKeyword, returnKeyword, unexpectedBetweenReturnKeywordAndExpression, expression, unexpectedAfterExpression))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeFallthroughKeyword?.raw, - fallthroughKeyword.raw, - unexpectedAfterFallthroughKeyword?.raw, + unexpectedBeforeReturnKeyword?.raw, + returnKeyword.raw, + unexpectedBetweenReturnKeywordAndExpression?.raw, + expression?.raw, + unexpectedAfterExpression?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.fallthroughStmt, from: layout, arena: arena, + kind: SyntaxKind.returnStmt, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeFallthroughKeyword: UnexpectedNodesSyntax? { + /// 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, + _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, + returnKeyword: TokenSyntax = .keyword(.return), + _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: MissingExprSyntax? = nil, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeReturnKeyword, + returnKeyword: returnKeyword, + unexpectedBetweenReturnKeywordAndExpression, + expression: Optional.none, + unexpectedAfterExpression, + trailingTrivia: trailingTrivia + ) + } + + public var unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeFallthroughKeyword(value) + self = withUnexpectedBeforeReturnKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeFallthroughKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeFallthroughKeyword` to replace the node's - /// current `unexpectedBeforeFallthroughKeyword`, if present. - public func withUnexpectedBeforeFallthroughKeyword(_ newChild: UnexpectedNodesSyntax?) -> FallthroughStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeReturnKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeReturnKeyword` to replace the node's + /// current `unexpectedBeforeReturnKeyword`, if present. + public func withUnexpectedBeforeReturnKeyword(_ newChild: UnexpectedNodesSyntax?) -> ReturnStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return FallthroughStmtSyntax(newData) + return ReturnStmtSyntax(newData) } - public var fallthroughKeyword: TokenSyntax { + public var returnKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withFallthroughKeyword(value) + self = withReturnKeyword(value) } } - /// Returns a copy of the receiver with its `fallthroughKeyword` replaced. - /// - param newChild: The new `fallthroughKeyword` to replace the node's - /// current `fallthroughKeyword`, if present. - public func withFallthroughKeyword(_ newChild: TokenSyntax) -> FallthroughStmtSyntax { + /// Returns a copy of the receiver with its `returnKeyword` replaced. + /// - param newChild: The new `returnKeyword` to replace the node's + /// current `returnKeyword`, if present. + public func withReturnKeyword(_ newChild: TokenSyntax) -> ReturnStmtSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return FallthroughStmtSyntax(newData) + return ReturnStmtSyntax(newData) } - public var unexpectedAfterFallthroughKeyword: UnexpectedNodesSyntax? { + public var unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterFallthroughKeyword(value) + self = withUnexpectedBetweenReturnKeywordAndExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterFallthroughKeyword` replaced. - /// - param newChild: The new `unexpectedAfterFallthroughKeyword` to replace the node's - /// current `unexpectedAfterFallthroughKeyword`, if present. - public func withUnexpectedAfterFallthroughKeyword(_ newChild: UnexpectedNodesSyntax?) -> FallthroughStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenReturnKeywordAndExpression` replaced. + /// - param newChild: The new `unexpectedBetweenReturnKeywordAndExpression` to replace the node's + /// current `unexpectedBetweenReturnKeywordAndExpression`, if present. + public func withUnexpectedBetweenReturnKeywordAndExpression(_ newChild: UnexpectedNodesSyntax?) -> ReturnStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return FallthroughStmtSyntax(newData) + return ReturnStmtSyntax(newData) + } + + public var expression: ExprSyntax? { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return ExprSyntax(childData!) + } + set(value) { + self = withExpression(value) + } + } + + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax?) -> ReturnStmtSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ReturnStmtSyntax(newData) + } + + public var unexpectedAfterExpression: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterExpression(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterExpression` replaced. + /// - param newChild: The new `unexpectedAfterExpression` to replace the node's + /// current `unexpectedAfterExpression`, if present. + public func withUnexpectedAfterExpression(_ newChild: UnexpectedNodesSyntax?) -> ReturnStmtSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ReturnStmtSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeFallthroughKeyword, - \Self.fallthroughKeyword, - \Self.unexpectedAfterFallthroughKeyword, + \Self.unexpectedBeforeReturnKeyword, + \Self.returnKeyword, + \Self.unexpectedBetweenReturnKeywordAndExpression, + \Self.expression, + \Self.unexpectedAfterExpression, ]) } @@ -3352,178 +2756,219 @@ public struct FallthroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { return nil case 2: return nil + case 3: + return nil + case 4: + return nil default: fatalError("Invalid index") } } } -extension FallthroughStmtSyntax: CustomReflectable { +extension ReturnStmtSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeFallthroughKeyword": unexpectedBeforeFallthroughKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "fallthroughKeyword": Syntax(fallthroughKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedAfterFallthroughKeyword": unexpectedAfterFallthroughKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeReturnKeyword": unexpectedBeforeReturnKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "returnKeyword": Syntax(returnKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenReturnKeywordAndExpression": unexpectedBetweenReturnKeywordAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": expression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterExpression": unexpectedAfterExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - BreakStmtSyntax +// MARK: - YieldStmtSyntax + +public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { + public enum Yields: SyntaxChildChoices { + case `yieldList`(YieldListSyntax) + case `simpleYield`(ExprSyntax) + public var _syntaxNode: Syntax { + switch self { + case .yieldList(let node): return node._syntaxNode + case .simpleYield(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: YieldListSyntax) { + self = .yieldList(node) + } + public init(_ node: Node) { + self = .simpleYield(ExprSyntax(node)) + } + public init?(_ node: S) { + if let node = node.as(YieldListSyntax.self) { + self = .yieldList(node) + return + } + if let node = node.as(ExprSyntax.self) { + self = .simpleYield(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(YieldListSyntax.self), + .node(ExprSyntax.self), + ]) + } + } -public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .breakStmt else { return nil } + guard node.raw.kind == .yieldStmt else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `BreakStmtSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `YieldStmtSyntax` 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) { - assert(data.raw.kind == .breakStmt) + assert(data.raw.kind == .yieldStmt) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBreakKeyword: UnexpectedNodesSyntax? = nil, - breakKeyword: TokenSyntax = .keyword(.break), - _ unexpectedBetweenBreakKeywordAndLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax? = nil, - _ unexpectedAfterLabel: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeYieldKeyword: UnexpectedNodesSyntax? = nil, + yieldKeyword: TokenSyntax = .keyword(.yield), + _ unexpectedBetweenYieldKeywordAndYields: UnexpectedNodesSyntax? = nil, + yields: Yields, + _ unexpectedAfterYields: 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(), (unexpectedBeforeBreakKeyword, breakKeyword, unexpectedBetweenBreakKeywordAndLabel, label, unexpectedAfterLabel))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeYieldKeyword, yieldKeyword, unexpectedBetweenYieldKeywordAndYields, yields, unexpectedAfterYields))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeBreakKeyword?.raw, - breakKeyword.raw, - unexpectedBetweenBreakKeywordAndLabel?.raw, - label?.raw, - unexpectedAfterLabel?.raw, + unexpectedBeforeYieldKeyword?.raw, + yieldKeyword.raw, + unexpectedBetweenYieldKeywordAndYields?.raw, + yields.raw, + unexpectedAfterYields?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.breakStmt, from: layout, arena: arena, + kind: SyntaxKind.yieldStmt, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeBreakKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeYieldKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeBreakKeyword(value) + self = withUnexpectedBeforeYieldKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeBreakKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeBreakKeyword` to replace the node's - /// current `unexpectedBeforeBreakKeyword`, if present. - public func withUnexpectedBeforeBreakKeyword(_ newChild: UnexpectedNodesSyntax?) -> BreakStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeYieldKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeYieldKeyword` to replace the node's + /// current `unexpectedBeforeYieldKeyword`, if present. + public func withUnexpectedBeforeYieldKeyword(_ newChild: UnexpectedNodesSyntax?) -> YieldStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return BreakStmtSyntax(newData) + return YieldStmtSyntax(newData) } - public var breakKeyword: TokenSyntax { + public var yieldKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withBreakKeyword(value) + self = withYieldKeyword(value) } } - /// Returns a copy of the receiver with its `breakKeyword` replaced. - /// - param newChild: The new `breakKeyword` to replace the node's - /// current `breakKeyword`, if present. - public func withBreakKeyword(_ newChild: TokenSyntax) -> BreakStmtSyntax { + /// Returns a copy of the receiver with its `yieldKeyword` replaced. + /// - param newChild: The new `yieldKeyword` to replace the node's + /// current `yieldKeyword`, if present. + public func withYieldKeyword(_ newChild: TokenSyntax) -> YieldStmtSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return BreakStmtSyntax(newData) + return YieldStmtSyntax(newData) } - public var unexpectedBetweenBreakKeywordAndLabel: UnexpectedNodesSyntax? { + public var unexpectedBetweenYieldKeywordAndYields: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenBreakKeywordAndLabel(value) + self = withUnexpectedBetweenYieldKeywordAndYields(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenBreakKeywordAndLabel` replaced. - /// - param newChild: The new `unexpectedBetweenBreakKeywordAndLabel` to replace the node's - /// current `unexpectedBetweenBreakKeywordAndLabel`, if present. - public func withUnexpectedBetweenBreakKeywordAndLabel(_ newChild: UnexpectedNodesSyntax?) -> BreakStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenYieldKeywordAndYields` replaced. + /// - param newChild: The new `unexpectedBetweenYieldKeywordAndYields` to replace the node's + /// current `unexpectedBetweenYieldKeywordAndYields`, if present. + public func withUnexpectedBetweenYieldKeywordAndYields(_ newChild: UnexpectedNodesSyntax?) -> YieldStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return BreakStmtSyntax(newData) + return YieldStmtSyntax(newData) } - public var label: TokenSyntax? { + public var yields: Yields { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return Yields(childData!) } set(value) { - self = withLabel(value) + self = withYields(value) } } - /// Returns a copy of the receiver with its `label` replaced. - /// - param newChild: The new `label` to replace the node's - /// current `label`, if present. - public func withLabel(_ newChild: TokenSyntax?) -> BreakStmtSyntax { + /// Returns a copy of the receiver with its `yields` replaced. + /// - param newChild: The new `yields` to replace the node's + /// current `yields`, if present. + public func withYields(_ newChild: Yields) -> YieldStmtSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return BreakStmtSyntax(newData) + return YieldStmtSyntax(newData) } - public var unexpectedAfterLabel: UnexpectedNodesSyntax? { + public var unexpectedAfterYields: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterLabel(value) + self = withUnexpectedAfterYields(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterLabel` replaced. - /// - param newChild: The new `unexpectedAfterLabel` to replace the node's - /// current `unexpectedAfterLabel`, if present. - public func withUnexpectedAfterLabel(_ newChild: UnexpectedNodesSyntax?) -> BreakStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterYields` replaced. + /// - param newChild: The new `unexpectedAfterYields` to replace the node's + /// current `unexpectedAfterYields`, if present. + public func withUnexpectedAfterYields(_ newChild: UnexpectedNodesSyntax?) -> YieldStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return BreakStmtSyntax(newData) + return YieldStmtSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeBreakKeyword, - \Self.breakKeyword, - \Self.unexpectedBetweenBreakKeywordAndLabel, - \Self.label, - \Self.unexpectedAfterLabel, + \Self.unexpectedBeforeYieldKeyword, + \Self.yieldKeyword, + \Self.unexpectedBetweenYieldKeywordAndYields, + \Self.yields, + \Self.unexpectedAfterYields, ]) } @@ -3536,7 +2981,7 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "label" + return nil case 4: return nil default: @@ -3545,173 +2990,126 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } } -extension BreakStmtSyntax: CustomReflectable { +extension YieldStmtSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeBreakKeyword": unexpectedBeforeBreakKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "breakKeyword": Syntax(breakKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenBreakKeywordAndLabel": unexpectedBetweenBreakKeywordAndLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "label": label.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterLabel": unexpectedAfterLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeYieldKeyword": unexpectedBeforeYieldKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "yieldKeyword": Syntax(yieldKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenYieldKeywordAndYields": unexpectedBetweenYieldKeywordAndYields.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "yields": Syntax(yields).asProtocol(SyntaxProtocol.self), + "unexpectedAfterYields": unexpectedAfterYields.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ThrowStmtSyntax +// MARK: - FallthroughStmtSyntax -public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { +public struct FallthroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .throwStmt else { return nil } + guard node.raw.kind == .fallthroughStmt else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ThrowStmtSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `FallthroughStmtSyntax` 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) { - assert(data.raw.kind == .throwStmt) + assert(data.raw.kind == .fallthroughStmt) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeThrowKeyword: UnexpectedNodesSyntax? = nil, - throwKeyword: TokenSyntax = .keyword(.throw), - _ unexpectedBetweenThrowKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeFallthroughKeyword: UnexpectedNodesSyntax? = nil, + fallthroughKeyword: TokenSyntax = .keyword(.fallthrough), + _ unexpectedAfterFallthroughKeyword: 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(), (unexpectedBeforeThrowKeyword, throwKeyword, unexpectedBetweenThrowKeywordAndExpression, expression, unexpectedAfterExpression))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFallthroughKeyword, fallthroughKeyword, unexpectedAfterFallthroughKeyword))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeThrowKeyword?.raw, - throwKeyword.raw, - unexpectedBetweenThrowKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw, + unexpectedBeforeFallthroughKeyword?.raw, + fallthroughKeyword.raw, + unexpectedAfterFallthroughKeyword?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.throwStmt, from: layout, arena: arena, + kind: SyntaxKind.fallthroughStmt, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeThrowKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeFallthroughKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeThrowKeyword(value) + self = withUnexpectedBeforeFallthroughKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeThrowKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeThrowKeyword` to replace the node's - /// current `unexpectedBeforeThrowKeyword`, if present. - public func withUnexpectedBeforeThrowKeyword(_ newChild: UnexpectedNodesSyntax?) -> ThrowStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeFallthroughKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeFallthroughKeyword` to replace the node's + /// current `unexpectedBeforeFallthroughKeyword`, if present. + public func withUnexpectedBeforeFallthroughKeyword(_ newChild: UnexpectedNodesSyntax?) -> FallthroughStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ThrowStmtSyntax(newData) + return FallthroughStmtSyntax(newData) } - public var throwKeyword: TokenSyntax { + public var fallthroughKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withThrowKeyword(value) + self = withFallthroughKeyword(value) } } - /// Returns a copy of the receiver with its `throwKeyword` replaced. - /// - param newChild: The new `throwKeyword` to replace the node's - /// current `throwKeyword`, if present. - public func withThrowKeyword(_ newChild: TokenSyntax) -> ThrowStmtSyntax { + /// Returns a copy of the receiver with its `fallthroughKeyword` replaced. + /// - param newChild: The new `fallthroughKeyword` to replace the node's + /// current `fallthroughKeyword`, if present. + public func withFallthroughKeyword(_ newChild: TokenSyntax) -> FallthroughStmtSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ThrowStmtSyntax(newData) + return FallthroughStmtSyntax(newData) } - public var unexpectedBetweenThrowKeywordAndExpression: UnexpectedNodesSyntax? { + public var unexpectedAfterFallthroughKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenThrowKeywordAndExpression(value) + self = withUnexpectedAfterFallthroughKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenThrowKeywordAndExpression` replaced. - /// - param newChild: The new `unexpectedBetweenThrowKeywordAndExpression` to replace the node's - /// current `unexpectedBetweenThrowKeywordAndExpression`, if present. - public func withUnexpectedBetweenThrowKeywordAndExpression(_ newChild: UnexpectedNodesSyntax?) -> ThrowStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterFallthroughKeyword` replaced. + /// - param newChild: The new `unexpectedAfterFallthroughKeyword` to replace the node's + /// current `unexpectedAfterFallthroughKeyword`, if present. + public func withUnexpectedAfterFallthroughKeyword(_ newChild: UnexpectedNodesSyntax?) -> FallthroughStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ThrowStmtSyntax(newData) - } - - public var expression: ExprSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withExpression(value) - } - } - - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax) -> ThrowStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ThrowStmtSyntax(newData) - } - - public var unexpectedAfterExpression: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterExpression(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterExpression` replaced. - /// - param newChild: The new `unexpectedAfterExpression` to replace the node's - /// current `unexpectedAfterExpression`, if present. - public func withUnexpectedAfterExpression(_ newChild: UnexpectedNodesSyntax?) -> ThrowStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ThrowStmtSyntax(newData) + return FallthroughStmtSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeThrowKeyword, - \Self.throwKeyword, - \Self.unexpectedBetweenThrowKeywordAndExpression, - \Self.expression, - \Self.unexpectedAfterExpression, + \Self.unexpectedBeforeFallthroughKeyword, + \Self.fallthroughKeyword, + \Self.unexpectedAfterFallthroughKeyword, ]) } @@ -3723,381 +3121,366 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { return nil case 2: return nil - case 3: - return nil - case 4: - return nil default: fatalError("Invalid index") } } } -extension ThrowStmtSyntax: CustomReflectable { +extension FallthroughStmtSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeThrowKeyword": unexpectedBeforeThrowKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "throwKeyword": Syntax(throwKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenThrowKeywordAndExpression": unexpectedBetweenThrowKeywordAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), - "unexpectedAfterExpression": unexpectedAfterExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeFallthroughKeyword": unexpectedBeforeFallthroughKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "fallthroughKeyword": Syntax(fallthroughKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedAfterFallthroughKeyword": unexpectedAfterFallthroughKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - IfStmtSyntax - -public struct IfStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { - public enum ElseBody: SyntaxChildChoices { - case `ifStmt`(IfStmtSyntax) - case `codeBlock`(CodeBlockSyntax) - public var _syntaxNode: Syntax { - switch self { - case .ifStmt(let node): return node._syntaxNode - case .codeBlock(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: IfStmtSyntax) { - self = .ifStmt(node) - } - public init(_ node: CodeBlockSyntax) { - self = .codeBlock(node) - } - public init?(_ node: S) { - if let node = node.as(IfStmtSyntax.self) { - self = .ifStmt(node) - return - } - if let node = node.as(CodeBlockSyntax.self) { - self = .codeBlock(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(IfStmtSyntax.self), - .node(CodeBlockSyntax.self), - ]) - } - } +// MARK: - BreakStmtSyntax +public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .ifStmt else { return nil } + guard node.raw.kind == .breakStmt else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `IfStmtSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `BreakStmtSyntax` 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) { - assert(data.raw.kind == .ifStmt) + assert(data.raw.kind == .breakStmt) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, - ifKeyword: TokenSyntax = .keyword(.if), - _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, - conditions: ConditionElementListSyntax, - _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, - elseKeyword: TokenSyntax? = nil, - _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, - elseBody: ElseBody? = nil, - _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBreakKeyword: UnexpectedNodesSyntax? = nil, + breakKeyword: TokenSyntax = .keyword(.break), + _ unexpectedBetweenBreakKeywordAndLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax? = nil, + _ unexpectedAfterLabel: 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(), (unexpectedBeforeIfKeyword, ifKeyword, unexpectedBetweenIfKeywordAndConditions, conditions, unexpectedBetweenConditionsAndBody, body, unexpectedBetweenBodyAndElseKeyword, elseKeyword, unexpectedBetweenElseKeywordAndElseBody, elseBody, unexpectedAfterElseBody))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBreakKeyword, breakKeyword, unexpectedBetweenBreakKeywordAndLabel, label, unexpectedAfterLabel))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeIfKeyword?.raw, - ifKeyword.raw, - unexpectedBetweenIfKeywordAndConditions?.raw, - conditions.raw, - unexpectedBetweenConditionsAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndElseKeyword?.raw, - elseKeyword?.raw, - unexpectedBetweenElseKeywordAndElseBody?.raw, - elseBody?.raw, - unexpectedAfterElseBody?.raw, + unexpectedBeforeBreakKeyword?.raw, + breakKeyword.raw, + unexpectedBetweenBreakKeywordAndLabel?.raw, + label?.raw, + unexpectedAfterLabel?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifStmt, from: layout, arena: arena, + kind: SyntaxKind.breakStmt, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeBreakKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeIfKeyword(value) + self = withUnexpectedBeforeBreakKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeIfKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeIfKeyword` to replace the node's - /// current `unexpectedBeforeIfKeyword`, if present. - public func withUnexpectedBeforeIfKeyword(_ newChild: UnexpectedNodesSyntax?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeBreakKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeBreakKeyword` to replace the node's + /// current `unexpectedBeforeBreakKeyword`, if present. + public func withUnexpectedBeforeBreakKeyword(_ newChild: UnexpectedNodesSyntax?) -> BreakStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return IfStmtSyntax(newData) + return BreakStmtSyntax(newData) } - public var ifKeyword: TokenSyntax { + public var breakKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withIfKeyword(value) + self = withBreakKeyword(value) } } - /// Returns a copy of the receiver with its `ifKeyword` replaced. - /// - param newChild: The new `ifKeyword` to replace the node's - /// current `ifKeyword`, if present. - public func withIfKeyword(_ newChild: TokenSyntax) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `breakKeyword` replaced. + /// - param newChild: The new `breakKeyword` to replace the node's + /// current `breakKeyword`, if present. + public func withBreakKeyword(_ newChild: TokenSyntax) -> BreakStmtSyntax { let arena = SyntaxArena() let raw = newChild.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return IfStmtSyntax(newData) + return BreakStmtSyntax(newData) } - public var unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? { + public var unexpectedBetweenBreakKeywordAndLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenIfKeywordAndConditions(value) + self = withUnexpectedBetweenBreakKeywordAndLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenIfKeywordAndConditions` replaced. - /// - param newChild: The new `unexpectedBetweenIfKeywordAndConditions` to replace the node's - /// current `unexpectedBetweenIfKeywordAndConditions`, if present. - public func withUnexpectedBetweenIfKeywordAndConditions(_ newChild: UnexpectedNodesSyntax?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenBreakKeywordAndLabel` replaced. + /// - param newChild: The new `unexpectedBetweenBreakKeywordAndLabel` to replace the node's + /// current `unexpectedBetweenBreakKeywordAndLabel`, if present. + public func withUnexpectedBetweenBreakKeywordAndLabel(_ newChild: UnexpectedNodesSyntax?) -> BreakStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return IfStmtSyntax(newData) + return BreakStmtSyntax(newData) } - public var conditions: ConditionElementListSyntax { + public var label: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return ConditionElementListSyntax(childData!) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withConditions(value) - } - } - - /// Adds the provided `Condition` to the node's `conditions` - /// collection. - /// - param element: The new `Condition` to add to the node's - /// `conditions` collection. - /// - returns: A copy of the receiver with the provided `Condition` - /// appended to its `conditions` collection. - public func addCondition(_ element: ConditionElementSyntax) -> IfStmtSyntax { - 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.conditionElementList, - from: [element.raw], arena: arena) + self = withLabel(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return IfStmtSyntax(newData) } - /// Returns a copy of the receiver with its `conditions` replaced. - /// - param newChild: The new `conditions` to replace the node's - /// current `conditions`, if present. - public func withConditions(_ newChild: ConditionElementListSyntax) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel(_ newChild: TokenSyntax?) -> BreakStmtSyntax { let arena = SyntaxArena() - let raw = newChild.raw + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return IfStmtSyntax(newData) + return BreakStmtSyntax(newData) } - public var unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? { + public var unexpectedAfterLabel: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenConditionsAndBody(value) + self = withUnexpectedAfterLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenConditionsAndBody` replaced. - /// - param newChild: The new `unexpectedBetweenConditionsAndBody` to replace the node's - /// current `unexpectedBetweenConditionsAndBody`, if present. - public func withUnexpectedBetweenConditionsAndBody(_ newChild: UnexpectedNodesSyntax?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterLabel` replaced. + /// - param newChild: The new `unexpectedAfterLabel` to replace the node's + /// current `unexpectedAfterLabel`, if present. + public func withUnexpectedAfterLabel(_ newChild: UnexpectedNodesSyntax?) -> BreakStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return IfStmtSyntax(newData) + return BreakStmtSyntax(newData) } - public var body: CodeBlockSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return CodeBlockSyntax(childData!) - } - set(value) { - self = withBody(value) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeBreakKeyword, + \Self.breakKeyword, + \Self.unexpectedBetweenBreakKeywordAndLabel, + \Self.label, + \Self.unexpectedAfterLabel, + ]) + } + + 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 "label" + case 4: + return nil + default: + fatalError("Invalid index") } } +} - /// Returns a copy of the receiver with its `body` replaced. - /// - param newChild: The new `body` to replace the node's - /// current `body`, if present. - public func withBody(_ newChild: CodeBlockSyntax) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return IfStmtSyntax(newData) +extension BreakStmtSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeBreakKeyword": unexpectedBeforeBreakKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "breakKeyword": Syntax(breakKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenBreakKeywordAndLabel": unexpectedBetweenBreakKeywordAndLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "label": label.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterLabel": unexpectedAfterLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + +// MARK: - ThrowStmtSyntax + +public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .throwStmt else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `ThrowStmtSyntax` 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) { + assert(data.raw.kind == .throwStmt) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeThrowKeyword: UnexpectedNodesSyntax? = nil, + throwKeyword: TokenSyntax = .keyword(.throw), + _ unexpectedBetweenThrowKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: 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(), (unexpectedBeforeThrowKeyword, throwKeyword, unexpectedBetweenThrowKeywordAndExpression, expression, unexpectedAfterExpression))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeThrowKeyword?.raw, + throwKeyword.raw, + unexpectedBetweenThrowKeywordAndExpression?.raw, + expression.raw, + unexpectedAfterExpression?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.throwStmt, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) } - public var unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeThrowKeyword: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenBodyAndElseKeyword(value) + self = withUnexpectedBeforeThrowKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenBodyAndElseKeyword` replaced. - /// - param newChild: The new `unexpectedBetweenBodyAndElseKeyword` to replace the node's - /// current `unexpectedBetweenBodyAndElseKeyword`, if present. - public func withUnexpectedBetweenBodyAndElseKeyword(_ newChild: UnexpectedNodesSyntax?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeThrowKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeThrowKeyword` to replace the node's + /// current `unexpectedBeforeThrowKeyword`, if present. + public func withUnexpectedBeforeThrowKeyword(_ newChild: UnexpectedNodesSyntax?) -> ThrowStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return IfStmtSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return ThrowStmtSyntax(newData) } - public var elseKeyword: TokenSyntax? { + public var throwKeyword: TokenSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withElseKeyword(value) + self = withThrowKeyword(value) } } - /// Returns a copy of the receiver with its `elseKeyword` replaced. - /// - param newChild: The new `elseKeyword` to replace the node's - /// current `elseKeyword`, if present. - public func withElseKeyword(_ newChild: TokenSyntax?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `throwKeyword` replaced. + /// - param newChild: The new `throwKeyword` to replace the node's + /// current `throwKeyword`, if present. + public func withThrowKeyword(_ newChild: TokenSyntax) -> ThrowStmtSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return IfStmtSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return ThrowStmtSyntax(newData) } - public var unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowKeywordAndExpression: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenElseKeywordAndElseBody(value) + self = withUnexpectedBetweenThrowKeywordAndExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenElseKeywordAndElseBody` replaced. - /// - param newChild: The new `unexpectedBetweenElseKeywordAndElseBody` to replace the node's - /// current `unexpectedBetweenElseKeywordAndElseBody`, if present. - public func withUnexpectedBetweenElseKeywordAndElseBody(_ newChild: UnexpectedNodesSyntax?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenThrowKeywordAndExpression` replaced. + /// - param newChild: The new `unexpectedBetweenThrowKeywordAndExpression` to replace the node's + /// current `unexpectedBetweenThrowKeywordAndExpression`, if present. + public func withUnexpectedBetweenThrowKeywordAndExpression(_ newChild: UnexpectedNodesSyntax?) -> ThrowStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return IfStmtSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return ThrowStmtSyntax(newData) } - public var elseBody: ElseBody? { + public var expression: ExprSyntax { get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return ElseBody(childData!) + let childData = data.child(at: 3, parent: Syntax(self)) + return ExprSyntax(childData!) } set(value) { - self = withElseBody(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `elseBody` replaced. - /// - param newChild: The new `elseBody` to replace the node's - /// current `elseBody`, if present. - public func withElseBody(_ newChild: ElseBody?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax) -> ThrowStmtSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return IfStmtSyntax(newData) + let raw = newChild.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ThrowStmtSyntax(newData) } - public var unexpectedAfterElseBody: UnexpectedNodesSyntax? { + public var unexpectedAfterExpression: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterElseBody(value) + self = withUnexpectedAfterExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterElseBody` replaced. - /// - param newChild: The new `unexpectedAfterElseBody` to replace the node's - /// current `unexpectedAfterElseBody`, if present. - public func withUnexpectedAfterElseBody(_ newChild: UnexpectedNodesSyntax?) -> IfStmtSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterExpression` replaced. + /// - param newChild: The new `unexpectedAfterExpression` to replace the node's + /// current `unexpectedAfterExpression`, if present. + public func withUnexpectedAfterExpression(_ newChild: UnexpectedNodesSyntax?) -> ThrowStmtSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return IfStmtSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ThrowStmtSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIfKeyword, - \Self.ifKeyword, - \Self.unexpectedBetweenIfKeywordAndConditions, - \Self.conditions, - \Self.unexpectedBetweenConditionsAndBody, - \Self.body, - \Self.unexpectedBetweenBodyAndElseKeyword, - \Self.elseKeyword, - \Self.unexpectedBetweenElseKeywordAndElseBody, - \Self.elseBody, - \Self.unexpectedAfterElseBody, + \Self.unexpectedBeforeThrowKeyword, + \Self.throwKeyword, + \Self.unexpectedBetweenThrowKeywordAndExpression, + \Self.expression, + \Self.unexpectedAfterExpression, ]) } @@ -4113,38 +3496,20 @@ public struct IfStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return "body" - case 6: - return nil - case 7: - return nil - case 8: - return nil - case 9: - return "else body" - case 10: - return nil default: fatalError("Invalid index") } } } -extension IfStmtSyntax: CustomReflectable { +extension ThrowStmtSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeIfKeyword": unexpectedBeforeIfKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "ifKeyword": Syntax(ifKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenIfKeywordAndConditions": unexpectedBetweenIfKeywordAndConditions.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "conditions": Syntax(conditions).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenConditionsAndBody": unexpectedBetweenConditionsAndBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "body": Syntax(body).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenBodyAndElseKeyword": unexpectedBetweenBodyAndElseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "elseKeyword": elseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenElseKeywordAndElseBody": unexpectedBetweenElseKeywordAndElseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "elseBody": elseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterElseBody": unexpectedAfterElseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeThrowKeyword": unexpectedBeforeThrowKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "throwKeyword": Syntax(throwKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenThrowKeywordAndExpression": unexpectedBetweenThrowKeywordAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedAfterExpression": unexpectedAfterExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index 8aed568f7f8..b94c6a68d21 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -713,7 +713,7 @@ extension GuardStmt { } } -extension IfStmt { +extension IfExpr { /// A convenience initializer that allows: /// - Initializing syntax collections using result builders /// - Initializing tokens without default text using strings @@ -1170,7 +1170,7 @@ extension SwitchCase { } } -extension SwitchStmt { +extension SwitchExpr { /// A convenience initializer that allows: /// - Initializing syntax collections using result builders /// - Initializing tokens without default text using strings diff --git a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift index c6c87b9131e..47c1fb5f397 100644 --- a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift +++ b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift @@ -177,6 +177,9 @@ extension ExprSyntax: SyntaxExpressibleByStringInterpolation { extension ExpressionPatternSyntax: SyntaxExpressibleByStringInterpolation { } +extension ExpressionStmtSyntax: SyntaxExpressibleByStringInterpolation { +} + extension ExtensionDeclSyntax: SyntaxExpressibleByStringInterpolation { } @@ -221,7 +224,7 @@ extension IdentifierPatternSyntax: SyntaxExpressibleByStringInterpolation { extension IfConfigDeclSyntax: SyntaxExpressibleByStringInterpolation { } -extension IfStmtSyntax: SyntaxExpressibleByStringInterpolation { +extension IfExprSyntax: SyntaxExpressibleByStringInterpolation { } extension ImplicitlyUnwrappedOptionalTypeSyntax: SyntaxExpressibleByStringInterpolation { @@ -426,7 +429,7 @@ extension SwitchCaseSyntax: SyntaxExpressibleByStringInterpolation { } } -extension SwitchStmtSyntax: SyntaxExpressibleByStringInterpolation { +extension SwitchExprSyntax: SyntaxExpressibleByStringInterpolation { } extension TernaryExprSyntax: SyntaxExpressibleByStringInterpolation { diff --git a/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift b/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift index cb17bbc1808..7609e891345 100644 --- a/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift +++ b/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift @@ -211,6 +211,8 @@ public typealias ExpressionPattern = ExpressionPatternSyntax public typealias ExpressionSegment = ExpressionSegmentSyntax +public typealias ExpressionStmt = ExpressionStmtSyntax + public typealias ExtensionDecl = ExtensionDeclSyntax public typealias FallthroughStmt = FallthroughStmtSyntax @@ -265,7 +267,7 @@ public typealias IfConfigClause = IfConfigClauseSyntax public typealias IfConfigDecl = IfConfigDeclSyntax -public typealias IfStmt = IfStmtSyntax +public typealias IfExpr = IfExprSyntax public typealias ImplementsAttributeArguments = ImplementsAttributeArgumentsSyntax @@ -459,7 +461,7 @@ public typealias SwitchCase = SwitchCaseSyntax public typealias SwitchDefaultLabel = SwitchDefaultLabelSyntax -public typealias SwitchStmt = SwitchStmtSyntax +public typealias SwitchExpr = SwitchExprSyntax public typealias TargetFunctionEntry = TargetFunctionEntrySyntax