From fecc81c0cd914d48c081d7c240866dc083e09f32 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:17 +0000 Subject: [PATCH 1/9] Introduce IfExprSyntax This replaces IfStmtSyntax, and will be wrapped in an ExpressionStmtSyntax when used as a statement. --- gyb_syntax_support/ExprNodes.py | 22 ++++++++++++++++++++++ gyb_syntax_support/StmtNodes.py | 19 ------------------- 2 files changed, 22 insertions(+), 19 deletions(-) diff --git a/gyb_syntax_support/ExprNodes.py b/gyb_syntax_support/ExprNodes.py index ce065a99655..7269b53dc10 100644 --- a/gyb_syntax_support/ExprNodes.py +++ b/gyb_syntax_support/ExprNodes.py @@ -285,6 +285,28 @@ ]) ]), + # if-expr -> identifier? ':'? 'if' condition-list code-block + # else-clause ';'? + # + # This node represents both an 'if' expression, as well as an 'if' statement + # when wrapped in a ExpressionStmt node. + Node('IfExpr', name_for_diagnostics="'if' statement", kind='Expr', + traits=['WithCodeBlock'], + children=[ + Child('IfKeyword', kind='IfToken'), + 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 736ab2c6993..3898539b58b 100644 --- a/gyb_syntax_support/StmtNodes.py +++ b/gyb_syntax_support/StmtNodes.py @@ -271,25 +271,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='IfToken'), - 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 c061f83150799f970f26599199351af3c0e56bfa Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:18 +0000 Subject: [PATCH 2/9] NFC: Move parseIfStatement into Expressions.swift --- Sources/SwiftParser/Expressions.swift | 41 +++++++++++++++++++++++++++ Sources/SwiftParser/Statements.swift | 41 --------------------------- 2 files changed, 41 insertions(+), 41 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 01a0179e0d3..d0fe12a49ef 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -2524,6 +2524,47 @@ extension Parser.Lookahead { } } +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: .elseKeyword) + let elseBody: RawIfStmtSyntax.ElseBody? + if elseKeyword != nil { + if self.at(.ifKeyword) { + elseBody = .ifStmt(self.parseIfStatement(ifHandle: .constant(.ifKeyword))) + } 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 + ) + } +} + // MARK: Lookahead extension Parser.Lookahead { diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index c7115158f08..b054b79a41e 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -130,47 +130,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: .elseKeyword) - let elseBody: RawIfStmtSyntax.ElseBody? - if elseKeyword != nil { - if self.at(.ifKeyword) { - elseBody = .ifStmt(self.parseIfStatement(ifHandle: .constant(.ifKeyword))) - } 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. /// From 03f302ad7649bf3712420ad8e4f304e2a65fd677 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:18 +0000 Subject: [PATCH 3/9] 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 | 18 ++-- Sources/SwiftParser/Statements.swift | 7 +- .../MigrateToNewIfLetSyntax.swift | 6 +- .../ConvenienceInitializers.swift | 2 +- Tests/SwiftParserTest/StatementTests.swift | 4 +- .../MigrateToNewIfLetSyntax.swift | 99 ++++++++++--------- .../FunctionTests.swift | 2 +- .../SwiftSyntaxBuilderTest/IfStmtTests.swift | 10 +- 8 files changed, 85 insertions(+), 63 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index d0fe12a49ef..9e27f170ccd 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -2524,16 +2524,20 @@ extension Parser.Lookahead { } } +// MARK: Conditional Expressions + extension Parser { - /// Parse an if statement. + /// Parse an if statement/expression. /// /// Grammar /// ======= /// - /// if-statement → 'if' condition-list code-block else-clause? + /// if-expression → 'if' condition-list code-block else-clause? /// else-clause → 'else' code-block | else if-statement @_spi(RawSyntax) - public mutating func parseIfStatement(ifHandle: RecoveryConsumptionHandle) -> RawIfStmtSyntax { + 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. @@ -2542,10 +2546,12 @@ extension Parser { // The else branch, if any, is outside of the scope of the condition. let elseKeyword = self.consume(if: .elseKeyword) - let elseBody: RawIfStmtSyntax.ElseBody? + let elseBody: RawIfExprSyntax.ElseBody? if elseKeyword != nil { if self.at(.ifKeyword) { - elseBody = .ifStmt(self.parseIfStatement(ifHandle: .constant(.ifKeyword))) + elseBody = .ifExpr( + self.parseIfExpression(ifHandle: .constant(.ifKeyword)) + ) } else { elseBody = .codeBlock(self.parseCodeBlock(introducer: ifKeyword)) } @@ -2553,7 +2559,7 @@ extension Parser { elseBody = nil } - return RawIfStmtSyntax( + return RawIfExprSyntax( unexpectedBeforeIfKeyword, ifKeyword: ifKeyword, conditions: conditions, diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index b054b79a41e..55db70d7e68 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)?: 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 54ce7f3c090..420e78cb733 100644 --- a/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift +++ b/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift @@ -188,7 +188,7 @@ extension FunctionParameter { // MARK: - IfStmt -extension IfStmt { +extension IfExprSyntax { /// 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/Tests/SwiftParserTest/StatementTests.swift b/Tests/SwiftParserTest/StatementTests.swift index aa9878b04a6..679112acd61 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: .ifKeyword(), conditions: ConditionElementListSyntax([ ConditionElementSyntax( @@ -47,7 +47,7 @@ final class StatementTests: XCTestCase { if let self = self {} """, substructure: Syntax( - IfStmtSyntax( + IfExprSyntax( ifKeyword: .ifKeyword(), 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 85c1c7578b4..1d942baded8 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 8a75048e9f8..81e2b09360b 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, """ @@ -32,7 +32,7 @@ final class IfStmtTests: XCTestCase { func testIfElseStmt() { // 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!")) } @@ -54,7 +54,7 @@ final class IfStmtTests: XCTestCase { } func testIfLetStmt() { - let buildable = IfStmt( + let buildable = IfExpr( conditions: ConditionElementList { OptionalBindingCondition( letOrVarKeyword: .let, @@ -73,7 +73,7 @@ final class IfStmtTests: XCTestCase { } func testIfCaseStmt() { - let buildable = IfStmt( + let buildable = IfExpr( conditions: ConditionElementList { MatchingPatternCondition( pattern: ExpressionPattern(expression: MemberAccessExpr(name: "x")), From 102f1acb91a805e28c40a3bf7051a8bdc82daeab Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:19 +0000 Subject: [PATCH 4/9] Introduce SwitchExprSyntax This replaces SwitchStmtSyntax, and will be wrapped in an ExpressionStmtSyntax when used as a statement. --- gyb_syntax_support/ExprNodes.py | 67 +++++++++++++++++++++++++++++++++ gyb_syntax_support/StmtNodes.py | 64 ------------------------------- 2 files changed, 67 insertions(+), 64 deletions(-) diff --git a/gyb_syntax_support/ExprNodes.py b/gyb_syntax_support/ExprNodes.py index 7269b53dc10..d31c6561738 100644 --- a/gyb_syntax_support/ExprNodes.py +++ b/gyb_syntax_support/ExprNodes.py @@ -307,6 +307,73 @@ is_optional=True), ]), + # switch-expr -> identifier? ':'? 'switch' expr '{' + # switch-case-list '}' ';'? + # + # This node represents both a 'switch' expression, as well as a 'switch' + # statement when wrapped in a ExpressionStmt node. + Node('SwitchExpr', name_for_diagnostics="'switch' statement", kind='Expr', + traits=['Braced'], + children=[ + Child('SwitchKeyword', kind='SwitchToken'), + 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='CaseToken'), + 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='DefaultToken'), + 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 3898539b58b..aabfa0e5f74 100644 --- a/gyb_syntax_support/StmtNodes.py +++ b/gyb_syntax_support/StmtNodes.py @@ -42,12 +42,6 @@ Child('Expression', kind='Expr'), ]), - # 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='SwitchToken'), - 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'), @@ -271,41 +251,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='DefaultToken'), - 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'], @@ -317,15 +262,6 @@ is_optional=True), ]), - # switch-case-label -> 'case' case-item-list ':' - Node('SwitchCaseLabel', name_for_diagnostics=None, kind='Syntax', - children=[ - Child('CaseKeyword', kind='CaseToken'), - 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 c8f237108f7432e1109744dc90c8a67b202bc0bb Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:19 +0000 Subject: [PATCH 5/9] NFC: Move switch parsing to Expressions.swift --- Sources/SwiftParser/Expressions.swift | 288 ++++++++++++++++++++++++++ Sources/SwiftParser/Statements.swift | 288 -------------------------- 2 files changed, 288 insertions(+), 288 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 9e27f170ccd..a8cecc8b540 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -2571,6 +2571,294 @@ 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(.caseKeyword, 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() + + var tokenList = [RawTokenSyntax]() + var loopProgress = LoopProgressCondition() + while let atSign = self.consume(if: .atSign), loopProgress.evaluate(currentToken) { + tokenList.append(atSign) + tokenList.append(self.expectIdentifierWithoutRecovery()) + } + + unknownAttr = RawAttributeSyntax( + atSignToken: at, + unexpectedBeforeIdent, + attributeName: ident, + leftParen: nil, + argument: nil, + rightParen: nil, + tokenList: tokenList.isEmpty ? nil : RawTokenListSyntax(elements: tokenList, arena: self.arena), + 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(.caseKeyword), + 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: .whereKeyword) { + 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 55db70d7e68..f169b27838d 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -657,294 +657,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(.caseKeyword, 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() - - var tokenList = [RawTokenSyntax]() - var loopProgress = LoopProgressCondition() - while let atSign = self.consume(if: .atSign), loopProgress.evaluate(currentToken) { - tokenList.append(atSign) - tokenList.append(self.expectIdentifierWithoutRecovery()) - } - - unknownAttr = RawAttributeSyntax( - atSignToken: at, - unexpectedBeforeIdent, - attributeName: ident, - leftParen: nil, - argument: nil, - rightParen: nil, - tokenList: tokenList.isEmpty ? nil : RawTokenListSyntax(elements: tokenList, arena: self.arena), - 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(.caseKeyword), - 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: .whereKeyword) { - 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 { From 9edcf214dc7f66040910b53bd9fecd88d389772a Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:19 +0000 Subject: [PATCH 6/9] 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 | 12 +++++++----- Sources/SwiftParser/Statements.swift | 7 ++++++- Tests/SwiftSyntaxBuilderTest/SwitchTests.swift | 2 +- 3 files changed, 14 insertions(+), 7 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index a8cecc8b540..dc1a3888735 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -2571,18 +2571,20 @@ extension Parser { } } -// MARK: Switch Statements +// MARK: Switch Statements/Expressions extension Parser { - /// Parse a switch statement. + /// Parse a switch statement/expression. /// /// Grammar /// ======= /// - /// switch-statement → 'switch' expression '{' switch-cases? '}' + /// switch-expression → 'switch' expression '{' switch-cases? '}' /// switch-cases → switch-case switch-cases? @_spi(RawSyntax) - public mutating func parseSwitchStatement(switchHandle: RecoveryConsumptionHandle) -> RawSwitchStmtSyntax { + public mutating func parseSwitchExpression( + switchHandle: RecoveryConsumptionHandle + ) -> RawSwitchExprSyntax { let (unexpectedBeforeSwitchKeyword, switchKeyword) = self.eat(switchHandle) let subject = self.parseExpression(.basic) @@ -2591,7 +2593,7 @@ extension Parser { let cases = self.parseSwitchCases(allowStandaloneStmtRecovery: !lbrace.isMissing) let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: switchKeyword) - return RawSwitchStmtSyntax( + return RawSwitchExprSyntax( unexpectedBeforeSwitchKeyword, switchKeyword: switchKeyword, expression: subject, diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index f169b27838d..bb3b54f66fd 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)?: 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 f6b7d7937eb4c98c9055c3c0371410469e430899 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:20 +0000 Subject: [PATCH 7/9] 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 | 64 ++++++-- Sources/SwiftParser/RawTokenKindSubset.swift | 20 +++ Sources/SwiftParser/Statements.swift | 26 +++- Sources/SwiftParser/TopLevel.swift | 33 +++- Tests/SwiftParserTest/ExpressionTests.swift | 151 +++++++++++++++++++ 5 files changed, 272 insertions(+), 22 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index dc1a3888735..4a0e2ab2f32 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': @@ -191,6 +196,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. @@ -323,19 +352,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().tokenKind == .arrow || self.peek().tokenKind == .throwsKeyword { @@ -487,6 +504,22 @@ extension Parser { ) -> RawExprSyntax { // First check to see if we have the start of a regex literal `/.../`. // tryLexRegexLiteral(/*forUnappliedOperator*/ false) + + // 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) @@ -2461,6 +2494,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 b430554ec5e..9115dfbd1ba 100644 --- a/Sources/SwiftParser/RawTokenKindSubset.swift +++ b/Sources/SwiftParser/RawTokenKindSubset.swift @@ -611,6 +611,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 bb3b54f66fd..587233887fd 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -665,6 +665,24 @@ extension Parser { // MARK: Control Transfer Statements extension Parser { + private mutating func isStartOfReturnExpr() -> Bool { + if self.at(any: [ + .rightBrace, .caseKeyword, .defaultKeyword, .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 @@ -680,13 +698,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, .caseKeyword, .defaultKeyword, .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 e09154eaa18..23f62aac936 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 4895de87d41..0253fa84bb7 100644 --- a/Tests/SwiftParserTest/ExpressionTests.swift +++ b/Tests/SwiftParserTest/ExpressionTests.swift @@ -803,3 +803,154 @@ final class ExpressionTests: 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 5ab7b7250a5b7683f8a9b9ac58afed287804082e Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:20 +0000 Subject: [PATCH 8/9] Generate gyb --- .../gyb_generated/ExprNodes.swift | 152 + .../gyb_generated/StmtNodes.swift | 152 - .../generated/BasicFormat.swift | 2 +- .../gyb_generated/SwiftSyntax.md | 14 +- .../Raw/gyb_generated/RawSyntaxNodes.swift | 6178 ++--- .../gyb_generated/RawSyntaxValidation.swift | 160 +- Sources/SwiftSyntax/generated/Misc.swift | 16 +- .../generated/SyntaxAnyVisitor.swift | 8 +- .../generated/SyntaxBaseNodes.swift | 12 +- .../SwiftSyntax/generated/SyntaxEnum.swift | 12 +- .../SwiftSyntax/generated/SyntaxKind.swift | 4 +- .../gyb_generated/SyntaxCollections.swift | 798 +- .../gyb_generated/SyntaxFactory.swift | 484 +- .../gyb_generated/SyntaxRewriter.swift | 294 +- .../gyb_generated/SyntaxTraits.swift | 8 +- .../gyb_generated/SyntaxTransform.swift | 168 +- .../gyb_generated/SyntaxVisitor.swift | 322 +- .../syntax_nodes/SyntaxExprNodes.swift | 766 + .../syntax_nodes/SyntaxNodes.swift | 20422 ++++++++-------- .../syntax_nodes/SyntaxStmtNodes.swift | 766 - .../generated/BuildableNodes.swift | 4 +- ...bleByStringInterpolationConformances.swift | 4 +- .../generated/Typealiases.swift | 4 +- 23 files changed, 15375 insertions(+), 15375 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift index 0fb430a4ca8..26f68282a57 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift @@ -493,6 +493,158 @@ public let EXPR_NODES: [Node] = [ ]) ]), + Node(name: "IfExpr", + nameForDiagnostics: "'if' statement", + kind: "Expr", + traits: [ + "WithCodeBlock" + ], + children: [ + Child(name: "IfKeyword", + kind: "IfToken", + tokenChoices: [ + "If" + ]), + Child(name: "Conditions", + kind: "ConditionElementList", + collectionElementName: "Condition"), + Child(name: "Body", + kind: "CodeBlock"), + Child(name: "ElseKeyword", + kind: "ElseToken", + isOptional: true, + tokenChoices: [ + "Else" + ]), + 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: "SwitchToken", + tokenChoices: [ + "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: "CaseToken", + tokenChoices: [ + "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: "DefaultToken", + tokenChoices: [ + "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 e06f261a132..1744e050c36 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift @@ -91,14 +91,6 @@ public let STMT_NODES: [Node] = [ kind: "Expr") ]), - Node(name: "SwitchCaseList", - nameForDiagnostics: nil, - kind: "SyntaxCollection", - element: "Syntax", - elementName: "SwitchCase", - elementChoices: ["SwitchCase", "IfConfigDecl"], - elementsSeparatedByNewline: true), - Node(name: "RepeatWhileStmt", nameForDiagnostics: "'repeat' statement", kind: "Stmt", @@ -212,36 +204,6 @@ public let STMT_NODES: [Node] = [ kind: "CodeBlock") ]), - Node(name: "SwitchStmt", - nameForDiagnostics: "'switch' statement", - kind: "Stmt", - traits: [ - "Braced" - ], - children: [ - Child(name: "SwitchKeyword", - kind: "SwitchToken", - tokenChoices: [ - "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", @@ -520,101 +482,6 @@ public let STMT_NODES: [Node] = [ kind: "Expr") ]), - Node(name: "IfStmt", - nameForDiagnostics: "'if' statement", - kind: "Stmt", - traits: [ - "WithCodeBlock" - ], - children: [ - Child(name: "IfKeyword", - kind: "IfToken", - tokenChoices: [ - "If" - ]), - Child(name: "Conditions", - kind: "ConditionElementList", - collectionElementName: "Condition"), - Child(name: "Body", - kind: "CodeBlock"), - Child(name: "ElseKeyword", - kind: "ElseToken", - isOptional: true, - tokenChoices: [ - "Else" - ]), - 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: "DefaultToken", - tokenChoices: [ - "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", @@ -636,25 +503,6 @@ public let STMT_NODES: [Node] = [ ]) ]), - Node(name: "SwitchCaseLabel", - nameForDiagnostics: nil, - kind: "Syntax", - children: [ - Child(name: "CaseKeyword", - kind: "CaseToken", - tokenChoices: [ - "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 e89330c4ca7..3f14729ced7 100644 --- a/Sources/SwiftBasicFormat/generated/BasicFormat.swift +++ b/Sources/SwiftBasicFormat/generated/BasicFormat.swift @@ -103,7 +103,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 780a9c590ce..71507f043bf 100644 --- a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md @@ -87,7 +87,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- - - - @@ -95,7 +94,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- - ### Expressions @@ -125,6 +123,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- - - - @@ -280,6 +280,11 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- +- +- +- - - - @@ -364,7 +369,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- - - - @@ -377,11 +381,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 ceb0cecb53a..ecc3f05b00f 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, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .symbolicReferenceExpr, .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, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .symbolicReferenceExpr, .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, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .ifStmt, .poundAssertStmt: return true + case .missingStmt, .labeledStmt, .continueStmt, .whileStmt, .deferStmt, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .poundAssertStmt: return true default: return false } } @@ -2655,7 +2655,36 @@ public struct RawBooleanLiteralExprSyntax: RawExprSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { +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 { @@ -2663,7 +2692,7 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedTernaryExpr + return raw.kind == .ifExpr } public var raw: RawSyntax @@ -2678,54 +2707,74 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeQuestionMark: RawUnexpectedNodesSyntax? = nil, - questionMark: RawTokenSyntax, - _ unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? = nil, - firstChoice: RawExprSyntax, - _ unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? = nil, - colonMark: RawTokenSyntax, - _ unexpectedAfterColonMark: RawUnexpectedNodesSyntax? = nil, + _ 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: .unresolvedTernaryExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .ifExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeQuestionMark?.raw - layout[1] = questionMark.raw - layout[2] = unexpectedBetweenQuestionMarkAndFirstChoice?.raw - layout[3] = firstChoice.raw - layout[4] = unexpectedBetweenFirstChoiceAndColonMark?.raw - layout[5] = colonMark.raw - layout[6] = unexpectedAfterColonMark?.raw + 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 unexpectedBeforeQuestionMark: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var questionMark: RawTokenSyntax { + public var ifKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var firstChoice: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! + public var conditions: RawConditionElementListSyntax { + layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))! } - public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var colonMark: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var body: RawCodeBlockSyntax { + layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))! } - public var unexpectedAfterColonMark: RawUnexpectedNodesSyntax? { + 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 RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawSwitchExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -2733,7 +2782,7 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ternaryExpr + return raw.kind == .switchExpr } public var raw: RawSyntax @@ -2748,74 +2797,103 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeConditionExpression: RawUnexpectedNodesSyntax? = nil, - conditionExpression: RawExprSyntax, - _ unexpectedBetweenConditionExpressionAndQuestionMark: RawUnexpectedNodesSyntax? = nil, - questionMark: RawTokenSyntax, - _ unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? = nil, - firstChoice: RawExprSyntax, - _ unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? = nil, - colonMark: RawTokenSyntax, - _ unexpectedBetweenColonMarkAndSecondChoice: RawUnexpectedNodesSyntax? = nil, - secondChoice: RawExprSyntax, - _ unexpectedAfterSecondChoice: RawUnexpectedNodesSyntax? = nil, + _ 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: .ternaryExpr, uninitializedCount: 11, arena: arena) { layout in + kind: .switchExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeConditionExpression?.raw - layout[1] = conditionExpression.raw - layout[2] = unexpectedBetweenConditionExpressionAndQuestionMark?.raw - layout[3] = questionMark.raw - layout[4] = unexpectedBetweenQuestionMarkAndFirstChoice?.raw - layout[5] = firstChoice.raw - layout[6] = unexpectedBetweenFirstChoiceAndColonMark?.raw - layout[7] = colonMark.raw - layout[8] = unexpectedBetweenColonMarkAndSecondChoice?.raw - layout[9] = secondChoice.raw - layout[10] = unexpectedAfterSecondChoice?.raw + 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 unexpectedBeforeConditionExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var conditionExpression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var switchKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenConditionExpressionAndQuestionMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var questionMark: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var firstChoice: RawExprSyntax { - layoutView.children[5].map(RawExprSyntax.init(raw:))! + public var leftBrace: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var colonMark: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! + public var cases: RawSwitchCaseListSyntax { + layoutView.children[7].map(RawSwitchCaseListSyntax.init(raw:))! } - public var unexpectedBetweenColonMarkAndSecondChoice: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var secondChoice: RawExprSyntax { - layoutView.children[9].map(RawExprSyntax.init(raw:))! + public var rightBrace: RawTokenSyntax { + layoutView.children[9].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterSecondChoice: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { +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 { @@ -2823,7 +2901,7 @@ public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .memberAccessExpr + return raw.kind == .switchCaseList } public var raw: RawSyntax @@ -2837,65 +2915,54 @@ public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeBase: RawUnexpectedNodesSyntax? = nil, - base: RawExprSyntax?, - _ unexpectedBetweenBaseAndDot: RawUnexpectedNodesSyntax? = nil, - dot: RawTokenSyntax, - _ unexpectedBetweenDotAndName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax, - _ unexpectedBetweenNameAndDeclNameArguments: RawUnexpectedNodesSyntax? = nil, - declNameArguments: RawDeclNameArgumentsSyntax?, - _ unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [Element], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .memberAccessExpr, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeBase?.raw - layout[1] = base?.raw - layout[2] = unexpectedBetweenBaseAndDot?.raw - layout[3] = dot.raw - layout[4] = unexpectedBetweenDotAndName?.raw - layout[5] = name.raw - layout[6] = unexpectedBetweenNameAndDeclNameArguments?.raw - layout[7] = declNameArguments?.raw - layout[8] = unexpectedAfterDeclNameArguments?.raw + 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 unexpectedBeforeBase: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var base: RawExprSyntax? { - layoutView.children[1].map(RawExprSyntax.init(raw:)) - } - public var unexpectedBetweenBaseAndDot: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var dot: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenDotAndName: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var name: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenNameAndDeclNameArguments: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var declNameArguments: RawDeclNameArgumentsSyntax? { - layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:)) - } - public var unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawSyntax] { + layoutView.children.map { RawSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { +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 { @@ -2903,7 +2970,7 @@ public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedIsExpr + return raw.kind == .switchCase } public var raw: RawSyntax @@ -2918,34 +2985,54 @@ public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? = nil, - isTok: RawTokenSyntax, - _ unexpectedAfterIsTok: RawUnexpectedNodesSyntax? = nil, + _ 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: .unresolvedIsExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .switchCase, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeIsTok?.raw - layout[1] = isTok.raw - layout[2] = unexpectedAfterIsTok?.raw + 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 unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var isTok: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var unknownAttr: RawAttributeSyntax? { + layoutView.children[1].map(RawAttributeSyntax.init(raw:)) } - public var unexpectedAfterIsTok: RawUnexpectedNodesSyntax? { + 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 RawIsExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -2953,7 +3040,7 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .isExpr + return raw.kind == .switchCaseLabel } public var raw: RawSyntax @@ -2968,54 +3055,54 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? = nil, - isTok: RawTokenSyntax, - _ unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? = nil, - typeName: RawTypeSyntax, - _ unexpectedAfterTypeName: RawUnexpectedNodesSyntax? = nil, + _ 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: .isExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .switchCaseLabel, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeExpression?.raw - layout[1] = expression.raw - layout[2] = unexpectedBetweenExpressionAndIsTok?.raw - layout[3] = isTok.raw - layout[4] = unexpectedBetweenIsTokAndTypeName?.raw - layout[5] = typeName.raw - layout[6] = unexpectedAfterTypeName?.raw + 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 unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var caseKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var isTok: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var caseItems: RawCaseItemListSyntax { + layoutView.children[3].map(RawCaseItemListSyntax.init(raw:))! } - public var unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var typeName: RawTypeSyntax { - layoutView.children[5].map(RawTypeSyntax.init(raw:))! + public var colon: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? { + public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3023,7 +3110,7 @@ public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedAsExpr + return raw.kind == .switchDefaultLabel } public var raw: RawSyntax @@ -3038,44 +3125,44 @@ public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAsTok: RawUnexpectedNodesSyntax? = nil, - asTok: RawTokenSyntax, - _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, - questionOrExclamationMark: RawTokenSyntax?, - _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? = nil, + defaultKeyword: RawTokenSyntax, + _ unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax, + _ unexpectedAfterColon: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .unresolvedAsExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .switchDefaultLabel, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAsTok?.raw - layout[1] = asTok.raw - layout[2] = unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw - layout[3] = questionOrExclamationMark?.raw - layout[4] = unexpectedAfterQuestionOrExclamationMark?.raw + 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 unexpectedBeforeAsTok: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var asTok: RawTokenSyntax { + public var defaultKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var questionOrExclamationMark: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var colon: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { + public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3083,7 +3170,7 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .asExpr + return raw.kind == .caseItem } public var raw: RawSyntax @@ -3098,64 +3185,54 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? = nil, - asTok: RawTokenSyntax, - _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, - questionOrExclamationMark: RawTokenSyntax?, - _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? = nil, - typeName: RawTypeSyntax, - _ unexpectedAfterTypeName: RawUnexpectedNodesSyntax? = nil, + _ 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: .asExpr, uninitializedCount: 9, arena: arena) { layout in + kind: .caseItem, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeExpression?.raw - layout[1] = expression.raw - layout[2] = unexpectedBetweenExpressionAndAsTok?.raw - layout[3] = asTok.raw - layout[4] = unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw - layout[5] = questionOrExclamationMark?.raw - layout[6] = unexpectedBetweenQuestionOrExclamationMarkAndTypeName?.raw - layout[7] = typeName.raw - layout[8] = unexpectedAfterTypeName?.raw + 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 unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var pattern: RawPatternSyntax { + layoutView.children[1].map(RawPatternSyntax.init(raw:))! } - public var unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var asTok: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var whereClause: RawWhereClauseSyntax? { + layoutView.children[3].map(RawWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var questionOrExclamationMark: RawTokenSyntax? { + public var trailingComma: RawTokenSyntax? { layoutView.children[5].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var typeName: RawTypeSyntax { - layoutView.children[7].map(RawTypeSyntax.init(raw:))! - } - public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3163,7 +3240,7 @@ public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typeExpr + return raw.kind == .unresolvedTernaryExpr } public var raw: RawSyntax @@ -3178,34 +3255,54 @@ public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeType: RawUnexpectedNodesSyntax? = nil, - type: RawTypeSyntax, - _ unexpectedAfterType: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeQuestionMark: RawUnexpectedNodesSyntax? = nil, + questionMark: RawTokenSyntax, + _ unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? = nil, + firstChoice: RawExprSyntax, + _ unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? = nil, + colonMark: RawTokenSyntax, + _ unexpectedAfterColonMark: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .unresolvedTernaryExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeType?.raw - layout[1] = type.raw - layout[2] = unexpectedAfterType?.raw - } + layout[0] = unexpectedBeforeQuestionMark?.raw + layout[1] = questionMark.raw + layout[2] = unexpectedBetweenQuestionMarkAndFirstChoice?.raw + layout[3] = firstChoice.raw + layout[4] = unexpectedBetweenFirstChoiceAndColonMark?.raw + layout[5] = colonMark.raw + layout[6] = unexpectedAfterColonMark?.raw + } self.init(raw: raw) } - public var unexpectedBeforeType: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeQuestionMark: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var type: RawTypeSyntax { - layoutView.children[1].map(RawTypeSyntax.init(raw:))! + public var questionMark: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterType: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var firstChoice: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! + } + public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var colonMark: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterColonMark: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { +public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3213,7 +3310,7 @@ public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureCaptureItem + return raw.kind == .ternaryExpr } public var raw: RawSyntax @@ -3228,114 +3325,74 @@ public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, - specifier: RawTokenListSyntax?, - _ unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax?, - _ unexpectedBetweenNameAndAssignToken: RawUnexpectedNodesSyntax? = nil, - assignToken: RawTokenSyntax?, - _ unexpectedBetweenAssignTokenAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeConditionExpression: RawUnexpectedNodesSyntax? = nil, + conditionExpression: RawExprSyntax, + _ unexpectedBetweenConditionExpressionAndQuestionMark: RawUnexpectedNodesSyntax? = nil, + questionMark: RawTokenSyntax, + _ unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? = nil, + firstChoice: RawExprSyntax, + _ unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? = nil, + colonMark: RawTokenSyntax, + _ unexpectedBetweenColonMarkAndSecondChoice: RawUnexpectedNodesSyntax? = nil, + secondChoice: RawExprSyntax, + _ unexpectedAfterSecondChoice: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureCaptureItem, uninitializedCount: 11, arena: arena) { layout in + kind: .ternaryExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeSpecifier?.raw - layout[1] = specifier?.raw - layout[2] = unexpectedBetweenSpecifierAndName?.raw - layout[3] = name?.raw - layout[4] = unexpectedBetweenNameAndAssignToken?.raw - layout[5] = assignToken?.raw - layout[6] = unexpectedBetweenAssignTokenAndExpression?.raw - layout[7] = expression.raw - layout[8] = unexpectedBetweenExpressionAndTrailingComma?.raw - layout[9] = trailingComma?.raw - layout[10] = unexpectedAfterTrailingComma?.raw + layout[0] = unexpectedBeforeConditionExpression?.raw + layout[1] = conditionExpression.raw + layout[2] = unexpectedBetweenConditionExpressionAndQuestionMark?.raw + layout[3] = questionMark.raw + layout[4] = unexpectedBetweenQuestionMarkAndFirstChoice?.raw + layout[5] = firstChoice.raw + layout[6] = unexpectedBetweenFirstChoiceAndColonMark?.raw + layout[7] = colonMark.raw + layout[8] = unexpectedBetweenColonMarkAndSecondChoice?.raw + layout[9] = secondChoice.raw + layout[10] = unexpectedAfterSecondChoice?.raw } self.init(raw: raw) } - public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeConditionExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var specifier: RawTokenListSyntax? { - layoutView.children[1].map(RawTokenListSyntax.init(raw:)) + public var conditionExpression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenConditionExpressionAndQuestionMark: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var name: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var questionMark: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenNameAndAssignToken: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var assignToken: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) + public var firstChoice: RawExprSyntax { + layoutView.children[5].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenAssignTokenAndExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[7].map(RawExprSyntax.init(raw:))! + public var colonMark: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenColonMarkAndSecondChoice: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var trailingComma: RawTokenSyntax? { - layoutView.children[9].map(RawTokenSyntax.init(raw:)) + public var secondChoice: RawExprSyntax { + layoutView.children[9].map(RawExprSyntax.init(raw:))! } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterSecondChoice: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawClosureCaptureItemListSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureCaptureItemList - } - - 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: [RawClosureCaptureItemSyntax], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .closureCaptureItemList, 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: [RawClosureCaptureItemSyntax] { - layoutView.children.map { RawClosureCaptureItemSyntax(raw: $0!) } - } -} - -@_spi(RawSyntax) -public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { +public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3343,7 +3400,7 @@ public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureCaptureSignature + return raw.kind == .memberAccessExpr } public var raw: RawSyntax @@ -3358,54 +3415,64 @@ public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? = nil, - leftSquare: RawTokenSyntax, - _ unexpectedBetweenLeftSquareAndItems: RawUnexpectedNodesSyntax? = nil, - items: RawClosureCaptureItemListSyntax?, - _ unexpectedBetweenItemsAndRightSquare: RawUnexpectedNodesSyntax? = nil, - rightSquare: RawTokenSyntax, - _ unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBase: RawUnexpectedNodesSyntax? = nil, + base: RawExprSyntax?, + _ unexpectedBetweenBaseAndDot: RawUnexpectedNodesSyntax? = nil, + dot: RawTokenSyntax, + _ unexpectedBetweenDotAndName: RawUnexpectedNodesSyntax? = nil, + name: RawTokenSyntax, + _ unexpectedBetweenNameAndDeclNameArguments: RawUnexpectedNodesSyntax? = nil, + declNameArguments: RawDeclNameArgumentsSyntax?, + _ unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureCaptureSignature, uninitializedCount: 7, arena: arena) { layout in + kind: .memberAccessExpr, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftSquare?.raw - layout[1] = leftSquare.raw - layout[2] = unexpectedBetweenLeftSquareAndItems?.raw - layout[3] = items?.raw - layout[4] = unexpectedBetweenItemsAndRightSquare?.raw - layout[5] = rightSquare.raw - layout[6] = unexpectedAfterRightSquare?.raw + layout[0] = unexpectedBeforeBase?.raw + layout[1] = base?.raw + layout[2] = unexpectedBetweenBaseAndDot?.raw + layout[3] = dot.raw + layout[4] = unexpectedBetweenDotAndName?.raw + layout[5] = name.raw + layout[6] = unexpectedBetweenNameAndDeclNameArguments?.raw + layout[7] = declNameArguments?.raw + layout[8] = unexpectedAfterDeclNameArguments?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeBase: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftSquare: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var base: RawExprSyntax? { + layoutView.children[1].map(RawExprSyntax.init(raw:)) } - public var unexpectedBetweenLeftSquareAndItems: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenBaseAndDot: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var items: RawClosureCaptureItemListSyntax? { - layoutView.children[3].map(RawClosureCaptureItemListSyntax.init(raw:)) + public var dot: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenItemsAndRightSquare: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenDotAndName: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightSquare: RawTokenSyntax { + public var name: RawTokenSyntax { layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndDeclNameArguments: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var declNameArguments: RawDeclNameArgumentsSyntax? { + layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:)) + } + public var unexpectedAfterDeclNameArguments: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { +public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3413,7 +3480,7 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureParam + return raw.kind == .unresolvedIsExpr } public var raw: RawSyntax @@ -3428,44 +3495,34 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? = nil, + isTok: RawTokenSyntax, + _ unexpectedAfterIsTok: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureParam, uninitializedCount: 5, arena: arena) { layout in + kind: .unresolvedIsExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeName?.raw - layout[1] = name.raw - layout[2] = unexpectedBetweenNameAndTrailingComma?.raw - layout[3] = trailingComma?.raw - layout[4] = unexpectedAfterTrailingComma?.raw + layout[0] = unexpectedBeforeIsTok?.raw + layout[1] = isTok.raw + layout[2] = unexpectedAfterIsTok?.raw } self.init(raw: raw) } - public var unexpectedBeforeName: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var name: RawTokenSyntax { + public var isTok: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterIsTok: 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 RawClosureParamListSyntax: RawSyntaxNodeProtocol { +public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3473,7 +3530,7 @@ public struct RawClosureParamListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureParamList + return raw.kind == .isExpr } public var raw: RawSyntax @@ -3487,54 +3544,55 @@ public struct RawClosureParamListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawClosureParamSyntax], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .closureParamList, 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 - } + public init( + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? = nil, + isTok: RawTokenSyntax, + _ unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? = nil, + typeName: RawTypeSyntax, + _ unexpectedAfterTypeName: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .isExpr, uninitializedCount: 7, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndIsTok?.raw + layout[3] = isTok.raw + layout[4] = unexpectedBetweenIsTokAndTypeName?.raw + layout[5] = typeName.raw + layout[6] = unexpectedAfterTypeName?.raw } self.init(raw: raw) } - public var elements: [RawClosureParamSyntax] { - layoutView.children.map { RawClosureParamSyntax(raw: $0!) } + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! + } + public var unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var isTok: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var typeName: RawTypeSyntax { + layoutView.children[5].map(RawTypeSyntax.init(raw:))! + } + public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Input: RawSyntaxNodeProtocol { - case `simpleInput`(RawClosureParamListSyntax) - case `input`(RawParameterClauseSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawClosureParamListSyntax.isKindOf(raw) || RawParameterClauseSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .simpleInput(let node): return node.raw - case .input(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawClosureParamListSyntax(other) { - self = .simpleInput(node) - return - } - if let node = RawParameterClauseSyntax(other) { - self = .input(node) - return - } - return nil - } - } - +public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3542,7 +3600,7 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureSignature + return raw.kind == .unresolvedAsExpr } public var raw: RawSyntax @@ -3557,94 +3615,44 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndCapture: RawUnexpectedNodesSyntax? = nil, - capture: RawClosureCaptureSignatureSyntax?, - _ unexpectedBetweenCaptureAndInput: RawUnexpectedNodesSyntax? = nil, - input: Input?, - _ unexpectedBetweenInputAndAsyncKeyword: RawUnexpectedNodesSyntax? = nil, - asyncKeyword: RawTokenSyntax?, - _ unexpectedBetweenAsyncKeywordAndThrowsTok: RawUnexpectedNodesSyntax? = nil, - throwsTok: RawTokenSyntax?, - _ unexpectedBetweenThrowsTokAndOutput: RawUnexpectedNodesSyntax? = nil, - output: RawReturnClauseSyntax?, - _ unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? = nil, - inTok: RawTokenSyntax, - _ unexpectedAfterInTok: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAsTok: RawUnexpectedNodesSyntax? = nil, + asTok: RawTokenSyntax, + _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + questionOrExclamationMark: RawTokenSyntax?, + _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureSignature, uninitializedCount: 15, arena: arena) { layout in + kind: .unresolvedAsExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAttributes?.raw - layout[1] = attributes?.raw - layout[2] = unexpectedBetweenAttributesAndCapture?.raw - layout[3] = capture?.raw - layout[4] = unexpectedBetweenCaptureAndInput?.raw - layout[5] = input?.raw - layout[6] = unexpectedBetweenInputAndAsyncKeyword?.raw - layout[7] = asyncKeyword?.raw - layout[8] = unexpectedBetweenAsyncKeywordAndThrowsTok?.raw - layout[9] = throwsTok?.raw - layout[10] = unexpectedBetweenThrowsTokAndOutput?.raw - layout[11] = output?.raw - layout[12] = unexpectedBetweenOutputAndInTok?.raw - layout[13] = inTok.raw - layout[14] = unexpectedAfterInTok?.raw + layout[0] = unexpectedBeforeAsTok?.raw + layout[1] = asTok.raw + layout[2] = unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw + layout[3] = questionOrExclamationMark?.raw + layout[4] = unexpectedAfterQuestionOrExclamationMark?.raw } self.init(raw: raw) } - public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAsTok: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var asTok: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndCapture: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var capture: RawClosureCaptureSignatureSyntax? { - layoutView.children[3].map(RawClosureCaptureSignatureSyntax.init(raw:)) + public var questionOrExclamationMark: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenCaptureAndInput: RawUnexpectedNodesSyntax? { + public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var input: RawSyntax? { - layoutView.children[5] - } - public var unexpectedBetweenInputAndAsyncKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var asyncKeyword: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenAsyncKeywordAndThrowsTok: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var throwsTok: RawTokenSyntax? { - layoutView.children[9].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenThrowsTokAndOutput: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var output: RawReturnClauseSyntax? { - layoutView.children[11].map(RawReturnClauseSyntax.init(raw:)) - } - public var unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var inTok: RawTokenSyntax { - layoutView.children[13].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterInTok: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3652,7 +3660,7 @@ public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureExpr + return raw.kind == .asExpr } public var raw: RawSyntax @@ -3667,64 +3675,64 @@ public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? = nil, - leftBrace: RawTokenSyntax, - _ unexpectedBetweenLeftBraceAndSignature: RawUnexpectedNodesSyntax? = nil, - signature: RawClosureSignatureSyntax?, - _ unexpectedBetweenSignatureAndStatements: RawUnexpectedNodesSyntax? = nil, - statements: RawCodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndRightBrace: RawUnexpectedNodesSyntax? = nil, - rightBrace: RawTokenSyntax, - _ unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? = nil, + asTok: RawTokenSyntax, + _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + questionOrExclamationMark: RawTokenSyntax?, + _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? = nil, + typeName: RawTypeSyntax, + _ unexpectedAfterTypeName: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureExpr, uninitializedCount: 9, arena: arena) { layout in + kind: .asExpr, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftBrace?.raw - layout[1] = leftBrace.raw - layout[2] = unexpectedBetweenLeftBraceAndSignature?.raw - layout[3] = signature?.raw - layout[4] = unexpectedBetweenSignatureAndStatements?.raw - layout[5] = statements.raw - layout[6] = unexpectedBetweenStatementsAndRightBrace?.raw - layout[7] = rightBrace.raw - layout[8] = unexpectedAfterRightBrace?.raw + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndAsTok?.raw + layout[3] = asTok.raw + layout[4] = unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw + layout[5] = questionOrExclamationMark?.raw + layout[6] = unexpectedBetweenQuestionOrExclamationMarkAndTypeName?.raw + layout[7] = typeName.raw + layout[8] = unexpectedAfterTypeName?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftBrace: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenLeftBraceAndSignature: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var signature: RawClosureSignatureSyntax? { - layoutView.children[3].map(RawClosureSignatureSyntax.init(raw:)) + public var asTok: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenSignatureAndStatements: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var statements: RawCodeBlockItemListSyntax { - layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw:))! + public var questionOrExclamationMark: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenStatementsAndRightBrace: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightBrace: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! + public var typeName: RawTypeSyntax { + layoutView.children[7].map(RawTypeSyntax.init(raw:))! } - public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { + public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3732,7 +3740,7 @@ public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedPatternExpr + return raw.kind == .typeExpr } public var raw: RawSyntax @@ -3747,34 +3755,34 @@ public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePattern: RawUnexpectedNodesSyntax? = nil, - pattern: RawPatternSyntax, - _ unexpectedAfterPattern: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeType: RawUnexpectedNodesSyntax? = nil, + type: RawTypeSyntax, + _ unexpectedAfterType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .unresolvedPatternExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .typeExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePattern?.raw - layout[1] = pattern.raw - layout[2] = unexpectedAfterPattern?.raw + layout[0] = unexpectedBeforeType?.raw + layout[1] = type.raw + layout[2] = unexpectedAfterType?.raw } self.init(raw: raw) } - public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeType: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var pattern: RawPatternSyntax { - layoutView.children[1].map(RawPatternSyntax.init(raw:))! + public var type: RawTypeSyntax { + layoutView.children[1].map(RawTypeSyntax.init(raw:))! } - public var unexpectedAfterPattern: RawUnexpectedNodesSyntax? { + public var unexpectedAfterType: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { +public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3782,7 +3790,7 @@ public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .multipleTrailingClosureElement + return raw.kind == .closureCaptureItem } public var raw: RawSyntax @@ -3797,54 +3805,74 @@ public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLabel: RawUnexpectedNodesSyntax? = nil, - label: RawTokenSyntax, - _ unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax, - _ unexpectedBetweenColonAndClosure: RawUnexpectedNodesSyntax? = nil, - closure: RawClosureExprSyntax, - _ unexpectedAfterClosure: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, + specifier: RawTokenListSyntax?, + _ unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? = nil, + name: RawTokenSyntax?, + _ unexpectedBetweenNameAndAssignToken: RawUnexpectedNodesSyntax? = nil, + assignToken: RawTokenSyntax?, + _ unexpectedBetweenAssignTokenAndExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .multipleTrailingClosureElement, uninitializedCount: 7, arena: arena) { layout in + kind: .closureCaptureItem, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLabel?.raw - layout[1] = label.raw - layout[2] = unexpectedBetweenLabelAndColon?.raw - layout[3] = colon.raw - layout[4] = unexpectedBetweenColonAndClosure?.raw - layout[5] = closure.raw - layout[6] = unexpectedAfterClosure?.raw + layout[0] = unexpectedBeforeSpecifier?.raw + layout[1] = specifier?.raw + layout[2] = unexpectedBetweenSpecifierAndName?.raw + layout[3] = name?.raw + layout[4] = unexpectedBetweenNameAndAssignToken?.raw + layout[5] = assignToken?.raw + layout[6] = unexpectedBetweenAssignTokenAndExpression?.raw + layout[7] = expression.raw + layout[8] = unexpectedBetweenExpressionAndTrailingComma?.raw + layout[9] = trailingComma?.raw + layout[10] = unexpectedAfterTrailingComma?.raw } self.init(raw: raw) } - public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var label: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var specifier: RawTokenListSyntax? { + layoutView.children[1].map(RawTokenListSyntax.init(raw:)) } - public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var colon: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var name: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenColonAndClosure: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndAssignToken: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var closure: RawClosureExprSyntax { - layoutView.children[5].map(RawClosureExprSyntax.init(raw:))! + public var assignToken: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterClosure: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAssignTokenAndExpression: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var expression: RawExprSyntax { + layoutView.children[7].map(RawExprSyntax.init(raw:))! + } + public var unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var trailingComma: RawTokenSyntax? { + layoutView.children[9].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol { +public struct RawClosureCaptureItemListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3852,7 +3880,7 @@ public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .multipleTrailingClosureElementList + return raw.kind == .closureCaptureItemList } public var raw: RawSyntax @@ -3866,9 +3894,9 @@ public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol self.init(raw: other.raw) } - public init(elements: [RawMultipleTrailingClosureElementSyntax], arena: __shared SyntaxArena) { + public init(elements: [RawClosureCaptureItemSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .multipleTrailingClosureElementList, uninitializedCount: elements.count, arena: arena) { layout in + kind: .closureCaptureItemList, uninitializedCount: elements.count, arena: arena) { layout in guard var ptr = layout.baseAddress else { return } for elem in elements { ptr.initialize(to: elem.raw) @@ -3878,13 +3906,13 @@ public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol self.init(raw: raw) } - public var elements: [RawMultipleTrailingClosureElementSyntax] { - layoutView.children.map { RawMultipleTrailingClosureElementSyntax(raw: $0!) } + public var elements: [RawClosureCaptureItemSyntax] { + layoutView.children.map { RawClosureCaptureItemSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3892,7 +3920,7 @@ public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .functionCallExpr + return raw.kind == .closureCaptureSignature } public var raw: RawSyntax @@ -3907,84 +3935,54 @@ public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? = nil, - calledExpression: RawExprSyntax, - _ unexpectedBetweenCalledExpressionAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax?, - _ unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? = nil, - argumentList: RawTupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax?, - _ unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? = nil, - trailingClosure: RawClosureExprSyntax?, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, - additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax?, - _ unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? = nil, + leftSquare: RawTokenSyntax, + _ unexpectedBetweenLeftSquareAndItems: RawUnexpectedNodesSyntax? = nil, + items: RawClosureCaptureItemListSyntax?, + _ unexpectedBetweenItemsAndRightSquare: RawUnexpectedNodesSyntax? = nil, + rightSquare: RawTokenSyntax, + _ unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionCallExpr, uninitializedCount: 13, arena: arena) { layout in + kind: .closureCaptureSignature, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeCalledExpression?.raw - layout[1] = calledExpression.raw - layout[2] = unexpectedBetweenCalledExpressionAndLeftParen?.raw - layout[3] = leftParen?.raw - layout[4] = unexpectedBetweenLeftParenAndArgumentList?.raw - layout[5] = argumentList.raw - layout[6] = unexpectedBetweenArgumentListAndRightParen?.raw - layout[7] = rightParen?.raw - layout[8] = unexpectedBetweenRightParenAndTrailingClosure?.raw - layout[9] = trailingClosure?.raw - layout[10] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw - layout[11] = additionalTrailingClosures?.raw - layout[12] = unexpectedAfterAdditionalTrailingClosures?.raw + layout[0] = unexpectedBeforeLeftSquare?.raw + layout[1] = leftSquare.raw + layout[2] = unexpectedBetweenLeftSquareAndItems?.raw + layout[3] = items?.raw + layout[4] = unexpectedBetweenItemsAndRightSquare?.raw + layout[5] = rightSquare.raw + layout[6] = unexpectedAfterRightSquare?.raw } self.init(raw: raw) } - public var unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var calledExpression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var leftSquare: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenCalledExpressionAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftSquareAndItems: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var items: RawClosureCaptureItemListSyntax? { + layoutView.children[3].map(RawClosureCaptureItemListSyntax.init(raw:)) } - public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenItemsAndRightSquare: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var argumentList: RawTupleExprElementListSyntax { - layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))! + public var rightSquare: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightParen: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var trailingClosure: RawClosureExprSyntax? { - layoutView.children[9].map(RawClosureExprSyntax.init(raw:)) - } - public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? { - layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw:)) - } - public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3992,7 +3990,7 @@ public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .subscriptExpr + return raw.kind == .closureParam } public var raw: RawSyntax @@ -4007,84 +4005,44 @@ public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? = nil, - calledExpression: RawExprSyntax, - _ unexpectedBetweenCalledExpressionAndLeftBracket: RawUnexpectedNodesSyntax? = nil, - leftBracket: RawTokenSyntax, - _ unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? = nil, - argumentList: RawTupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? = nil, - rightBracket: RawTokenSyntax, - _ unexpectedBetweenRightBracketAndTrailingClosure: RawUnexpectedNodesSyntax? = nil, - trailingClosure: RawClosureExprSyntax?, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, - additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax?, - _ unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, + name: RawTokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .subscriptExpr, uninitializedCount: 13, arena: arena) { layout in + kind: .closureParam, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeCalledExpression?.raw - layout[1] = calledExpression.raw - layout[2] = unexpectedBetweenCalledExpressionAndLeftBracket?.raw - layout[3] = leftBracket.raw - layout[4] = unexpectedBetweenLeftBracketAndArgumentList?.raw - layout[5] = argumentList.raw - layout[6] = unexpectedBetweenArgumentListAndRightBracket?.raw - layout[7] = rightBracket.raw - layout[8] = unexpectedBetweenRightBracketAndTrailingClosure?.raw - layout[9] = trailingClosure?.raw - layout[10] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw - layout[11] = additionalTrailingClosures?.raw - layout[12] = unexpectedAfterAdditionalTrailingClosures?.raw + layout[0] = unexpectedBeforeName?.raw + layout[1] = name.raw + layout[2] = unexpectedBetweenNameAndTrailingComma?.raw + layout[3] = trailingComma?.raw + layout[4] = unexpectedAfterTrailingComma?.raw } self.init(raw: raw) } - public var unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeName: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var calledExpression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var name: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenCalledExpressionAndLeftBracket: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftBracket: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var trailingComma: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var argumentList: RawTupleExprElementListSyntax { - layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))! - } - public var unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var rightBracket: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenRightBracketAndTrailingClosure: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var trailingClosure: RawClosureExprSyntax? { - layoutView.children[9].map(RawClosureExprSyntax.init(raw:)) - } - public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? { - layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw:)) - } - public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawClosureParamListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4092,7 +4050,7 @@ public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .optionalChainingExpr + return raw.kind == .closureParamList } public var raw: RawSyntax @@ -4106,45 +4064,54 @@ public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndQuestionMark: RawUnexpectedNodesSyntax? = nil, - questionMark: RawTokenSyntax, - _ unexpectedAfterQuestionMark: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawClosureParamSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .optionalChainingExpr, uninitializedCount: 5, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeExpression?.raw - layout[1] = expression.raw - layout[2] = unexpectedBetweenExpressionAndQuestionMark?.raw - layout[3] = questionMark.raw - layout[4] = unexpectedAfterQuestionMark?.raw + kind: .closureParamList, 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 unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var expression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! - } - public var unexpectedBetweenExpressionAndQuestionMark: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var questionMark: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterQuestionMark: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawClosureParamSyntax] { + layoutView.children.map { RawClosureParamSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum Input: RawSyntaxNodeProtocol { + case `simpleInput`(RawClosureParamListSyntax) + case `input`(RawParameterClauseSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return RawClosureParamListSyntax.isKindOf(raw) || RawParameterClauseSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .simpleInput(let node): return node.raw + case .input(let node): return node.raw + } + } + + public init?(_ other: T) where T : RawSyntaxNodeProtocol { + if let node = RawClosureParamListSyntax(other) { + self = .simpleInput(node) + return + } + if let node = RawParameterClauseSyntax(other) { + self = .input(node) + return + } + return nil + } + } + @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4152,7 +4119,7 @@ public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .forcedValueExpr + return raw.kind == .closureSignature } public var raw: RawSyntax @@ -4167,44 +4134,94 @@ public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndExclamationMark: RawUnexpectedNodesSyntax? = nil, - exclamationMark: RawTokenSyntax, - _ unexpectedAfterExclamationMark: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndCapture: RawUnexpectedNodesSyntax? = nil, + capture: RawClosureCaptureSignatureSyntax?, + _ unexpectedBetweenCaptureAndInput: RawUnexpectedNodesSyntax? = nil, + input: Input?, + _ unexpectedBetweenInputAndAsyncKeyword: RawUnexpectedNodesSyntax? = nil, + asyncKeyword: RawTokenSyntax?, + _ unexpectedBetweenAsyncKeywordAndThrowsTok: RawUnexpectedNodesSyntax? = nil, + throwsTok: RawTokenSyntax?, + _ unexpectedBetweenThrowsTokAndOutput: RawUnexpectedNodesSyntax? = nil, + output: RawReturnClauseSyntax?, + _ unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? = nil, + inTok: RawTokenSyntax, + _ unexpectedAfterInTok: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .forcedValueExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .closureSignature, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeExpression?.raw - layout[1] = expression.raw - layout[2] = unexpectedBetweenExpressionAndExclamationMark?.raw - layout[3] = exclamationMark.raw - layout[4] = unexpectedAfterExclamationMark?.raw + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndCapture?.raw + layout[3] = capture?.raw + layout[4] = unexpectedBetweenCaptureAndInput?.raw + layout[5] = input?.raw + layout[6] = unexpectedBetweenInputAndAsyncKeyword?.raw + layout[7] = asyncKeyword?.raw + layout[8] = unexpectedBetweenAsyncKeywordAndThrowsTok?.raw + layout[9] = throwsTok?.raw + layout[10] = unexpectedBetweenThrowsTokAndOutput?.raw + layout[11] = output?.raw + layout[12] = unexpectedBetweenOutputAndInTok?.raw + layout[13] = inTok.raw + layout[14] = unexpectedAfterInTok?.raw } self.init(raw: raw) } - public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) } - public var unexpectedBetweenExpressionAndExclamationMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndCapture: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var exclamationMark: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var capture: RawClosureCaptureSignatureSyntax? { + layoutView.children[3].map(RawClosureCaptureSignatureSyntax.init(raw:)) } - public var unexpectedAfterExclamationMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCaptureAndInput: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var input: RawSyntax? { + layoutView.children[5] + } + public var unexpectedBetweenInputAndAsyncKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var asyncKeyword: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenAsyncKeywordAndThrowsTok: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var throwsTok: RawTokenSyntax? { + layoutView.children[9].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenThrowsTokAndOutput: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var output: RawReturnClauseSyntax? { + layoutView.children[11].map(RawReturnClauseSyntax.init(raw:)) + } + public var unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var inTok: RawTokenSyntax { + layoutView.children[13].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterInTok: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4212,7 +4229,7 @@ public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .postfixUnaryExpr + return raw.kind == .closureExpr } public var raw: RawSyntax @@ -4227,44 +4244,64 @@ public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndOperatorToken: RawUnexpectedNodesSyntax? = nil, - operatorToken: RawTokenSyntax, - _ unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? = nil, + leftBrace: RawTokenSyntax, + _ unexpectedBetweenLeftBraceAndSignature: RawUnexpectedNodesSyntax? = nil, + signature: RawClosureSignatureSyntax?, + _ unexpectedBetweenSignatureAndStatements: RawUnexpectedNodesSyntax? = nil, + statements: RawCodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndRightBrace: RawUnexpectedNodesSyntax? = nil, + rightBrace: RawTokenSyntax, + _ unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .postfixUnaryExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .closureExpr, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeExpression?.raw - layout[1] = expression.raw - layout[2] = unexpectedBetweenExpressionAndOperatorToken?.raw - layout[3] = operatorToken.raw - layout[4] = unexpectedAfterOperatorToken?.raw + layout[0] = unexpectedBeforeLeftBrace?.raw + layout[1] = leftBrace.raw + layout[2] = unexpectedBetweenLeftBraceAndSignature?.raw + layout[3] = signature?.raw + layout[4] = unexpectedBetweenSignatureAndStatements?.raw + layout[5] = statements.raw + layout[6] = unexpectedBetweenStatementsAndRightBrace?.raw + layout[7] = rightBrace.raw + layout[8] = unexpectedAfterRightBrace?.raw } self.init(raw: raw) } - public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var leftBrace: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenExpressionAndOperatorToken: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndSignature: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var operatorToken: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var signature: RawClosureSignatureSyntax? { + layoutView.children[3].map(RawClosureSignatureSyntax.init(raw:)) } - public var unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenSignatureAndStatements: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var statements: RawCodeBlockItemListSyntax { + layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw:))! + } + public var unexpectedBetweenStatementsAndRightBrace: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var rightBrace: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4272,7 +4309,7 @@ public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .specializeExpr + return raw.kind == .unresolvedPatternExpr } public var raw: RawSyntax @@ -4287,44 +4324,34 @@ public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, - genericArgumentClause: RawGenericArgumentClauseSyntax, - _ unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforePattern: RawUnexpectedNodesSyntax? = nil, + pattern: RawPatternSyntax, + _ unexpectedAfterPattern: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .specializeExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .unresolvedPatternExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeExpression?.raw - layout[1] = expression.raw - layout[2] = unexpectedBetweenExpressionAndGenericArgumentClause?.raw - layout[3] = genericArgumentClause.raw - layout[4] = unexpectedAfterGenericArgumentClause?.raw + layout[0] = unexpectedBeforePattern?.raw + layout[1] = pattern.raw + layout[2] = unexpectedAfterPattern?.raw } self.init(raw: raw) } - public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var pattern: RawPatternSyntax { + layoutView.children[1].map(RawPatternSyntax.init(raw:))! } - public var unexpectedBetweenExpressionAndGenericArgumentClause: RawUnexpectedNodesSyntax? { + public var unexpectedAfterPattern: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericArgumentClause: RawGenericArgumentClauseSyntax { - layoutView.children[3].map(RawGenericArgumentClauseSyntax.init(raw:))! - } - public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { +public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4332,7 +4359,7 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .stringSegment + return raw.kind == .multipleTrailingClosureElement } public var raw: RawSyntax @@ -4347,34 +4374,54 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeContent: RawUnexpectedNodesSyntax? = nil, - content: RawTokenSyntax, - _ unexpectedAfterContent: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLabel: RawUnexpectedNodesSyntax? = nil, + label: RawTokenSyntax, + _ unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax, + _ unexpectedBetweenColonAndClosure: RawUnexpectedNodesSyntax? = nil, + closure: RawClosureExprSyntax, + _ unexpectedAfterClosure: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .stringSegment, uninitializedCount: 3, arena: arena) { layout in + kind: .multipleTrailingClosureElement, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeContent?.raw - layout[1] = content.raw - layout[2] = unexpectedAfterContent?.raw + layout[0] = unexpectedBeforeLabel?.raw + layout[1] = label.raw + layout[2] = unexpectedBetweenLabelAndColon?.raw + layout[3] = colon.raw + layout[4] = unexpectedBetweenColonAndClosure?.raw + layout[5] = closure.raw + layout[6] = unexpectedAfterClosure?.raw } self.init(raw: raw) } - public var unexpectedBeforeContent: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var content: RawTokenSyntax { + public var label: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterContent: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var colon: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenColonAndClosure: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var closure: RawClosureExprSyntax { + layoutView.children[5].map(RawClosureExprSyntax.init(raw:))! + } + public var unexpectedAfterClosure: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol { +public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4382,7 +4429,7 @@ public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .expressionSegment + return raw.kind == .multipleTrailingClosureElementList } public var raw: RawSyntax @@ -4396,75 +4443,25 @@ public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? = nil, - backslash: RawTokenSyntax, - _ unexpectedBetweenBackslashAndDelimiter: RawUnexpectedNodesSyntax? = nil, - delimiter: RawTokenSyntax?, - _ unexpectedBetweenDelimiterAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndExpressions: RawUnexpectedNodesSyntax? = nil, - expressions: RawTupleExprElementListSyntax, - _ unexpectedBetweenExpressionsAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawMultipleTrailingClosureElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .expressionSegment, uninitializedCount: 11, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeBackslash?.raw - layout[1] = backslash.raw - layout[2] = unexpectedBetweenBackslashAndDelimiter?.raw - layout[3] = delimiter?.raw - layout[4] = unexpectedBetweenDelimiterAndLeftParen?.raw - layout[5] = leftParen.raw - layout[6] = unexpectedBetweenLeftParenAndExpressions?.raw - layout[7] = expressions.raw - layout[8] = unexpectedBetweenExpressionsAndRightParen?.raw - layout[9] = rightParen.raw - layout[10] = unexpectedAfterRightParen?.raw + kind: .multipleTrailingClosureElementList, 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 unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var backslash: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenBackslashAndDelimiter: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var delimiter: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenDelimiterAndLeftParen: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftParen: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftParenAndExpressions: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var expressions: RawTupleExprElementListSyntax { - layoutView.children[7].map(RawTupleExprElementListSyntax.init(raw:))! - } - public var unexpectedBetweenExpressionsAndRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var rightParen: RawTokenSyntax { - layoutView.children[9].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawMultipleTrailingClosureElementSyntax] { + layoutView.children.map { RawMultipleTrailingClosureElementSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4472,7 +4469,7 @@ public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .stringLiteralExpr + return raw.kind == .functionCallExpr } public var raw: RawSyntax @@ -4487,74 +4484,84 @@ public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeOpenDelimiter: RawUnexpectedNodesSyntax? = nil, - openDelimiter: RawTokenSyntax?, - _ unexpectedBetweenOpenDelimiterAndOpenQuote: RawUnexpectedNodesSyntax? = nil, - openQuote: RawTokenSyntax, - _ unexpectedBetweenOpenQuoteAndSegments: RawUnexpectedNodesSyntax? = nil, - segments: RawStringLiteralSegmentsSyntax, - _ unexpectedBetweenSegmentsAndCloseQuote: RawUnexpectedNodesSyntax? = nil, - closeQuote: RawTokenSyntax, - _ unexpectedBetweenCloseQuoteAndCloseDelimiter: RawUnexpectedNodesSyntax? = nil, - closeDelimiter: RawTokenSyntax?, - _ unexpectedAfterCloseDelimiter: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? = nil, + calledExpression: RawExprSyntax, + _ unexpectedBetweenCalledExpressionAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax?, + _ unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? = nil, + argumentList: RawTupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax?, + _ unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? = nil, + trailingClosure: RawClosureExprSyntax?, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, + additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax?, + _ unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .stringLiteralExpr, uninitializedCount: 11, arena: arena) { layout in + kind: .functionCallExpr, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeOpenDelimiter?.raw - layout[1] = openDelimiter?.raw - layout[2] = unexpectedBetweenOpenDelimiterAndOpenQuote?.raw - layout[3] = openQuote.raw - layout[4] = unexpectedBetweenOpenQuoteAndSegments?.raw - layout[5] = segments.raw - layout[6] = unexpectedBetweenSegmentsAndCloseQuote?.raw - layout[7] = closeQuote.raw - layout[8] = unexpectedBetweenCloseQuoteAndCloseDelimiter?.raw - layout[9] = closeDelimiter?.raw - layout[10] = unexpectedAfterCloseDelimiter?.raw + layout[0] = unexpectedBeforeCalledExpression?.raw + layout[1] = calledExpression.raw + layout[2] = unexpectedBetweenCalledExpressionAndLeftParen?.raw + layout[3] = leftParen?.raw + layout[4] = unexpectedBetweenLeftParenAndArgumentList?.raw + layout[5] = argumentList.raw + layout[6] = unexpectedBetweenArgumentListAndRightParen?.raw + layout[7] = rightParen?.raw + layout[8] = unexpectedBetweenRightParenAndTrailingClosure?.raw + layout[9] = trailingClosure?.raw + layout[10] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw + layout[11] = additionalTrailingClosures?.raw + layout[12] = unexpectedAfterAdditionalTrailingClosures?.raw } self.init(raw: raw) } - public var unexpectedBeforeOpenDelimiter: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var openDelimiter: RawTokenSyntax? { - layoutView.children[1].map(RawTokenSyntax.init(raw:)) + public var calledExpression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenOpenDelimiterAndOpenQuote: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCalledExpressionAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var openQuote: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var leftParen: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenOpenQuoteAndSegments: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var segments: RawStringLiteralSegmentsSyntax { - layoutView.children[5].map(RawStringLiteralSegmentsSyntax.init(raw:))! + public var argumentList: RawTupleExprElementListSyntax { + layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))! } - public var unexpectedBetweenSegmentsAndCloseQuote: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var closeQuote: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! + public var rightParen: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenCloseQuoteAndCloseDelimiter: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var closeDelimiter: RawTokenSyntax? { - layoutView.children[9].map(RawTokenSyntax.init(raw:)) + public var trailingClosure: RawClosureExprSyntax? { + layoutView.children[9].map(RawClosureExprSyntax.init(raw:)) } - public var unexpectedAfterCloseDelimiter: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? { + layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw:)) + } + public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4562,7 +4569,7 @@ public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .regexLiteralExpr + return raw.kind == .subscriptExpr } public var raw: RawSyntax @@ -4577,42 +4584,92 @@ public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeRegex: RawUnexpectedNodesSyntax? = nil, - regex: RawTokenSyntax, - _ unexpectedAfterRegex: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? = nil, + calledExpression: RawExprSyntax, + _ unexpectedBetweenCalledExpressionAndLeftBracket: RawUnexpectedNodesSyntax? = nil, + leftBracket: RawTokenSyntax, + _ unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? = nil, + argumentList: RawTupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? = nil, + rightBracket: RawTokenSyntax, + _ unexpectedBetweenRightBracketAndTrailingClosure: RawUnexpectedNodesSyntax? = nil, + trailingClosure: RawClosureExprSyntax?, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, + additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax?, + _ unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .regexLiteralExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .subscriptExpr, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeRegex?.raw - layout[1] = regex.raw - layout[2] = unexpectedAfterRegex?.raw + layout[0] = unexpectedBeforeCalledExpression?.raw + layout[1] = calledExpression.raw + layout[2] = unexpectedBetweenCalledExpressionAndLeftBracket?.raw + layout[3] = leftBracket.raw + layout[4] = unexpectedBetweenLeftBracketAndArgumentList?.raw + layout[5] = argumentList.raw + layout[6] = unexpectedBetweenArgumentListAndRightBracket?.raw + layout[7] = rightBracket.raw + layout[8] = unexpectedBetweenRightBracketAndTrailingClosure?.raw + layout[9] = trailingClosure?.raw + layout[10] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw + layout[11] = additionalTrailingClosures?.raw + layout[12] = unexpectedAfterAdditionalTrailingClosures?.raw } self.init(raw: raw) } - public var unexpectedBeforeRegex: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeCalledExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var regex: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var calledExpression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedAfterRegex: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCalledExpressionAndLeftBracket: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } -} - -@_spi(RawSyntax) -public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) + public var leftBracket: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var argumentList: RawTupleExprElementListSyntax { + layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))! + } + public var unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var rightBracket: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenRightBracketAndTrailingClosure: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var trailingClosure: RawClosureExprSyntax? { + layoutView.children[9].map(RawClosureExprSyntax.init(raw:)) + } + public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? { + layoutView.children[11].map(RawMultipleTrailingClosureElementListSyntax.init(raw:)) + } + public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { + + @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathExpr + return raw.kind == .optionalChainingExpr } public var raw: RawSyntax @@ -4627,54 +4684,44 @@ public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? = nil, - backslash: RawTokenSyntax, - _ unexpectedBetweenBackslashAndRoot: RawUnexpectedNodesSyntax? = nil, - root: RawTypeSyntax?, - _ unexpectedBetweenRootAndComponents: RawUnexpectedNodesSyntax? = nil, - components: RawKeyPathComponentListSyntax, - _ unexpectedAfterComponents: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndQuestionMark: RawUnexpectedNodesSyntax? = nil, + questionMark: RawTokenSyntax, + _ unexpectedAfterQuestionMark: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .optionalChainingExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeBackslash?.raw - layout[1] = backslash.raw - layout[2] = unexpectedBetweenBackslashAndRoot?.raw - layout[3] = root?.raw - layout[4] = unexpectedBetweenRootAndComponents?.raw - layout[5] = components.raw - layout[6] = unexpectedAfterComponents?.raw + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndQuestionMark?.raw + layout[3] = questionMark.raw + layout[4] = unexpectedAfterQuestionMark?.raw } self.init(raw: raw) } - public var unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var backslash: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenBackslashAndRoot: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndQuestionMark: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var root: RawTypeSyntax? { - layoutView.children[3].map(RawTypeSyntax.init(raw:)) + public var questionMark: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenRootAndComponents: RawUnexpectedNodesSyntax? { + public var unexpectedAfterQuestionMark: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var components: RawKeyPathComponentListSyntax { - layoutView.children[5].map(RawKeyPathComponentListSyntax.init(raw:))! - } - public var unexpectedAfterComponents: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol { +public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4682,7 +4729,7 @@ public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathComponentList + return raw.kind == .forcedValueExpr } public var raw: RawSyntax @@ -4696,60 +4743,45 @@ public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawKeyPathComponentSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndExclamationMark: RawUnexpectedNodesSyntax? = nil, + exclamationMark: RawTokenSyntax, + _ unexpectedAfterExclamationMark: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .keyPathComponentList, 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 - } + kind: .forcedValueExpr, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndExclamationMark?.raw + layout[3] = exclamationMark.raw + layout[4] = unexpectedAfterExclamationMark?.raw } self.init(raw: raw) } - public var elements: [RawKeyPathComponentSyntax] { - layoutView.children.map { RawKeyPathComponentSyntax(raw: $0!) } + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! + } + public var unexpectedBetweenExpressionAndExclamationMark: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var exclamationMark: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterExclamationMark: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Component: RawSyntaxNodeProtocol { - case `property`(RawKeyPathPropertyComponentSyntax) - case `subscript`(RawKeyPathSubscriptComponentSyntax) - case `optional`(RawKeyPathOptionalComponentSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawKeyPathPropertyComponentSyntax.isKindOf(raw) || RawKeyPathSubscriptComponentSyntax.isKindOf(raw) || RawKeyPathOptionalComponentSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .property(let node): return node.raw - case .subscript(let node): return node.raw - case .optional(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawKeyPathPropertyComponentSyntax(other) { - self = .property(node) - return - } - if let node = RawKeyPathSubscriptComponentSyntax(other) { - self = .subscript(node) - return - } - if let node = RawKeyPathOptionalComponentSyntax(other) { - self = .optional(node) - return - } - return nil - } - } - +public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4757,7 +4789,7 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathComponent + return raw.kind == .postfixUnaryExpr } public var raw: RawSyntax @@ -4772,44 +4804,44 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforePeriod: RawUnexpectedNodesSyntax? = nil, - period: RawTokenSyntax?, - _ unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? = nil, - component: Component, - _ unexpectedAfterComponent: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndOperatorToken: RawUnexpectedNodesSyntax? = nil, + operatorToken: RawTokenSyntax, + _ unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathComponent, uninitializedCount: 5, arena: arena) { layout in + kind: .postfixUnaryExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePeriod?.raw - layout[1] = period?.raw - layout[2] = unexpectedBetweenPeriodAndComponent?.raw - layout[3] = component.raw - layout[4] = unexpectedAfterComponent?.raw + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndOperatorToken?.raw + layout[3] = operatorToken.raw + layout[4] = unexpectedAfterOperatorToken?.raw } self.init(raw: raw) } - public var unexpectedBeforePeriod: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var period: RawTokenSyntax? { - layoutView.children[1].map(RawTokenSyntax.init(raw:)) + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndOperatorToken: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var component: RawSyntax { - layoutView.children[3]! + public var operatorToken: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterComponent: RawUnexpectedNodesSyntax? { + public var unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { +public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4817,7 +4849,7 @@ public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathPropertyComponent + return raw.kind == .specializeExpr } public var raw: RawSyntax @@ -4832,54 +4864,44 @@ public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? = nil, - declNameArguments: RawDeclNameArgumentsSyntax?, - _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, - genericArgumentClause: RawGenericArgumentClauseSyntax?, + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, + genericArgumentClause: RawGenericArgumentClauseSyntax, _ unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathPropertyComponent, uninitializedCount: 7, arena: arena) { layout in + kind: .specializeExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeIdentifier?.raw - layout[1] = identifier.raw - layout[2] = unexpectedBetweenIdentifierAndDeclNameArguments?.raw - layout[3] = declNameArguments?.raw - layout[4] = unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause?.raw - layout[5] = genericArgumentClause?.raw - layout[6] = unexpectedAfterGenericArgumentClause?.raw + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndGenericArgumentClause?.raw + layout[3] = genericArgumentClause.raw + layout[4] = unexpectedAfterGenericArgumentClause?.raw } self.init(raw: raw) } - public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndGenericArgumentClause: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var declNameArguments: RawDeclNameArgumentsSyntax? { - layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw:)) - } - public var unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var genericArgumentClause: RawGenericArgumentClauseSyntax? { - layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:)) + public var genericArgumentClause: RawGenericArgumentClauseSyntax { + layoutView.children[3].map(RawGenericArgumentClauseSyntax.init(raw:))! } public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { +public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4887,7 +4909,7 @@ public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathSubscriptComponent + return raw.kind == .stringSegment } public var raw: RawSyntax @@ -4902,54 +4924,34 @@ public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? = nil, - leftBracket: RawTokenSyntax, - _ unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? = nil, - argumentList: RawTupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? = nil, - rightBracket: RawTokenSyntax, - _ unexpectedAfterRightBracket: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeContent: RawUnexpectedNodesSyntax? = nil, + content: RawTokenSyntax, + _ unexpectedAfterContent: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathSubscriptComponent, uninitializedCount: 7, arena: arena) { layout in + kind: .stringSegment, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftBracket?.raw - layout[1] = leftBracket.raw - layout[2] = unexpectedBetweenLeftBracketAndArgumentList?.raw - layout[3] = argumentList.raw - layout[4] = unexpectedBetweenArgumentListAndRightBracket?.raw - layout[5] = rightBracket.raw - layout[6] = unexpectedAfterRightBracket?.raw + layout[0] = unexpectedBeforeContent?.raw + layout[1] = content.raw + layout[2] = unexpectedAfterContent?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeContent: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftBracket: RawTokenSyntax { + public var content: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? { + public var unexpectedAfterContent: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var argumentList: RawTupleExprElementListSyntax { - layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw:))! - } - public var unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var rightBracket: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterRightBracket: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { +public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4957,7 +4959,7 @@ public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathOptionalComponent + return raw.kind == .expressionSegment } public var raw: RawSyntax @@ -4972,34 +4974,74 @@ public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, - questionOrExclamationMark: RawTokenSyntax, - _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? = nil, + backslash: RawTokenSyntax, + _ unexpectedBetweenBackslashAndDelimiter: RawUnexpectedNodesSyntax? = nil, + delimiter: RawTokenSyntax?, + _ unexpectedBetweenDelimiterAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndExpressions: RawUnexpectedNodesSyntax? = nil, + expressions: RawTupleExprElementListSyntax, + _ unexpectedBetweenExpressionsAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathOptionalComponent, uninitializedCount: 3, arena: arena) { layout in + kind: .expressionSegment, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeQuestionOrExclamationMark?.raw - layout[1] = questionOrExclamationMark.raw - layout[2] = unexpectedAfterQuestionOrExclamationMark?.raw + layout[0] = unexpectedBeforeBackslash?.raw + layout[1] = backslash.raw + layout[2] = unexpectedBetweenBackslashAndDelimiter?.raw + layout[3] = delimiter?.raw + layout[4] = unexpectedBetweenDelimiterAndLeftParen?.raw + layout[5] = leftParen.raw + layout[6] = unexpectedBetweenLeftParenAndExpressions?.raw + layout[7] = expressions.raw + layout[8] = unexpectedBetweenExpressionsAndRightParen?.raw + layout[9] = rightParen.raw + layout[10] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var questionOrExclamationMark: RawTokenSyntax { + public var backslash: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenBackslashAndDelimiter: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var delimiter: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenDelimiterAndLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var leftParen: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenLeftParenAndExpressions: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var expressions: RawTupleExprElementListSyntax { + layoutView.children[7].map(RawTupleExprElementListSyntax.init(raw:))! + } + public var unexpectedBetweenExpressionsAndRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var rightParen: RawTokenSyntax { + layoutView.children[9].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5007,7 +5049,7 @@ public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .macroExpansionExpr + return raw.kind == .stringLiteralExpr } public var raw: RawSyntax @@ -5022,104 +5064,74 @@ public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? = nil, - poundToken: RawTokenSyntax, - _ unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? = nil, - macro: RawTokenSyntax, - _ unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? = nil, - genericArguments: RawGenericArgumentClauseSyntax?, - _ unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax?, - _ unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? = nil, - argumentList: RawTupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax?, - _ unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? = nil, - trailingClosure: RawClosureExprSyntax?, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, - additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax?, - _ unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeOpenDelimiter: RawUnexpectedNodesSyntax? = nil, + openDelimiter: RawTokenSyntax?, + _ unexpectedBetweenOpenDelimiterAndOpenQuote: RawUnexpectedNodesSyntax? = nil, + openQuote: RawTokenSyntax, + _ unexpectedBetweenOpenQuoteAndSegments: RawUnexpectedNodesSyntax? = nil, + segments: RawStringLiteralSegmentsSyntax, + _ unexpectedBetweenSegmentsAndCloseQuote: RawUnexpectedNodesSyntax? = nil, + closeQuote: RawTokenSyntax, + _ unexpectedBetweenCloseQuoteAndCloseDelimiter: RawUnexpectedNodesSyntax? = nil, + closeDelimiter: RawTokenSyntax?, + _ unexpectedAfterCloseDelimiter: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .macroExpansionExpr, uninitializedCount: 17, arena: arena) { layout in + kind: .stringLiteralExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundToken?.raw - layout[1] = poundToken.raw - layout[2] = unexpectedBetweenPoundTokenAndMacro?.raw - layout[3] = macro.raw - layout[4] = unexpectedBetweenMacroAndGenericArguments?.raw - layout[5] = genericArguments?.raw - layout[6] = unexpectedBetweenGenericArgumentsAndLeftParen?.raw - layout[7] = leftParen?.raw - layout[8] = unexpectedBetweenLeftParenAndArgumentList?.raw - layout[9] = argumentList.raw - layout[10] = unexpectedBetweenArgumentListAndRightParen?.raw - layout[11] = rightParen?.raw - layout[12] = unexpectedBetweenRightParenAndTrailingClosure?.raw - layout[13] = trailingClosure?.raw - layout[14] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw - layout[15] = additionalTrailingClosures?.raw - layout[16] = unexpectedAfterAdditionalTrailingClosures?.raw + layout[0] = unexpectedBeforeOpenDelimiter?.raw + layout[1] = openDelimiter?.raw + layout[2] = unexpectedBetweenOpenDelimiterAndOpenQuote?.raw + layout[3] = openQuote.raw + layout[4] = unexpectedBetweenOpenQuoteAndSegments?.raw + layout[5] = segments.raw + layout[6] = unexpectedBetweenSegmentsAndCloseQuote?.raw + layout[7] = closeQuote.raw + layout[8] = unexpectedBetweenCloseQuoteAndCloseDelimiter?.raw + layout[9] = closeDelimiter?.raw + layout[10] = unexpectedAfterCloseDelimiter?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeOpenDelimiter: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundToken: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var openDelimiter: RawTokenSyntax? { + layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenOpenDelimiterAndOpenQuote: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var macro: RawTokenSyntax { + public var openQuote: RawTokenSyntax { layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenOpenQuoteAndSegments: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericArguments: RawGenericArgumentClauseSyntax? { - layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:)) + public var segments: RawStringLiteralSegmentsSyntax { + layoutView.children[5].map(RawStringLiteralSegmentsSyntax.init(raw:))! } - public var unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenSegmentsAndCloseQuote: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) + public var closeQuote: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCloseQuoteAndCloseDelimiter: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var argumentList: RawTupleExprElementListSyntax { - layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw:))! + public var closeDelimiter: RawTokenSyntax? { + layoutView.children[9].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedAfterCloseDelimiter: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightParen: RawTokenSyntax? { - layoutView.children[11].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var trailingClosure: RawClosureExprSyntax? { - layoutView.children[13].map(RawClosureExprSyntax.init(raw:)) - } - public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? { - layoutView.children[15].map(RawMultipleTrailingClosureElementListSyntax.init(raw:)) - } - public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5127,7 +5139,7 @@ public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .postfixIfConfigExpr + return raw.kind == .regexLiteralExpr } public var raw: RawSyntax @@ -5142,44 +5154,34 @@ public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeBase: RawUnexpectedNodesSyntax? = nil, - base: RawExprSyntax?, - _ unexpectedBetweenBaseAndConfig: RawUnexpectedNodesSyntax? = nil, - config: RawIfConfigDeclSyntax, - _ unexpectedAfterConfig: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeRegex: RawUnexpectedNodesSyntax? = nil, + regex: RawTokenSyntax, + _ unexpectedAfterRegex: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .postfixIfConfigExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .regexLiteralExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeBase?.raw - layout[1] = base?.raw - layout[2] = unexpectedBetweenBaseAndConfig?.raw - layout[3] = config.raw - layout[4] = unexpectedAfterConfig?.raw + layout[0] = unexpectedBeforeRegex?.raw + layout[1] = regex.raw + layout[2] = unexpectedAfterRegex?.raw } self.init(raw: raw) } - public var unexpectedBeforeBase: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeRegex: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var base: RawExprSyntax? { - layoutView.children[1].map(RawExprSyntax.init(raw:)) + public var regex: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenBaseAndConfig: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRegex: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var config: RawIfConfigDeclSyntax { - layoutView.children[3].map(RawIfConfigDeclSyntax.init(raw:))! - } - public var unexpectedAfterConfig: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5187,7 +5189,7 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .editorPlaceholderExpr + return raw.kind == .keyPathExpr } public var raw: RawSyntax @@ -5202,34 +5204,54 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + _ unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? = nil, + backslash: RawTokenSyntax, + _ unexpectedBetweenBackslashAndRoot: RawUnexpectedNodesSyntax? = nil, + root: RawTypeSyntax?, + _ unexpectedBetweenRootAndComponents: RawUnexpectedNodesSyntax? = nil, + components: RawKeyPathComponentListSyntax, + _ unexpectedAfterComponents: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .editorPlaceholderExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .keyPathExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeIdentifier?.raw - layout[1] = identifier.raw - layout[2] = unexpectedAfterIdentifier?.raw + layout[0] = unexpectedBeforeBackslash?.raw + layout[1] = backslash.raw + layout[2] = unexpectedBetweenBackslashAndRoot?.raw + layout[3] = root?.raw + layout[4] = unexpectedBetweenRootAndComponents?.raw + layout[5] = components.raw + layout[6] = unexpectedAfterComponents?.raw } self.init(raw: raw) } - public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { + public var backslash: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenBackslashAndRoot: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var root: RawTypeSyntax? { + layoutView.children[3].map(RawTypeSyntax.init(raw:)) + } + public var unexpectedBetweenRootAndComponents: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var components: RawKeyPathComponentListSyntax { + layoutView.children[5].map(RawKeyPathComponentListSyntax.init(raw:))! + } + public var unexpectedAfterComponents: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { +public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5237,7 +5259,7 @@ public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .yieldExprList + return raw.kind == .keyPathComponentList } public var raw: RawSyntax @@ -5251,9 +5273,9 @@ public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawYieldExprListElementSyntax], arena: __shared SyntaxArena) { + public init(elements: [RawKeyPathComponentSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .yieldExprList, uninitializedCount: elements.count, arena: arena) { layout in + kind: .keyPathComponentList, uninitializedCount: elements.count, arena: arena) { layout in guard var ptr = layout.baseAddress else { return } for elem in elements { ptr.initialize(to: elem.raw) @@ -5263,13 +5285,48 @@ public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { self.init(raw: raw) } - public var elements: [RawYieldExprListElementSyntax] { - layoutView.children.map { RawYieldExprListElementSyntax(raw: $0!) } + public var elements: [RawKeyPathComponentSyntax] { + layoutView.children.map { RawKeyPathComponentSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawYieldExprListElementSyntax: RawSyntaxNodeProtocol { +public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum Component: RawSyntaxNodeProtocol { + case `property`(RawKeyPathPropertyComponentSyntax) + case `subscript`(RawKeyPathSubscriptComponentSyntax) + case `optional`(RawKeyPathOptionalComponentSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return RawKeyPathPropertyComponentSyntax.isKindOf(raw) || RawKeyPathSubscriptComponentSyntax.isKindOf(raw) || RawKeyPathOptionalComponentSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .property(let node): return node.raw + case .subscript(let node): return node.raw + case .optional(let node): return node.raw + } + } + + public init?(_ other: T) where T : RawSyntaxNodeProtocol { + if let node = RawKeyPathPropertyComponentSyntax(other) { + self = .property(node) + return + } + if let node = RawKeyPathSubscriptComponentSyntax(other) { + self = .subscript(node) + return + } + if let node = RawKeyPathOptionalComponentSyntax(other) { + self = .optional(node) + return + } + return nil + } + } + @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5277,7 +5334,7 @@ public struct RawYieldExprListElementSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .yieldExprListElement + return raw.kind == .keyPathComponent } public var raw: RawSyntax @@ -5292,44 +5349,44 @@ public struct RawYieldExprListElementSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndComma: RawUnexpectedNodesSyntax? = nil, - comma: RawTokenSyntax?, - _ unexpectedAfterComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforePeriod: RawUnexpectedNodesSyntax? = nil, + period: RawTokenSyntax?, + _ unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? = nil, + component: Component, + _ unexpectedAfterComponent: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .yieldExprListElement, uninitializedCount: 5, arena: arena) { layout in + kind: .keyPathComponent, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeExpression?.raw - layout[1] = expression.raw - layout[2] = unexpectedBetweenExpressionAndComma?.raw - layout[3] = comma?.raw - layout[4] = unexpectedAfterComma?.raw + layout[0] = unexpectedBeforePeriod?.raw + layout[1] = period?.raw + layout[2] = unexpectedBetweenPeriodAndComponent?.raw + layout[3] = component.raw + layout[4] = unexpectedAfterComponent?.raw } self.init(raw: raw) } - public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePeriod: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! + public var period: RawTokenSyntax? { + layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenExpressionAndComma: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var comma: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var component: RawSyntax { + layoutView.children[3]! } - public var unexpectedAfterComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterComponent: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { +public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5337,7 +5394,7 @@ public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typeInitializerClause + return raw.kind == .keyPathPropertyComponent } public var raw: RawSyntax @@ -5352,44 +5409,54 @@ public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeEqual: RawUnexpectedNodesSyntax? = nil, - equal: RawTokenSyntax, - _ unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? = nil, - value: RawTypeSyntax, - _ unexpectedAfterValue: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? = nil, + declNameArguments: RawDeclNameArgumentsSyntax?, + _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, + genericArgumentClause: RawGenericArgumentClauseSyntax?, + _ unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeInitializerClause, uninitializedCount: 5, arena: arena) { layout in + kind: .keyPathPropertyComponent, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeEqual?.raw - layout[1] = equal.raw - layout[2] = unexpectedBetweenEqualAndValue?.raw - layout[3] = value.raw - layout[4] = unexpectedAfterValue?.raw + layout[0] = unexpectedBeforeIdentifier?.raw + layout[1] = identifier.raw + layout[2] = unexpectedBetweenIdentifierAndDeclNameArguments?.raw + layout[3] = declNameArguments?.raw + layout[4] = unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause?.raw + layout[5] = genericArgumentClause?.raw + layout[6] = unexpectedAfterGenericArgumentClause?.raw } self.init(raw: raw) } - public var unexpectedBeforeEqual: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var equal: RawTokenSyntax { + public var identifier: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var value: RawTypeSyntax { - layoutView.children[3].map(RawTypeSyntax.init(raw:))! + public var declNameArguments: RawDeclNameArgumentsSyntax? { + layoutView.children[3].map(RawDeclNameArgumentsSyntax.init(raw:)) } - public var unexpectedAfterValue: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var genericArgumentClause: RawGenericArgumentClauseSyntax? { + layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:)) + } + public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5397,7 +5464,7 @@ public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typealiasDecl + return raw.kind == .keyPathSubscriptComponent } public var raw: RawSyntax @@ -5412,94 +5479,104 @@ public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, - modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndTypealiasKeyword: RawUnexpectedNodesSyntax? = nil, - typealiasKeyword: RawTokenSyntax, - _ unexpectedBetweenTypealiasKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, - genericParameterClause: RawGenericParameterClauseSyntax?, - _ unexpectedBetweenGenericParameterClauseAndInitializer: RawUnexpectedNodesSyntax? = nil, - initializer: RawTypeInitializerClauseSyntax, - _ unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, - genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? = nil, + leftBracket: RawTokenSyntax, + _ unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? = nil, + argumentList: RawTupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? = nil, + rightBracket: RawTokenSyntax, + _ unexpectedAfterRightBracket: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typealiasDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .keyPathSubscriptComponent, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAttributes?.raw - layout[1] = attributes?.raw - layout[2] = unexpectedBetweenAttributesAndModifiers?.raw - layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndTypealiasKeyword?.raw - layout[5] = typealiasKeyword.raw - layout[6] = unexpectedBetweenTypealiasKeywordAndIdentifier?.raw - layout[7] = identifier.raw - layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw - layout[9] = genericParameterClause?.raw - layout[10] = unexpectedBetweenGenericParameterClauseAndInitializer?.raw - layout[11] = initializer.raw - layout[12] = unexpectedBetweenInitializerAndGenericWhereClause?.raw - layout[13] = genericWhereClause?.raw - layout[14] = unexpectedAfterGenericWhereClause?.raw + layout[0] = unexpectedBeforeLeftBracket?.raw + layout[1] = leftBracket.raw + layout[2] = unexpectedBetweenLeftBracketAndArgumentList?.raw + layout[3] = argumentList.raw + layout[4] = unexpectedBetweenArgumentListAndRightBracket?.raw + layout[5] = rightBracket.raw + layout[6] = unexpectedAfterRightBracket?.raw } self.init(raw: raw) } - public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var leftBracket: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var modifiers: RawModifierListSyntax? { - layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + public var argumentList: RawTupleExprElementListSyntax { + layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw:))! } - public var unexpectedBetweenModifiersAndTypealiasKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var typealiasKeyword: RawTokenSyntax { + public var rightBracket: RawTokenSyntax { layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenTypealiasKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRightBracket: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) +} + +@_spi(RawSyntax) +public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! } - public var genericParameterClause: RawGenericParameterClauseSyntax? { - layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .keyPathOptionalComponent } - public var unexpectedBetweenGenericParameterClauseAndInitializer: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw } - public var initializer: RawTypeInitializerClauseSyntax { - layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw:))! + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) } - public var unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + + public init( + _ unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + questionOrExclamationMark: RawTokenSyntax, + _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .keyPathOptionalComponent, uninitializedCount: 3, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeQuestionOrExclamationMark?.raw + layout[1] = questionOrExclamationMark.raw + layout[2] = unexpectedAfterQuestionOrExclamationMark?.raw + } + self.init(raw: raw) } - public var genericWhereClause: RawGenericWhereClauseSyntax? { - layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + + public var unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + public var questionOrExclamationMark: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5507,7 +5584,7 @@ public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .associatedtypeDecl + return raw.kind == .macroExpansionExpr } public var raw: RawSyntax @@ -5522,94 +5599,104 @@ public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, - modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndAssociatedtypeKeyword: RawUnexpectedNodesSyntax? = nil, - associatedtypeKeyword: RawTokenSyntax, - _ unexpectedBetweenAssociatedtypeKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, - inheritanceClause: RawTypeInheritanceClauseSyntax?, - _ unexpectedBetweenInheritanceClauseAndInitializer: RawUnexpectedNodesSyntax? = nil, - initializer: RawTypeInitializerClauseSyntax?, - _ unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, - genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? = nil, + poundToken: RawTokenSyntax, + _ unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? = nil, + macro: RawTokenSyntax, + _ unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? = nil, + genericArguments: RawGenericArgumentClauseSyntax?, + _ unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax?, + _ unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? = nil, + argumentList: RawTupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax?, + _ unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? = nil, + trailingClosure: RawClosureExprSyntax?, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, + additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax?, + _ unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .associatedtypeDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .macroExpansionExpr, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAttributes?.raw - layout[1] = attributes?.raw - layout[2] = unexpectedBetweenAttributesAndModifiers?.raw - layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndAssociatedtypeKeyword?.raw - layout[5] = associatedtypeKeyword.raw - layout[6] = unexpectedBetweenAssociatedtypeKeywordAndIdentifier?.raw - layout[7] = identifier.raw - layout[8] = unexpectedBetweenIdentifierAndInheritanceClause?.raw - layout[9] = inheritanceClause?.raw - layout[10] = unexpectedBetweenInheritanceClauseAndInitializer?.raw - layout[11] = initializer?.raw - layout[12] = unexpectedBetweenInitializerAndGenericWhereClause?.raw - layout[13] = genericWhereClause?.raw - layout[14] = unexpectedAfterGenericWhereClause?.raw + layout[0] = unexpectedBeforePoundToken?.raw + layout[1] = poundToken.raw + layout[2] = unexpectedBetweenPoundTokenAndMacro?.raw + layout[3] = macro.raw + layout[4] = unexpectedBetweenMacroAndGenericArguments?.raw + layout[5] = genericArguments?.raw + layout[6] = unexpectedBetweenGenericArgumentsAndLeftParen?.raw + layout[7] = leftParen?.raw + layout[8] = unexpectedBetweenLeftParenAndArgumentList?.raw + layout[9] = argumentList.raw + layout[10] = unexpectedBetweenArgumentListAndRightParen?.raw + layout[11] = rightParen?.raw + layout[12] = unexpectedBetweenRightParenAndTrailingClosure?.raw + layout[13] = trailingClosure?.raw + layout[14] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw + layout[15] = additionalTrailingClosures?.raw + layout[16] = unexpectedAfterAdditionalTrailingClosures?.raw } self.init(raw: raw) } - public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var poundToken: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var modifiers: RawModifierListSyntax? { - layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + public var macro: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenModifiersAndAssociatedtypeKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var associatedtypeKeyword: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var genericArguments: RawGenericArgumentClauseSyntax? { + layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:)) } - public var unexpectedBetweenAssociatedtypeKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! + public var leftParen: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenIdentifierAndInheritanceClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var inheritanceClause: RawTypeInheritanceClauseSyntax? { - layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw:)) + public var argumentList: RawTupleExprElementListSyntax { + layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw:))! } - public var unexpectedBetweenInheritanceClauseAndInitializer: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var initializer: RawTypeInitializerClauseSyntax? { - layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw:)) + public var rightParen: RawTokenSyntax? { + layoutView.children[11].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? { layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericWhereClause: RawGenericWhereClauseSyntax? { - layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + public var trailingClosure: RawClosureExprSyntax? { + layoutView.children[13].map(RawClosureExprSyntax.init(raw:)) } - public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? { + layoutView.children[15].map(RawMultipleTrailingClosureElementListSyntax.init(raw:)) + } + public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? { + layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { +public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5617,7 +5704,7 @@ public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .functionParameterList + return raw.kind == .postfixIfConfigExpr } public var raw: RawSyntax @@ -5631,25 +5718,45 @@ public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawFunctionParameterSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforeBase: RawUnexpectedNodesSyntax? = nil, + base: RawExprSyntax?, + _ unexpectedBetweenBaseAndConfig: RawUnexpectedNodesSyntax? = nil, + config: RawIfConfigDeclSyntax, + _ unexpectedAfterConfig: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .functionParameterList, 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 - } + kind: .postfixIfConfigExpr, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeBase?.raw + layout[1] = base?.raw + layout[2] = unexpectedBetweenBaseAndConfig?.raw + layout[3] = config.raw + layout[4] = unexpectedAfterConfig?.raw } self.init(raw: raw) } - public var elements: [RawFunctionParameterSyntax] { - layoutView.children.map { RawFunctionParameterSyntax(raw: $0!) } + public var unexpectedBeforeBase: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var base: RawExprSyntax? { + layoutView.children[1].map(RawExprSyntax.init(raw:)) + } + public var unexpectedBetweenBaseAndConfig: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var config: RawIfConfigDeclSyntax { + layoutView.children[3].map(RawIfConfigDeclSyntax.init(raw:))! + } + public var unexpectedAfterConfig: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { +public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5657,7 +5764,7 @@ public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .parameterClause + return raw.kind == .editorPlaceholderExpr } public var raw: RawSyntax @@ -5672,54 +5779,34 @@ public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? = nil, - parameterList: RawFunctionParameterListSyntax, - _ unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .parameterClause, uninitializedCount: 7, arena: arena) { layout in + kind: .editorPlaceholderExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftParen?.raw - layout[1] = leftParen.raw - layout[2] = unexpectedBetweenLeftParenAndParameterList?.raw - layout[3] = parameterList.raw - layout[4] = unexpectedBetweenParameterListAndRightParen?.raw - layout[5] = rightParen.raw - layout[6] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforeIdentifier?.raw + layout[1] = identifier.raw + layout[2] = unexpectedAfterIdentifier?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { + public var identifier: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? { + public var unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var parameterList: RawFunctionParameterListSyntax { - layoutView.children[3].map(RawFunctionParameterListSyntax.init(raw:))! - } - public var unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var rightParen: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { +public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5727,7 +5814,7 @@ public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .returnClause + return raw.kind == .yieldExprList } public var raw: RawSyntax @@ -5741,45 +5828,25 @@ public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeArrow: RawUnexpectedNodesSyntax? = nil, - arrow: RawTokenSyntax, - _ unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? = nil, - returnType: RawTypeSyntax, - _ unexpectedAfterReturnType: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawYieldExprListElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .returnClause, uninitializedCount: 5, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeArrow?.raw - layout[1] = arrow.raw - layout[2] = unexpectedBetweenArrowAndReturnType?.raw - layout[3] = returnType.raw - layout[4] = unexpectedAfterReturnType?.raw + kind: .yieldExprList, 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 unexpectedBeforeArrow: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var arrow: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var returnType: RawTypeSyntax { - layoutView.children[3].map(RawTypeSyntax.init(raw:))! - } - public var unexpectedAfterReturnType: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawYieldExprListElementSyntax] { + layoutView.children.map { RawYieldExprListElementSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { +public struct RawYieldExprListElementSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5787,7 +5854,7 @@ public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .functionSignature + return raw.kind == .yieldExprListElement } public var raw: RawSyntax @@ -5802,111 +5869,44 @@ public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeInput: RawUnexpectedNodesSyntax? = nil, - input: RawParameterClauseSyntax, - _ unexpectedBetweenInputAndAsyncOrReasyncKeyword: RawUnexpectedNodesSyntax? = nil, - asyncOrReasyncKeyword: RawTokenSyntax?, - _ unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: RawUnexpectedNodesSyntax? = nil, - throwsOrRethrowsKeyword: RawTokenSyntax?, - _ unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: RawUnexpectedNodesSyntax? = nil, - output: RawReturnClauseSyntax?, - _ unexpectedAfterOutput: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndComma: RawUnexpectedNodesSyntax? = nil, + comma: RawTokenSyntax?, + _ unexpectedAfterComma: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionSignature, uninitializedCount: 9, arena: arena) { layout in + kind: .yieldExprListElement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeInput?.raw - layout[1] = input.raw - layout[2] = unexpectedBetweenInputAndAsyncOrReasyncKeyword?.raw - layout[3] = asyncOrReasyncKeyword?.raw - layout[4] = unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword?.raw - layout[5] = throwsOrRethrowsKeyword?.raw - layout[6] = unexpectedBetweenThrowsOrRethrowsKeywordAndOutput?.raw - layout[7] = output?.raw - layout[8] = unexpectedAfterOutput?.raw + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndComma?.raw + layout[3] = comma?.raw + layout[4] = unexpectedAfterComma?.raw } self.init(raw: raw) } - public var unexpectedBeforeInput: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var input: RawParameterClauseSyntax { - layoutView.children[1].map(RawParameterClauseSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenInputAndAsyncOrReasyncKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndComma: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var asyncOrReasyncKeyword: RawTokenSyntax? { + public var comma: RawTokenSyntax? { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedAfterComma: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var throwsOrRethrowsKeyword: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var output: RawReturnClauseSyntax? { - layoutView.children[7].map(RawReturnClauseSyntax.init(raw:)) - } - public var unexpectedAfterOutput: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Elements: RawSyntaxNodeProtocol { - case `statements`(RawCodeBlockItemListSyntax) - case `switchCases`(RawSwitchCaseListSyntax) - case `decls`(RawMemberDeclListSyntax) - case `postfixExpression`(RawExprSyntax) - case `attributes`(RawAttributeListSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawCodeBlockItemListSyntax.isKindOf(raw) || RawSwitchCaseListSyntax.isKindOf(raw) || RawMemberDeclListSyntax.isKindOf(raw) || RawExprSyntax.isKindOf(raw) || RawAttributeListSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .statements(let node): return node.raw - case .switchCases(let node): return node.raw - case .decls(let node): return node.raw - case .postfixExpression(let node): return node.raw - case .attributes(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawCodeBlockItemListSyntax(other) { - self = .statements(node) - return - } - if let node = RawSwitchCaseListSyntax(other) { - self = .switchCases(node) - return - } - if let node = RawMemberDeclListSyntax(other) { - self = .decls(node) - return - } - if let node = RawExprSyntax(other) { - self = .postfixExpression(node) - return - } - if let node = RawAttributeListSyntax(other) { - self = .attributes(node) - return - } - return nil - } - } - +public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5914,7 +5914,7 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifConfigClause + return raw.kind == .typeInitializerClause } public var raw: RawSyntax @@ -5929,54 +5929,44 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? = nil, - poundKeyword: RawTokenSyntax, - _ unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? = nil, - condition: RawExprSyntax?, - _ unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? = nil, - elements: Elements?, - _ unexpectedAfterElements: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeEqual: RawUnexpectedNodesSyntax? = nil, + equal: RawTokenSyntax, + _ unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? = nil, + value: RawTypeSyntax, + _ unexpectedAfterValue: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .ifConfigClause, uninitializedCount: 7, arena: arena) { layout in + kind: .typeInitializerClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundKeyword?.raw - layout[1] = poundKeyword.raw - layout[2] = unexpectedBetweenPoundKeywordAndCondition?.raw - layout[3] = condition?.raw - layout[4] = unexpectedBetweenConditionAndElements?.raw - layout[5] = elements?.raw - layout[6] = unexpectedAfterElements?.raw + layout[0] = unexpectedBeforeEqual?.raw + layout[1] = equal.raw + layout[2] = unexpectedBetweenEqualAndValue?.raw + layout[3] = value.raw + layout[4] = unexpectedAfterValue?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeEqual: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundKeyword: RawTokenSyntax { + public var equal: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var condition: RawExprSyntax? { - layoutView.children[3].map(RawExprSyntax.init(raw:)) + public var value: RawTypeSyntax { + layoutView.children[3].map(RawTypeSyntax.init(raw:))! } - public var unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? { + public var unexpectedAfterValue: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var elements: RawSyntax? { - layoutView.children[5] - } - public var unexpectedAfterElements: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { +public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5984,7 +5974,7 @@ public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifConfigClauseList + return raw.kind == .typealiasDecl } public var raw: RawSyntax @@ -5998,33 +5988,103 @@ public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawIfConfigClauseSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndTypealiasKeyword: RawUnexpectedNodesSyntax? = nil, + typealiasKeyword: RawTokenSyntax, + _ unexpectedBetweenTypealiasKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, + genericParameterClause: RawGenericParameterClauseSyntax?, + _ unexpectedBetweenGenericParameterClauseAndInitializer: RawUnexpectedNodesSyntax? = nil, + initializer: RawTypeInitializerClauseSyntax, + _ unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + genericWhereClause: RawGenericWhereClauseSyntax?, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .ifConfigClauseList, 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 - } + kind: .typealiasDecl, uninitializedCount: 15, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers?.raw + layout[4] = unexpectedBetweenModifiersAndTypealiasKeyword?.raw + layout[5] = typealiasKeyword.raw + layout[6] = unexpectedBetweenTypealiasKeywordAndIdentifier?.raw + layout[7] = identifier.raw + layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw + layout[9] = genericParameterClause?.raw + layout[10] = unexpectedBetweenGenericParameterClauseAndInitializer?.raw + layout[11] = initializer.raw + layout[12] = unexpectedBetweenInitializerAndGenericWhereClause?.raw + layout[13] = genericWhereClause?.raw + layout[14] = unexpectedAfterGenericWhereClause?.raw } self.init(raw: raw) } - public var elements: [RawIfConfigClauseSyntax] { - layoutView.children.map { RawIfConfigClauseSyntax(raw: $0!) } + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } -} - -@_spi(RawSyntax) -public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifConfigDecl + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + } + public var unexpectedBetweenModifiersAndTypealiasKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var typealiasKeyword: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenTypealiasKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var identifier: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var genericParameterClause: RawGenericParameterClauseSyntax? { + layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) + } + public var unexpectedBetweenGenericParameterClauseAndInitializer: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var initializer: RawTypeInitializerClauseSyntax { + layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw:))! + } + public var unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var genericWhereClause: RawGenericWhereClauseSyntax? { + layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + } + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .associatedtypeDecl } public var raw: RawSyntax @@ -6039,44 +6099,94 @@ public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforeClauses: RawUnexpectedNodesSyntax? = nil, - clauses: RawIfConfigClauseListSyntax, - _ unexpectedBetweenClausesAndPoundEndif: RawUnexpectedNodesSyntax? = nil, - poundEndif: RawTokenSyntax, - _ unexpectedAfterPoundEndif: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndAssociatedtypeKeyword: RawUnexpectedNodesSyntax? = nil, + associatedtypeKeyword: RawTokenSyntax, + _ unexpectedBetweenAssociatedtypeKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, + inheritanceClause: RawTypeInheritanceClauseSyntax?, + _ unexpectedBetweenInheritanceClauseAndInitializer: RawUnexpectedNodesSyntax? = nil, + initializer: RawTypeInitializerClauseSyntax?, + _ unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + genericWhereClause: RawGenericWhereClauseSyntax?, + _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .ifConfigDecl, uninitializedCount: 5, arena: arena) { layout in + kind: .associatedtypeDecl, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeClauses?.raw - layout[1] = clauses.raw - layout[2] = unexpectedBetweenClausesAndPoundEndif?.raw - layout[3] = poundEndif.raw - layout[4] = unexpectedAfterPoundEndif?.raw + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers?.raw + layout[4] = unexpectedBetweenModifiersAndAssociatedtypeKeyword?.raw + layout[5] = associatedtypeKeyword.raw + layout[6] = unexpectedBetweenAssociatedtypeKeywordAndIdentifier?.raw + layout[7] = identifier.raw + layout[8] = unexpectedBetweenIdentifierAndInheritanceClause?.raw + layout[9] = inheritanceClause?.raw + layout[10] = unexpectedBetweenInheritanceClauseAndInitializer?.raw + layout[11] = initializer?.raw + layout[12] = unexpectedBetweenInitializerAndGenericWhereClause?.raw + layout[13] = genericWhereClause?.raw + layout[14] = unexpectedAfterGenericWhereClause?.raw } self.init(raw: raw) } - public var unexpectedBeforeClauses: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var clauses: RawIfConfigClauseListSyntax { - layoutView.children[1].map(RawIfConfigClauseListSyntax.init(raw:))! + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) } - public var unexpectedBetweenClausesAndPoundEndif: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundEndif: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedAfterPoundEndif: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndAssociatedtypeKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var associatedtypeKeyword: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenAssociatedtypeKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var identifier: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenIdentifierAndInheritanceClause: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var inheritanceClause: RawTypeInheritanceClauseSyntax? { + layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw:)) + } + public var unexpectedBetweenInheritanceClauseAndInitializer: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var initializer: RawTypeInitializerClauseSyntax? { + layoutView.children[11].map(RawTypeInitializerClauseSyntax.init(raw:)) + } + public var unexpectedBetweenInitializerAndGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var genericWhereClause: RawGenericWhereClauseSyntax? { + layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + } + public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawPoundErrorDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6084,7 +6194,7 @@ public struct RawPoundErrorDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundErrorDecl + return raw.kind == .functionParameterList } public var raw: RawSyntax @@ -6098,65 +6208,25 @@ public struct RawPoundErrorDeclSyntax: RawDeclSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforePoundError: RawUnexpectedNodesSyntax? = nil, - poundError: RawTokenSyntax, - _ unexpectedBetweenPoundErrorAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? = nil, - message: RawStringLiteralExprSyntax, - _ unexpectedBetweenMessageAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawFunctionParameterSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .poundErrorDecl, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundError?.raw - layout[1] = poundError.raw - layout[2] = unexpectedBetweenPoundErrorAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndMessage?.raw - layout[5] = message.raw - layout[6] = unexpectedBetweenMessageAndRightParen?.raw - layout[7] = rightParen.raw - layout[8] = unexpectedAfterRightParen?.raw + kind: .functionParameterList, 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 unexpectedBeforePoundError: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var poundError: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenPoundErrorAndLeftParen: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var message: RawStringLiteralExprSyntax { - layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))! - } - public var unexpectedBetweenMessageAndRightParen: 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:)) + public var elements: [RawFunctionParameterSyntax] { + layoutView.children.map { RawFunctionParameterSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawPoundWarningDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6164,7 +6234,7 @@ public struct RawPoundWarningDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundWarningDecl + return raw.kind == .parameterClause } public var raw: RawSyntax @@ -6179,64 +6249,54 @@ public struct RawPoundWarningDeclSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundWarning: RawUnexpectedNodesSyntax? = nil, - poundWarning: RawTokenSyntax, - _ unexpectedBetweenPoundWarningAndLeftParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? = nil, - message: RawStringLiteralExprSyntax, - _ unexpectedBetweenMessageAndRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? = nil, + parameterList: RawFunctionParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? = nil, rightParen: RawTokenSyntax, _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundWarningDecl, uninitializedCount: 9, arena: arena) { layout in + kind: .parameterClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundWarning?.raw - layout[1] = poundWarning.raw - layout[2] = unexpectedBetweenPoundWarningAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndMessage?.raw - layout[5] = message.raw - layout[6] = unexpectedBetweenMessageAndRightParen?.raw - layout[7] = rightParen.raw - layout[8] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforeLeftParen?.raw + layout[1] = leftParen.raw + layout[2] = unexpectedBetweenLeftParenAndParameterList?.raw + layout[3] = parameterList.raw + layout[4] = unexpectedBetweenParameterListAndRightParen?.raw + layout[5] = rightParen.raw + layout[6] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundWarning: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundWarning: RawTokenSyntax { + public var leftParen: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenPoundWarningAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var parameterList: RawFunctionParameterListSyntax { + layoutView.children[3].map(RawFunctionParameterListSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var message: RawStringLiteralExprSyntax { - layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))! - } - public var unexpectedBetweenMessageAndRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } public var rightParen: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { +public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6244,7 +6304,7 @@ public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundSourceLocation + return raw.kind == .returnClause } public var raw: RawSyntax @@ -6259,64 +6319,44 @@ public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundSourceLocation: RawUnexpectedNodesSyntax? = nil, - poundSourceLocation: RawTokenSyntax, - _ unexpectedBetweenPoundSourceLocationAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndArgs: RawUnexpectedNodesSyntax? = nil, - args: RawPoundSourceLocationArgsSyntax?, - _ unexpectedBetweenArgsAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeArrow: RawUnexpectedNodesSyntax? = nil, + arrow: RawTokenSyntax, + _ unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? = nil, + returnType: RawTypeSyntax, + _ unexpectedAfterReturnType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundSourceLocation, uninitializedCount: 9, arena: arena) { layout in + kind: .returnClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundSourceLocation?.raw - layout[1] = poundSourceLocation.raw - layout[2] = unexpectedBetweenPoundSourceLocationAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndArgs?.raw - layout[5] = args?.raw - layout[6] = unexpectedBetweenArgsAndRightParen?.raw - layout[7] = rightParen.raw - layout[8] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforeArrow?.raw + layout[1] = arrow.raw + layout[2] = unexpectedBetweenArrowAndReturnType?.raw + layout[3] = returnType.raw + layout[4] = unexpectedAfterReturnType?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundSourceLocation: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeArrow: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundSourceLocation: RawTokenSyntax { + public var arrow: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenPoundSourceLocationAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var returnType: RawTypeSyntax { + layoutView.children[3].map(RawTypeSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndArgs: RawUnexpectedNodesSyntax? { + public var unexpectedAfterReturnType: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var args: RawPoundSourceLocationArgsSyntax? { - layoutView.children[5].map(RawPoundSourceLocationArgsSyntax.init(raw:)) - } - public var unexpectedBetweenArgsAndRightParen: 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 RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { +public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6324,7 +6364,7 @@ public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundSourceLocationArgs + return raw.kind == .functionSignature } public var raw: RawSyntax @@ -6339,94 +6379,111 @@ public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? = nil, - fileArgLabel: RawTokenSyntax, - _ unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? = nil, - fileArgColon: RawTokenSyntax, - _ unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? = nil, - fileName: RawTokenSyntax, - _ unexpectedBetweenFileNameAndComma: RawUnexpectedNodesSyntax? = nil, - comma: RawTokenSyntax, - _ unexpectedBetweenCommaAndLineArgLabel: RawUnexpectedNodesSyntax? = nil, - lineArgLabel: RawTokenSyntax, - _ unexpectedBetweenLineArgLabelAndLineArgColon: RawUnexpectedNodesSyntax? = nil, - lineArgColon: RawTokenSyntax, - _ unexpectedBetweenLineArgColonAndLineNumber: RawUnexpectedNodesSyntax? = nil, - lineNumber: RawTokenSyntax, - _ unexpectedAfterLineNumber: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeInput: RawUnexpectedNodesSyntax? = nil, + input: RawParameterClauseSyntax, + _ unexpectedBetweenInputAndAsyncOrReasyncKeyword: RawUnexpectedNodesSyntax? = nil, + asyncOrReasyncKeyword: RawTokenSyntax?, + _ unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: RawUnexpectedNodesSyntax? = nil, + throwsOrRethrowsKeyword: RawTokenSyntax?, + _ unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: RawUnexpectedNodesSyntax? = nil, + output: RawReturnClauseSyntax?, + _ unexpectedAfterOutput: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundSourceLocationArgs, uninitializedCount: 15, arena: arena) { layout in + kind: .functionSignature, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeFileArgLabel?.raw - layout[1] = fileArgLabel.raw - layout[2] = unexpectedBetweenFileArgLabelAndFileArgColon?.raw - layout[3] = fileArgColon.raw - layout[4] = unexpectedBetweenFileArgColonAndFileName?.raw - layout[5] = fileName.raw - layout[6] = unexpectedBetweenFileNameAndComma?.raw - layout[7] = comma.raw - layout[8] = unexpectedBetweenCommaAndLineArgLabel?.raw - layout[9] = lineArgLabel.raw - layout[10] = unexpectedBetweenLineArgLabelAndLineArgColon?.raw - layout[11] = lineArgColon.raw - layout[12] = unexpectedBetweenLineArgColonAndLineNumber?.raw - layout[13] = lineNumber.raw - layout[14] = unexpectedAfterLineNumber?.raw + layout[0] = unexpectedBeforeInput?.raw + layout[1] = input.raw + layout[2] = unexpectedBetweenInputAndAsyncOrReasyncKeyword?.raw + layout[3] = asyncOrReasyncKeyword?.raw + layout[4] = unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword?.raw + layout[5] = throwsOrRethrowsKeyword?.raw + layout[6] = unexpectedBetweenThrowsOrRethrowsKeywordAndOutput?.raw + layout[7] = output?.raw + layout[8] = unexpectedAfterOutput?.raw } self.init(raw: raw) } - public var unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeInput: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var fileArgLabel: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var input: RawParameterClauseSyntax { + layoutView.children[1].map(RawParameterClauseSyntax.init(raw:))! } - public var unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenInputAndAsyncOrReasyncKeyword: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var fileArgColon: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var asyncOrReasyncKeyword: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncOrReasyncKeywordAndThrowsOrRethrowsKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var fileName: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var throwsOrRethrowsKeyword: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenFileNameAndComma: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsOrRethrowsKeywordAndOutput: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var comma: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! + public var output: RawReturnClauseSyntax? { + layoutView.children[7].map(RawReturnClauseSyntax.init(raw:)) } - public var unexpectedBetweenCommaAndLineArgLabel: RawUnexpectedNodesSyntax? { + public var unexpectedAfterOutput: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var lineArgLabel: RawTokenSyntax { - layoutView.children[9].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLineArgLabelAndLineArgColon: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var lineArgColon: RawTokenSyntax { - layoutView.children[11].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLineArgColonAndLineNumber: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var lineNumber: RawTokenSyntax { - layoutView.children[13].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterLineNumber: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { +public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum Elements: RawSyntaxNodeProtocol { + case `statements`(RawCodeBlockItemListSyntax) + case `switchCases`(RawSwitchCaseListSyntax) + case `decls`(RawMemberDeclListSyntax) + case `postfixExpression`(RawExprSyntax) + case `attributes`(RawAttributeListSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return RawCodeBlockItemListSyntax.isKindOf(raw) || RawSwitchCaseListSyntax.isKindOf(raw) || RawMemberDeclListSyntax.isKindOf(raw) || RawExprSyntax.isKindOf(raw) || RawAttributeListSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .statements(let node): return node.raw + case .switchCases(let node): return node.raw + case .decls(let node): return node.raw + case .postfixExpression(let node): return node.raw + case .attributes(let node): return node.raw + } + } + + public init?(_ other: T) where T : RawSyntaxNodeProtocol { + if let node = RawCodeBlockItemListSyntax(other) { + self = .statements(node) + return + } + if let node = RawSwitchCaseListSyntax(other) { + self = .switchCases(node) + return + } + if let node = RawMemberDeclListSyntax(other) { + self = .decls(node) + return + } + if let node = RawExprSyntax(other) { + self = .postfixExpression(node) + return + } + if let node = RawAttributeListSyntax(other) { + self = .attributes(node) + return + } + return nil + } + } + @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6434,7 +6491,7 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .declModifierDetail + return raw.kind == .ifConfigClause } public var raw: RawSyntax @@ -6449,54 +6506,54 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? = nil, - detail: RawTokenSyntax, - _ unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? = nil, + poundKeyword: RawTokenSyntax, + _ unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? = nil, + condition: RawExprSyntax?, + _ unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? = nil, + elements: Elements?, + _ unexpectedAfterElements: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .declModifierDetail, uninitializedCount: 7, arena: arena) { layout in + kind: .ifConfigClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftParen?.raw - layout[1] = leftParen.raw - layout[2] = unexpectedBetweenLeftParenAndDetail?.raw - layout[3] = detail.raw - layout[4] = unexpectedBetweenDetailAndRightParen?.raw - layout[5] = rightParen.raw - layout[6] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforePoundKeyword?.raw + layout[1] = poundKeyword.raw + layout[2] = unexpectedBetweenPoundKeywordAndCondition?.raw + layout[3] = condition?.raw + layout[4] = unexpectedBetweenConditionAndElements?.raw + layout[5] = elements?.raw + layout[6] = unexpectedAfterElements?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { + public var poundKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var detail: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var condition: RawExprSyntax? { + layoutView.children[3].map(RawExprSyntax.init(raw:)) } - public var unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightParen: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var elements: RawSyntax? { + layoutView.children[5] } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedAfterElements: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { +public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6504,7 +6561,7 @@ public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .declModifier + return raw.kind == .ifConfigClauseList } public var raw: RawSyntax @@ -6518,45 +6575,25 @@ public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax, - _ unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? = nil, - detail: RawDeclModifierDetailSyntax?, - _ unexpectedAfterDetail: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawIfConfigClauseSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .declModifier, uninitializedCount: 5, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeName?.raw - layout[1] = name.raw - layout[2] = unexpectedBetweenNameAndDetail?.raw - layout[3] = detail?.raw - layout[4] = unexpectedAfterDetail?.raw + kind: .ifConfigClauseList, 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 unexpectedBeforeName: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var name: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var detail: RawDeclModifierDetailSyntax? { - layoutView.children[3].map(RawDeclModifierDetailSyntax.init(raw:)) - } - public var unexpectedAfterDetail: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawIfConfigClauseSyntax] { + layoutView.children.map { RawIfConfigClauseSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { +public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6564,7 +6601,7 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .inheritedType + return raw.kind == .ifConfigDecl } public var raw: RawSyntax @@ -6579,44 +6616,44 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? = nil, - typeName: RawTypeSyntax, - _ unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeClauses: RawUnexpectedNodesSyntax? = nil, + clauses: RawIfConfigClauseListSyntax, + _ unexpectedBetweenClausesAndPoundEndif: RawUnexpectedNodesSyntax? = nil, + poundEndif: RawTokenSyntax, + _ unexpectedAfterPoundEndif: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .inheritedType, uninitializedCount: 5, arena: arena) { layout in + kind: .ifConfigDecl, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeTypeName?.raw - layout[1] = typeName.raw - layout[2] = unexpectedBetweenTypeNameAndTrailingComma?.raw - layout[3] = trailingComma?.raw - layout[4] = unexpectedAfterTrailingComma?.raw + layout[0] = unexpectedBeforeClauses?.raw + layout[1] = clauses.raw + layout[2] = unexpectedBetweenClausesAndPoundEndif?.raw + layout[3] = poundEndif.raw + layout[4] = unexpectedAfterPoundEndif?.raw } self.init(raw: raw) } - public var unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeClauses: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var typeName: RawTypeSyntax { - layoutView.children[1].map(RawTypeSyntax.init(raw:))! + public var clauses: RawIfConfigClauseListSyntax { + layoutView.children[1].map(RawIfConfigClauseListSyntax.init(raw:))! } - public var unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenClausesAndPoundEndif: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var trailingComma: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var poundEndif: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterPoundEndif: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { +public struct RawPoundErrorDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6624,7 +6661,7 @@ public struct RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .inheritedTypeList + return raw.kind == .poundErrorDecl } public var raw: RawSyntax @@ -6638,25 +6675,65 @@ public struct RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawInheritedTypeSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforePoundError: RawUnexpectedNodesSyntax? = nil, + poundError: RawTokenSyntax, + _ unexpectedBetweenPoundErrorAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? = nil, + message: RawStringLiteralExprSyntax, + _ unexpectedBetweenMessageAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .inheritedTypeList, 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 - } + kind: .poundErrorDecl, uninitializedCount: 9, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforePoundError?.raw + layout[1] = poundError.raw + layout[2] = unexpectedBetweenPoundErrorAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndMessage?.raw + layout[5] = message.raw + layout[6] = unexpectedBetweenMessageAndRightParen?.raw + layout[7] = rightParen.raw + layout[8] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var elements: [RawInheritedTypeSyntax] { - layoutView.children.map { RawInheritedTypeSyntax(raw: $0!) } + public var unexpectedBeforePoundError: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var poundError: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenPoundErrorAndLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var message: RawStringLiteralExprSyntax { + layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))! + } + public var unexpectedBetweenMessageAndRightParen: 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 RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { +public struct RawPoundWarningDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6664,7 +6741,7 @@ public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typeInheritanceClause + return raw.kind == .poundWarningDecl } public var raw: RawSyntax @@ -6679,44 +6756,64 @@ public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax, - _ unexpectedBetweenColonAndInheritedTypeCollection: RawUnexpectedNodesSyntax? = nil, - inheritedTypeCollection: RawInheritedTypeListSyntax, - _ unexpectedAfterInheritedTypeCollection: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforePoundWarning: RawUnexpectedNodesSyntax? = nil, + poundWarning: RawTokenSyntax, + _ unexpectedBetweenPoundWarningAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? = nil, + message: RawStringLiteralExprSyntax, + _ unexpectedBetweenMessageAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeInheritanceClause, uninitializedCount: 5, arena: arena) { layout in + kind: .poundWarningDecl, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeColon?.raw - layout[1] = colon.raw - layout[2] = unexpectedBetweenColonAndInheritedTypeCollection?.raw - layout[3] = inheritedTypeCollection.raw - layout[4] = unexpectedAfterInheritedTypeCollection?.raw + layout[0] = unexpectedBeforePoundWarning?.raw + layout[1] = poundWarning.raw + layout[2] = unexpectedBetweenPoundWarningAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndMessage?.raw + layout[5] = message.raw + layout[6] = unexpectedBetweenMessageAndRightParen?.raw + layout[7] = rightParen.raw + layout[8] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeColon: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePoundWarning: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var colon: RawTokenSyntax { + public var poundWarning: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenColonAndInheritedTypeCollection: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPoundWarningAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var inheritedTypeCollection: RawInheritedTypeListSyntax { - layoutView.children[3].map(RawInheritedTypeListSyntax.init(raw:))! + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterInheritedTypeCollection: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndMessage: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var message: RawStringLiteralExprSyntax { + layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))! + } + public var unexpectedBetweenMessageAndRightParen: 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 RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6724,7 +6821,7 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .classDecl + return raw.kind == .poundSourceLocation } public var raw: RawSyntax @@ -6739,104 +6836,64 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, - modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndClassKeyword: RawUnexpectedNodesSyntax? = nil, - classKeyword: RawTokenSyntax, - _ unexpectedBetweenClassKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, - genericParameterClause: RawGenericParameterClauseSyntax?, - _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, - inheritanceClause: RawTypeInheritanceClauseSyntax?, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, - genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? = nil, - members: RawMemberDeclBlockSyntax, - _ unexpectedAfterMembers: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforePoundSourceLocation: RawUnexpectedNodesSyntax? = nil, + poundSourceLocation: RawTokenSyntax, + _ unexpectedBetweenPoundSourceLocationAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndArgs: RawUnexpectedNodesSyntax? = nil, + args: RawPoundSourceLocationArgsSyntax?, + _ unexpectedBetweenArgsAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .classDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .poundSourceLocation, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAttributes?.raw - layout[1] = attributes?.raw - layout[2] = unexpectedBetweenAttributesAndModifiers?.raw - layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndClassKeyword?.raw - layout[5] = classKeyword.raw - layout[6] = unexpectedBetweenClassKeywordAndIdentifier?.raw - layout[7] = identifier.raw - layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw - layout[9] = genericParameterClause?.raw - layout[10] = unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw - layout[11] = inheritanceClause?.raw - layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw - layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMembers?.raw - layout[15] = members.raw - layout[16] = unexpectedAfterMembers?.raw + layout[0] = unexpectedBeforePoundSourceLocation?.raw + layout[1] = poundSourceLocation.raw + layout[2] = unexpectedBetweenPoundSourceLocationAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndArgs?.raw + layout[5] = args?.raw + layout[6] = unexpectedBetweenArgsAndRightParen?.raw + layout[7] = rightParen.raw + layout[8] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePoundSourceLocation: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var poundSourceLocation: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPoundSourceLocationAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var modifiers: RawModifierListSyntax? { - layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenModifiersAndClassKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArgs: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var classKeyword: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var args: RawPoundSourceLocationArgsSyntax? { + layoutView.children[5].map(RawPoundSourceLocationArgsSyntax.init(raw:)) } - public var unexpectedBetweenClassKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenArgsAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { + public var rightParen: RawTokenSyntax { layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericParameterClause: RawGenericParameterClauseSyntax? { - layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) - } - public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var inheritanceClause: RawTypeInheritanceClauseSyntax? { - layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:)) - } - public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var genericWhereClause: RawGenericWhereClauseSyntax? { - layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) - } - public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var members: RawMemberDeclBlockSyntax { - layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))! - } - public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6844,7 +6901,7 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .actorDecl + return raw.kind == .poundSourceLocationArgs } public var raw: RawSyntax @@ -6859,104 +6916,94 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, - modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndActorKeyword: RawUnexpectedNodesSyntax? = nil, - actorKeyword: RawTokenSyntax, - _ unexpectedBetweenActorKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, - genericParameterClause: RawGenericParameterClauseSyntax?, - _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, - inheritanceClause: RawTypeInheritanceClauseSyntax?, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, - genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? = nil, - members: RawMemberDeclBlockSyntax, - _ unexpectedAfterMembers: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? = nil, + fileArgLabel: RawTokenSyntax, + _ unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? = nil, + fileArgColon: RawTokenSyntax, + _ unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? = nil, + fileName: RawTokenSyntax, + _ unexpectedBetweenFileNameAndComma: RawUnexpectedNodesSyntax? = nil, + comma: RawTokenSyntax, + _ unexpectedBetweenCommaAndLineArgLabel: RawUnexpectedNodesSyntax? = nil, + lineArgLabel: RawTokenSyntax, + _ unexpectedBetweenLineArgLabelAndLineArgColon: RawUnexpectedNodesSyntax? = nil, + lineArgColon: RawTokenSyntax, + _ unexpectedBetweenLineArgColonAndLineNumber: RawUnexpectedNodesSyntax? = nil, + lineNumber: RawTokenSyntax, + _ unexpectedAfterLineNumber: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .actorDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .poundSourceLocationArgs, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAttributes?.raw - layout[1] = attributes?.raw - layout[2] = unexpectedBetweenAttributesAndModifiers?.raw - layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndActorKeyword?.raw - layout[5] = actorKeyword.raw - layout[6] = unexpectedBetweenActorKeywordAndIdentifier?.raw - layout[7] = identifier.raw - layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw - layout[9] = genericParameterClause?.raw - layout[10] = unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw - layout[11] = inheritanceClause?.raw - layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw - layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMembers?.raw - layout[15] = members.raw - layout[16] = unexpectedAfterMembers?.raw + layout[0] = unexpectedBeforeFileArgLabel?.raw + layout[1] = fileArgLabel.raw + layout[2] = unexpectedBetweenFileArgLabelAndFileArgColon?.raw + layout[3] = fileArgColon.raw + layout[4] = unexpectedBetweenFileArgColonAndFileName?.raw + layout[5] = fileName.raw + layout[6] = unexpectedBetweenFileNameAndComma?.raw + layout[7] = comma.raw + layout[8] = unexpectedBetweenCommaAndLineArgLabel?.raw + layout[9] = lineArgLabel.raw + layout[10] = unexpectedBetweenLineArgLabelAndLineArgColon?.raw + layout[11] = lineArgColon.raw + layout[12] = unexpectedBetweenLineArgColonAndLineNumber?.raw + layout[13] = lineNumber.raw + layout[14] = unexpectedAfterLineNumber?.raw } self.init(raw: raw) } - public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var fileArgLabel: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var modifiers: RawModifierListSyntax? { - layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + public var fileArgColon: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenModifiersAndActorKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var actorKeyword: RawTokenSyntax { + public var fileName: RawTokenSyntax { layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenActorKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenFileNameAndComma: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { + public var comma: RawTokenSyntax { layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndLineArgLabel: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericParameterClause: RawGenericParameterClauseSyntax? { - layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) + public var lineArgLabel: RawTokenSyntax { + layoutView.children[9].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLineArgLabelAndLineArgColon: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var inheritanceClause: RawTypeInheritanceClauseSyntax? { - layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:)) + public var lineArgColon: RawTokenSyntax { + layoutView.children[11].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLineArgColonAndLineNumber: RawUnexpectedNodesSyntax? { layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericWhereClause: RawGenericWhereClauseSyntax? { - layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + public var lineNumber: RawTokenSyntax { + layoutView.children[13].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? { + public var unexpectedAfterLineNumber: RawUnexpectedNodesSyntax? { layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var members: RawMemberDeclBlockSyntax { - layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))! - } - public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6964,7 +7011,7 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .structDecl + return raw.kind == .declModifierDetail } public var raw: RawSyntax @@ -6979,104 +7026,114 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, - modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndStructKeyword: RawUnexpectedNodesSyntax? = nil, - structKeyword: RawTokenSyntax, - _ unexpectedBetweenStructKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, - genericParameterClause: RawGenericParameterClauseSyntax?, - _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, - inheritanceClause: RawTypeInheritanceClauseSyntax?, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, - genericWhereClause: RawGenericWhereClauseSyntax?, - _ unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? = nil, - members: RawMemberDeclBlockSyntax, - _ unexpectedAfterMembers: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? = nil, + detail: RawTokenSyntax, + _ unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .structDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .declModifierDetail, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAttributes?.raw - layout[1] = attributes?.raw - layout[2] = unexpectedBetweenAttributesAndModifiers?.raw - layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndStructKeyword?.raw - layout[5] = structKeyword.raw - layout[6] = unexpectedBetweenStructKeywordAndIdentifier?.raw - layout[7] = identifier.raw - layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw - layout[9] = genericParameterClause?.raw - layout[10] = unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw - layout[11] = inheritanceClause?.raw - layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw - layout[13] = genericWhereClause?.raw - layout[14] = unexpectedBetweenGenericWhereClauseAndMembers?.raw - layout[15] = members.raw - layout[16] = unexpectedAfterMembers?.raw + layout[0] = unexpectedBeforeLeftParen?.raw + layout[1] = leftParen.raw + layout[2] = unexpectedBetweenLeftParenAndDetail?.raw + layout[3] = detail.raw + layout[4] = unexpectedBetweenDetailAndRightParen?.raw + layout[5] = rightParen.raw + layout[6] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var leftParen: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var modifiers: RawModifierListSyntax? { - layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + public var detail: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenModifiersAndStructKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var structKeyword: RawTokenSyntax { + public var rightParen: RawTokenSyntax { layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenStructKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! +} + +@_spi(RawSyntax) +public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! } - public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .declModifier } - public var genericParameterClause: RawGenericParameterClauseSyntax? { - layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw } - public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) } - public var inheritanceClause: RawTypeInheritanceClauseSyntax? { - layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:)) + + public init( + _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, + name: RawTokenSyntax, + _ unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? = nil, + detail: RawDeclModifierDetailSyntax?, + _ unexpectedAfterDetail: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .declModifier, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeName?.raw + layout[1] = name.raw + layout[2] = unexpectedBetweenNameAndDetail?.raw + layout[3] = detail?.raw + layout[4] = unexpectedAfterDetail?.raw + } + self.init(raw: raw) } - public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + + public var unexpectedBeforeName: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericWhereClause: RawGenericWhereClauseSyntax? { - layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + public var name: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var members: RawMemberDeclBlockSyntax { - layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))! + public var detail: RawDeclModifierDetailSyntax? { + layoutView.children[3].map(RawDeclModifierDetailSyntax.init(raw:)) } - public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? { - layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedAfterDetail: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -7084,7 +7141,167 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .protocolDecl + return raw.kind == .inheritedType + } + + 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( + _ unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? = nil, + typeName: RawTypeSyntax, + _ unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .inheritedType, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeTypeName?.raw + layout[1] = typeName.raw + layout[2] = unexpectedBetweenTypeNameAndTrailingComma?.raw + layout[3] = trailingComma?.raw + layout[4] = unexpectedAfterTrailingComma?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var typeName: RawTypeSyntax { + layoutView.children[1].map(RawTypeSyntax.init(raw:))! + } + public var unexpectedBetweenTypeNameAndTrailingComma: 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 RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .inheritedTypeList + } + + 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: [RawInheritedTypeSyntax], arena: __shared SyntaxArena) { + let raw = RawSyntax.makeLayout( + kind: .inheritedTypeList, 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: [RawInheritedTypeSyntax] { + layoutView.children.map { RawInheritedTypeSyntax(raw: $0!) } + } +} + +@_spi(RawSyntax) +public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .typeInheritanceClause + } + + 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( + _ unexpectedBeforeColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax, + _ unexpectedBetweenColonAndInheritedTypeCollection: RawUnexpectedNodesSyntax? = nil, + inheritedTypeCollection: RawInheritedTypeListSyntax, + _ unexpectedAfterInheritedTypeCollection: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .typeInheritanceClause, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeColon?.raw + layout[1] = colon.raw + layout[2] = unexpectedBetweenColonAndInheritedTypeCollection?.raw + layout[3] = inheritedTypeCollection.raw + layout[4] = unexpectedAfterInheritedTypeCollection?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeColon: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var colon: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenColonAndInheritedTypeCollection: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var inheritedTypeCollection: RawInheritedTypeListSyntax { + layoutView.children[3].map(RawInheritedTypeListSyntax.init(raw:))! + } + public var unexpectedAfterInheritedTypeCollection: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .classDecl } public var raw: RawSyntax @@ -7103,13 +7320,13 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { attributes: RawAttributeListSyntax?, _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndProtocolKeyword: RawUnexpectedNodesSyntax? = nil, - protocolKeyword: RawTokenSyntax, - _ unexpectedBetweenProtocolKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenModifiersAndClassKeyword: RawUnexpectedNodesSyntax? = nil, + classKeyword: RawTokenSyntax, + _ unexpectedBetweenClassKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: RawUnexpectedNodesSyntax? = nil, - primaryAssociatedTypeClause: RawPrimaryAssociatedTypeClauseSyntax?, - _ unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, + genericParameterClause: RawGenericParameterClauseSyntax?, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, inheritanceClause: RawTypeInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, @@ -7119,19 +7336,19 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .protocolDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .classDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw layout[2] = unexpectedBetweenAttributesAndModifiers?.raw layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndProtocolKeyword?.raw - layout[5] = protocolKeyword.raw - layout[6] = unexpectedBetweenProtocolKeywordAndIdentifier?.raw + layout[4] = unexpectedBetweenModifiersAndClassKeyword?.raw + layout[5] = classKeyword.raw + layout[6] = unexpectedBetweenClassKeywordAndIdentifier?.raw layout[7] = identifier.raw - layout[8] = unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause?.raw - layout[9] = primaryAssociatedTypeClause?.raw - layout[10] = unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause?.raw + layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw + layout[9] = genericParameterClause?.raw + layout[10] = unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw layout[11] = inheritanceClause?.raw layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw layout[13] = genericWhereClause?.raw @@ -7154,25 +7371,25 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { public var modifiers: RawModifierListSyntax? { layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedBetweenModifiersAndProtocolKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndClassKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var protocolKeyword: RawTokenSyntax { + public var classKeyword: RawTokenSyntax { layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenProtocolKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenClassKeywordAndIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } public var identifier: RawTokenSyntax { layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var primaryAssociatedTypeClause: RawPrimaryAssociatedTypeClauseSyntax? { - layoutView.children[9].map(RawPrimaryAssociatedTypeClauseSyntax.init(raw:)) + public var genericParameterClause: RawGenericParameterClauseSyntax? { + layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) } - public var unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } public var inheritanceClause: RawTypeInheritanceClauseSyntax? { @@ -7196,7 +7413,7 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -7204,7 +7421,7 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .extensionDecl + return raw.kind == .actorDecl } public var raw: RawSyntax @@ -7223,11 +7440,13 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { attributes: RawAttributeListSyntax?, _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndExtensionKeyword: RawUnexpectedNodesSyntax? = nil, - extensionKeyword: RawTokenSyntax, - _ unexpectedBetweenExtensionKeywordAndExtendedType: RawUnexpectedNodesSyntax? = nil, - extendedType: RawTypeSyntax, - _ unexpectedBetweenExtendedTypeAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenModifiersAndActorKeyword: RawUnexpectedNodesSyntax? = nil, + actorKeyword: RawTokenSyntax, + _ unexpectedBetweenActorKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, + genericParameterClause: RawGenericParameterClauseSyntax?, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, inheritanceClause: RawTypeInheritanceClauseSyntax?, _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, genericWhereClause: RawGenericWhereClauseSyntax?, @@ -7237,23 +7456,25 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .extensionDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .actorDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw layout[2] = unexpectedBetweenAttributesAndModifiers?.raw layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndExtensionKeyword?.raw - layout[5] = extensionKeyword.raw - layout[6] = unexpectedBetweenExtensionKeywordAndExtendedType?.raw - layout[7] = extendedType.raw - layout[8] = unexpectedBetweenExtendedTypeAndInheritanceClause?.raw - layout[9] = inheritanceClause?.raw - layout[10] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw - layout[11] = genericWhereClause?.raw - layout[12] = unexpectedBetweenGenericWhereClauseAndMembers?.raw - layout[13] = members.raw - layout[14] = unexpectedAfterMembers?.raw + layout[4] = unexpectedBetweenModifiersAndActorKeyword?.raw + layout[5] = actorKeyword.raw + layout[6] = unexpectedBetweenActorKeywordAndIdentifier?.raw + layout[7] = identifier.raw + layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw + layout[9] = genericParameterClause?.raw + layout[10] = unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw + layout[11] = inheritanceClause?.raw + layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw + layout[13] = genericWhereClause?.raw + layout[14] = unexpectedBetweenGenericWhereClauseAndMembers?.raw + layout[15] = members.raw + layout[16] = unexpectedAfterMembers?.raw } self.init(raw: raw) } @@ -7270,43 +7491,49 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { public var modifiers: RawModifierListSyntax? { layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedBetweenModifiersAndExtensionKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndActorKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var extensionKeyword: RawTokenSyntax { + public var actorKeyword: RawTokenSyntax { layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenExtensionKeywordAndExtendedType: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenActorKeywordAndIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var extendedType: RawTypeSyntax { - layoutView.children[7].map(RawTypeSyntax.init(raw:))! + public var identifier: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenExtendedTypeAndInheritanceClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var genericParameterClause: RawGenericParameterClauseSyntax? { + layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) + } + public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } public var inheritanceClause: RawTypeInheritanceClauseSyntax? { - layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw:)) + layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:)) } public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) } public var genericWhereClause: RawGenericWhereClauseSyntax? { - layoutView.children[11].map(RawGenericWhereClauseSyntax.init(raw:)) + layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) } public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) } public var members: RawMemberDeclBlockSyntax { - layoutView.children[13].map(RawMemberDeclBlockSyntax.init(raw:))! + layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))! } public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? { - layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawMemberDeclBlockSyntax: RawSyntaxNodeProtocol { +public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -7314,7 +7541,7 @@ public struct RawMemberDeclBlockSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .memberDeclBlock + return raw.kind == .structDecl } public var raw: RawSyntax @@ -7329,94 +7556,104 @@ public struct RawMemberDeclBlockSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? = nil, - leftBrace: RawTokenSyntax, - _ unexpectedBetweenLeftBraceAndMembers: RawUnexpectedNodesSyntax? = nil, - members: RawMemberDeclListSyntax, - _ unexpectedBetweenMembersAndRightBrace: RawUnexpectedNodesSyntax? = nil, - rightBrace: RawTokenSyntax, - _ unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndStructKeyword: RawUnexpectedNodesSyntax? = nil, + structKeyword: RawTokenSyntax, + _ unexpectedBetweenStructKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? = nil, + genericParameterClause: RawGenericParameterClauseSyntax?, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, + inheritanceClause: RawTypeInheritanceClauseSyntax?, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + genericWhereClause: RawGenericWhereClauseSyntax?, + _ unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? = nil, + members: RawMemberDeclBlockSyntax, + _ unexpectedAfterMembers: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .memberDeclBlock, uninitializedCount: 7, arena: arena) { layout in + kind: .structDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftBrace?.raw - layout[1] = leftBrace.raw - layout[2] = unexpectedBetweenLeftBraceAndMembers?.raw - layout[3] = members.raw - layout[4] = unexpectedBetweenMembersAndRightBrace?.raw - layout[5] = rightBrace.raw - layout[6] = unexpectedAfterRightBrace?.raw + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers?.raw + layout[4] = unexpectedBetweenModifiersAndStructKeyword?.raw + layout[5] = structKeyword.raw + layout[6] = unexpectedBetweenStructKeywordAndIdentifier?.raw + layout[7] = identifier.raw + layout[8] = unexpectedBetweenIdentifierAndGenericParameterClause?.raw + layout[9] = genericParameterClause?.raw + layout[10] = unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw + layout[11] = inheritanceClause?.raw + layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw + layout[13] = genericWhereClause?.raw + layout[14] = unexpectedBetweenGenericWhereClauseAndMembers?.raw + layout[15] = members.raw + layout[16] = unexpectedAfterMembers?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftBrace: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) } - public var unexpectedBetweenLeftBraceAndMembers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var members: RawMemberDeclListSyntax { - layoutView.children[3].map(RawMemberDeclListSyntax.init(raw:))! + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedBetweenMembersAndRightBrace: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndStructKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightBrace: RawTokenSyntax { + public var structKeyword: RawTokenSyntax { layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenStructKeywordAndIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } -} - -@_spi(RawSyntax) -public struct RawMemberDeclListSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! + public var identifier: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .memberDeclList + public var unexpectedBetweenIdentifierAndGenericParameterClause: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw + public var genericParameterClause: RawGenericParameterClauseSyntax? { + layoutView.children[9].map(RawGenericParameterClauseSyntax.init(raw:)) } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) + public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) } - - public init(elements: [RawMemberDeclListItemSyntax], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .memberDeclList, 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 inheritanceClause: RawTypeInheritanceClauseSyntax? { + layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:)) } - - public var elements: [RawMemberDeclListItemSyntax] { - layoutView.children.map { RawMemberDeclListItemSyntax(raw: $0!) } + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var genericWhereClause: RawGenericWhereClauseSyntax? { + layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + } + public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var members: RawMemberDeclBlockSyntax { + layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))! + } + public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? { + layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawMemberDeclListItemSyntax: RawSyntaxNodeProtocol { +public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -7424,7 +7661,7 @@ public struct RawMemberDeclListItemSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .memberDeclListItem + return raw.kind == .protocolDecl } public var raw: RawSyntax @@ -7439,44 +7676,104 @@ public struct RawMemberDeclListItemSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeDecl: RawUnexpectedNodesSyntax? = nil, - decl: RawDeclSyntax, - _ unexpectedBetweenDeclAndSemicolon: RawUnexpectedNodesSyntax? = nil, - semicolon: RawTokenSyntax?, - _ unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndProtocolKeyword: RawUnexpectedNodesSyntax? = nil, + protocolKeyword: RawTokenSyntax, + _ unexpectedBetweenProtocolKeywordAndIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: RawUnexpectedNodesSyntax? = nil, + primaryAssociatedTypeClause: RawPrimaryAssociatedTypeClauseSyntax?, + _ unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, + inheritanceClause: RawTypeInheritanceClauseSyntax?, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + genericWhereClause: RawGenericWhereClauseSyntax?, + _ unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? = nil, + members: RawMemberDeclBlockSyntax, + _ unexpectedAfterMembers: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .memberDeclListItem, uninitializedCount: 5, arena: arena) { layout in + kind: .protocolDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeDecl?.raw - layout[1] = decl.raw - layout[2] = unexpectedBetweenDeclAndSemicolon?.raw - layout[3] = semicolon?.raw - layout[4] = unexpectedAfterSemicolon?.raw + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers?.raw + layout[4] = unexpectedBetweenModifiersAndProtocolKeyword?.raw + layout[5] = protocolKeyword.raw + layout[6] = unexpectedBetweenProtocolKeywordAndIdentifier?.raw + layout[7] = identifier.raw + layout[8] = unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause?.raw + layout[9] = primaryAssociatedTypeClause?.raw + layout[10] = unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause?.raw + layout[11] = inheritanceClause?.raw + layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw + layout[13] = genericWhereClause?.raw + layout[14] = unexpectedBetweenGenericWhereClauseAndMembers?.raw + layout[15] = members.raw + layout[16] = unexpectedAfterMembers?.raw } self.init(raw: raw) } - public var unexpectedBeforeDecl: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var decl: RawDeclSyntax { - layoutView.children[1].map(RawDeclSyntax.init(raw:))! + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) } - public var unexpectedBetweenDeclAndSemicolon: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var semicolon: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndProtocolKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var protocolKeyword: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenProtocolKeywordAndIdentifier: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var identifier: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var primaryAssociatedTypeClause: RawPrimaryAssociatedTypeClauseSyntax? { + layoutView.children[9].map(RawPrimaryAssociatedTypeClauseSyntax.init(raw:)) + } + public var unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var inheritanceClause: RawTypeInheritanceClauseSyntax? { + layoutView.children[11].map(RawTypeInheritanceClauseSyntax.init(raw:)) + } + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var genericWhereClause: RawGenericWhereClauseSyntax? { + layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:)) + } + public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var members: RawMemberDeclBlockSyntax { + layoutView.children[15].map(RawMemberDeclBlockSyntax.init(raw:))! + } + public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? { + layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawSourceFileSyntax: RawSyntaxNodeProtocol { +public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -7484,7 +7781,7 @@ public struct RawSourceFileSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .sourceFile + return raw.kind == .extensionDecl } public var raw: RawSyntax @@ -7499,44 +7796,94 @@ public struct RawSourceFileSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeStatements: RawUnexpectedNodesSyntax? = nil, - statements: RawCodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndEOFToken: RawUnexpectedNodesSyntax? = nil, - eofToken: RawTokenSyntax, - _ unexpectedAfterEOFToken: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndExtensionKeyword: RawUnexpectedNodesSyntax? = nil, + extensionKeyword: RawTokenSyntax, + _ unexpectedBetweenExtensionKeywordAndExtendedType: RawUnexpectedNodesSyntax? = nil, + extendedType: RawTypeSyntax, + _ unexpectedBetweenExtendedTypeAndInheritanceClause: RawUnexpectedNodesSyntax? = nil, + inheritanceClause: RawTypeInheritanceClauseSyntax?, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil, + genericWhereClause: RawGenericWhereClauseSyntax?, + _ unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? = nil, + members: RawMemberDeclBlockSyntax, + _ unexpectedAfterMembers: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .sourceFile, uninitializedCount: 5, arena: arena) { layout in + kind: .extensionDecl, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeStatements?.raw - layout[1] = statements.raw - layout[2] = unexpectedBetweenStatementsAndEOFToken?.raw - layout[3] = eofToken.raw - layout[4] = unexpectedAfterEOFToken?.raw + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers?.raw + layout[4] = unexpectedBetweenModifiersAndExtensionKeyword?.raw + layout[5] = extensionKeyword.raw + layout[6] = unexpectedBetweenExtensionKeywordAndExtendedType?.raw + layout[7] = extendedType.raw + layout[8] = unexpectedBetweenExtendedTypeAndInheritanceClause?.raw + layout[9] = inheritanceClause?.raw + layout[10] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw + layout[11] = genericWhereClause?.raw + layout[12] = unexpectedBetweenGenericWhereClauseAndMembers?.raw + layout[13] = members.raw + layout[14] = unexpectedAfterMembers?.raw } self.init(raw: raw) } - public var unexpectedBeforeStatements: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var statements: RawCodeBlockItemListSyntax { - layoutView.children[1].map(RawCodeBlockItemListSyntax.init(raw:))! + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) } - public var unexpectedBetweenStatementsAndEOFToken: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var eofToken: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedAfterEOFToken: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndExtensionKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var extensionKeyword: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenExtensionKeywordAndExtendedType: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var extendedType: RawTypeSyntax { + layoutView.children[7].map(RawTypeSyntax.init(raw:))! + } + public var unexpectedBetweenExtendedTypeAndInheritanceClause: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var inheritanceClause: RawTypeInheritanceClauseSyntax? { + layoutView.children[9].map(RawTypeInheritanceClauseSyntax.init(raw:)) + } + public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var genericWhereClause: RawGenericWhereClauseSyntax? { + layoutView.children[11].map(RawGenericWhereClauseSyntax.init(raw:)) + } + public var unexpectedBetweenGenericWhereClauseAndMembers: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var members: RawMemberDeclBlockSyntax { + layoutView.children[13].map(RawMemberDeclBlockSyntax.init(raw:))! + } + public var unexpectedAfterMembers: RawUnexpectedNodesSyntax? { + layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawInitializerClauseSyntax: RawSyntaxNodeProtocol { +public struct RawMemberDeclBlockSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -7544,7 +7891,7 @@ public struct RawInitializerClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .initializerClause + return raw.kind == .memberDeclBlock } public var raw: RawSyntax @@ -7559,44 +7906,54 @@ public struct RawInitializerClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeEqual: RawUnexpectedNodesSyntax? = nil, - equal: RawTokenSyntax, - _ unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? = nil, - value: RawExprSyntax, - _ unexpectedAfterValue: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? = nil, + leftBrace: RawTokenSyntax, + _ unexpectedBetweenLeftBraceAndMembers: RawUnexpectedNodesSyntax? = nil, + members: RawMemberDeclListSyntax, + _ unexpectedBetweenMembersAndRightBrace: RawUnexpectedNodesSyntax? = nil, + rightBrace: RawTokenSyntax, + _ unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .initializerClause, uninitializedCount: 5, arena: arena) { layout in + kind: .memberDeclBlock, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeEqual?.raw - layout[1] = equal.raw - layout[2] = unexpectedBetweenEqualAndValue?.raw - layout[3] = value.raw - layout[4] = unexpectedAfterValue?.raw + layout[0] = unexpectedBeforeLeftBrace?.raw + layout[1] = leftBrace.raw + layout[2] = unexpectedBetweenLeftBraceAndMembers?.raw + layout[3] = members.raw + layout[4] = unexpectedBetweenMembersAndRightBrace?.raw + layout[5] = rightBrace.raw + layout[6] = unexpectedAfterRightBrace?.raw } self.init(raw: raw) } - public var unexpectedBeforeEqual: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var equal: RawTokenSyntax { + public var leftBrace: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndMembers: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var value: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! + public var members: RawMemberDeclListSyntax { + layoutView.children[3].map(RawMemberDeclListSyntax.init(raw:))! } - public var unexpectedAfterValue: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenMembersAndRightBrace: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var rightBrace: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { +public struct RawMemberDeclListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -7604,7 +7961,7 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .functionParameter + return raw.kind == .memberDeclList } public var raw: RawSyntax @@ -7618,65 +7975,285 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, - modifiers: RawModifierListSyntax?, - _ unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? = nil, - firstName: RawTokenSyntax?, - _ unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? = nil, - secondName: RawTokenSyntax?, - _ unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax?, - _ unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? = nil, - type: RawTypeSyntax?, - _ unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? = nil, - ellipsis: RawTokenSyntax?, - _ unexpectedBetweenEllipsisAndDefaultArgument: RawUnexpectedNodesSyntax? = nil, - defaultArgument: RawInitializerClauseSyntax?, - _ unexpectedBetweenDefaultArgumentAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawMemberDeclListItemSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .functionParameter, uninitializedCount: 19, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAttributes?.raw - layout[1] = attributes?.raw - layout[2] = unexpectedBetweenAttributesAndModifiers?.raw - layout[3] = modifiers?.raw - layout[4] = unexpectedBetweenModifiersAndFirstName?.raw - layout[5] = firstName?.raw - layout[6] = unexpectedBetweenFirstNameAndSecondName?.raw - layout[7] = secondName?.raw - layout[8] = unexpectedBetweenSecondNameAndColon?.raw - layout[9] = colon?.raw - layout[10] = unexpectedBetweenColonAndType?.raw - layout[11] = type?.raw - layout[12] = unexpectedBetweenTypeAndEllipsis?.raw - layout[13] = ellipsis?.raw - layout[14] = unexpectedBetweenEllipsisAndDefaultArgument?.raw - layout[15] = defaultArgument?.raw - layout[16] = unexpectedBetweenDefaultArgumentAndTrailingComma?.raw - layout[17] = trailingComma?.raw - layout[18] = unexpectedAfterTrailingComma?.raw + kind: .memberDeclList, 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 unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var elements: [RawMemberDeclListItemSyntax] { + layoutView.children.map { RawMemberDeclListItemSyntax(raw: $0!) } } - public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) +} + +@_spi(RawSyntax) +public struct RawMemberDeclListItemSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! } - public var modifiers: RawModifierListSyntax? { - layoutView.children[3].map(RawModifierListSyntax.init(raw:)) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .memberDeclListItem + } + + 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( + _ unexpectedBeforeDecl: RawUnexpectedNodesSyntax? = nil, + decl: RawDeclSyntax, + _ unexpectedBetweenDeclAndSemicolon: RawUnexpectedNodesSyntax? = nil, + semicolon: RawTokenSyntax?, + _ unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .memberDeclListItem, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeDecl?.raw + layout[1] = decl.raw + layout[2] = unexpectedBetweenDeclAndSemicolon?.raw + layout[3] = semicolon?.raw + layout[4] = unexpectedAfterSemicolon?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeDecl: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var decl: RawDeclSyntax { + layoutView.children[1].map(RawDeclSyntax.init(raw:))! + } + public var unexpectedBetweenDeclAndSemicolon: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var semicolon: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedAfterSemicolon: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawSourceFileSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .sourceFile + } + + 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( + _ unexpectedBeforeStatements: RawUnexpectedNodesSyntax? = nil, + statements: RawCodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndEOFToken: RawUnexpectedNodesSyntax? = nil, + eofToken: RawTokenSyntax, + _ unexpectedAfterEOFToken: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .sourceFile, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeStatements?.raw + layout[1] = statements.raw + layout[2] = unexpectedBetweenStatementsAndEOFToken?.raw + layout[3] = eofToken.raw + layout[4] = unexpectedAfterEOFToken?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeStatements: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var statements: RawCodeBlockItemListSyntax { + layoutView.children[1].map(RawCodeBlockItemListSyntax.init(raw:))! + } + public var unexpectedBetweenStatementsAndEOFToken: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var eofToken: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterEOFToken: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawInitializerClauseSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .initializerClause + } + + 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( + _ unexpectedBeforeEqual: RawUnexpectedNodesSyntax? = nil, + equal: RawTokenSyntax, + _ unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? = nil, + value: RawExprSyntax, + _ unexpectedAfterValue: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .initializerClause, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeEqual?.raw + layout[1] = equal.raw + layout[2] = unexpectedBetweenEqualAndValue?.raw + layout[3] = value.raw + layout[4] = unexpectedAfterValue?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeEqual: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var equal: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var value: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! + } + public var unexpectedAfterValue: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .functionParameter + } + + 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( + _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, + attributes: RawAttributeListSyntax?, + _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, + modifiers: RawModifierListSyntax?, + _ unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? = nil, + firstName: RawTokenSyntax?, + _ unexpectedBetweenFirstNameAndSecondName: RawUnexpectedNodesSyntax? = nil, + secondName: RawTokenSyntax?, + _ unexpectedBetweenSecondNameAndColon: RawUnexpectedNodesSyntax? = nil, + colon: RawTokenSyntax?, + _ unexpectedBetweenColonAndType: RawUnexpectedNodesSyntax? = nil, + type: RawTypeSyntax?, + _ unexpectedBetweenTypeAndEllipsis: RawUnexpectedNodesSyntax? = nil, + ellipsis: RawTokenSyntax?, + _ unexpectedBetweenEllipsisAndDefaultArgument: RawUnexpectedNodesSyntax? = nil, + defaultArgument: RawInitializerClauseSyntax?, + _ unexpectedBetweenDefaultArgumentAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .functionParameter, uninitializedCount: 19, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeAttributes?.raw + layout[1] = attributes?.raw + layout[2] = unexpectedBetweenAttributesAndModifiers?.raw + layout[3] = modifiers?.raw + layout[4] = unexpectedBetweenModifiersAndFirstName?.raw + layout[5] = firstName?.raw + layout[6] = unexpectedBetweenFirstNameAndSecondName?.raw + layout[7] = secondName?.raw + layout[8] = unexpectedBetweenSecondNameAndColon?.raw + layout[9] = colon?.raw + layout[10] = unexpectedBetweenColonAndType?.raw + layout[11] = type?.raw + layout[12] = unexpectedBetweenTypeAndEllipsis?.raw + layout[13] = ellipsis?.raw + layout[14] = unexpectedBetweenEllipsisAndDefaultArgument?.raw + layout[15] = defaultArgument?.raw + layout[16] = unexpectedBetweenDefaultArgumentAndTrailingComma?.raw + layout[17] = trailingComma?.raw + layout[18] = unexpectedAfterTrailingComma?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + } + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } public var unexpectedBetweenModifiersAndFirstName: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) @@ -12782,75 +13359,6 @@ public struct RawExpressionStmtSyntax: 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 { @@ -13211,96 +13719,6 @@ public struct RawForInStmtSyntax: RawStmtSyntaxNodeProtocol { } } -@_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 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 RawCatchClauseListSyntax: RawSyntaxNodeProtocol { @@ -13999,382 +14417,22 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { 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 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 RawUnavailabilityConditionSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unavailabilityCondition - } - - 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( - _ unexpectedBeforePoundUnavailableKeyword: RawUnexpectedNodesSyntax? = nil, - poundUnavailableKeyword: RawTokenSyntax, - _ unexpectedBetweenPoundUnavailableKeywordAndLeftParen: 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: .unavailabilityCondition, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundUnavailableKeyword?.raw - layout[1] = poundUnavailableKeyword.raw - layout[2] = unexpectedBetweenPoundUnavailableKeywordAndLeftParen?.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 unexpectedBeforePoundUnavailableKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var poundUnavailableKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenPoundUnavailableKeywordAndLeftParen: 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 RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .hasSymbolCondition - } - - 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( - _ 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: .hasSymbolCondition, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - 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 unexpectedBeforeHasSymbolKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var hasSymbolKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenHasSymbolKeywordAndLeftParen: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftParenAndExpression: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var expression: RawExprSyntax { - layoutView.children[5].map(RawExprSyntax.init(raw:))! - } - 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 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!) } + 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 RawDeclarationStmtSyntax: RawStmtSyntaxNodeProtocol { +public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14382,7 +14440,7 @@ public struct RawDeclarationStmtSyntax: RawStmtSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .declarationStmt + return raw.kind == .matchingPatternCondition } public var raw: RawSyntax @@ -14397,34 +14455,64 @@ public struct RawDeclarationStmtSyntax: RawStmtSyntaxNodeProtocol { } public init( - _ unexpectedBeforeDeclaration: RawUnexpectedNodesSyntax? = nil, - declaration: RawDeclSyntax, - _ unexpectedAfterDeclaration: 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: .declarationStmt, uninitializedCount: 3, arena: arena) { layout in + kind: .matchingPatternCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeDeclaration?.raw - layout[1] = declaration.raw - layout[2] = unexpectedAfterDeclaration?.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 unexpectedBeforeDeclaration: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var declaration: RawDeclSyntax { - layoutView.children[1].map(RawDeclSyntax.init(raw:))! + public var caseKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterDeclaration: RawUnexpectedNodesSyntax? { + 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 RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { +public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14432,7 +14520,7 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .throwStmt + return raw.kind == .optionalBindingCondition } public var raw: RawSyntax @@ -14447,73 +14535,64 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } public init( - _ unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? = nil, - throwKeyword: RawTokenSyntax, - _ unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedAfterExpression: 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: .throwStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .optionalBindingCondition, 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] = 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 unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var throwKeyword: RawTokenSyntax { + public var letOrVarKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLetOrVarKeywordAndPattern: 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 RawUnavailabilityConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14521,7 +14600,7 @@ public struct RawIfStmtSyntax: RawStmtSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifStmt + return raw.kind == .unavailabilityCondition } public var raw: RawSyntax @@ -14536,103 +14615,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, + _ unexpectedBeforePoundUnavailableKeyword: RawUnexpectedNodesSyntax? = nil, + poundUnavailableKeyword: RawTokenSyntax, + _ unexpectedBetweenPoundUnavailableKeywordAndLeftParen: 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: .ifStmt, uninitializedCount: 11, arena: arena) { layout in + kind: .unavailabilityCondition, 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] = unexpectedBeforePoundUnavailableKeyword?.raw + layout[1] = poundUnavailableKeyword.raw + layout[2] = unexpectedBetweenPoundUnavailableKeywordAndLeftParen?.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 unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePoundUnavailableKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var ifKeyword: RawTokenSyntax { + public var poundUnavailableKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPoundUnavailableKeywordAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var conditions: RawConditionElementListSyntax { - layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))! + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var body: RawCodeBlockSyntax { - layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))! + public var availabilitySpec: RawAvailabilitySpecListSyntax { + layoutView.children[5].map(RawAvailabilitySpecListSyntax.init(raw:))! } - public var unexpectedBetweenBodyAndElseKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var elseKeyword: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) + public var rightParen: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenElseKeywordAndElseBody: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: 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 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 struct RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14640,7 +14680,7 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCase + return raw.kind == .hasSymbolCondition } public var raw: RawSyntax @@ -14655,54 +14695,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 { @@ -14710,7 +14760,7 @@ public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchDefaultLabel + return raw.kind == .conditionElementList } public var raw: RawSyntax @@ -14724,45 +14774,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 RawDeclarationStmtSyntax: RawStmtSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14770,7 +14800,7 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .caseItem + return raw.kind == .declarationStmt } public var raw: RawSyntax @@ -14785,54 +14815,34 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforePattern: RawUnexpectedNodesSyntax? = nil, - pattern: RawPatternSyntax, - _ unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? = nil, - whereClause: RawWhereClauseSyntax?, - _ unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDeclaration: RawUnexpectedNodesSyntax? = nil, + declaration: RawDeclSyntax, + _ unexpectedAfterDeclaration: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .caseItem, uninitializedCount: 7, arena: arena) { layout in + kind: .declarationStmt, uninitializedCount: 3, 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] = unexpectedBeforeDeclaration?.raw + layout[1] = declaration.raw + layout[2] = unexpectedAfterDeclaration?.raw } self.init(raw: raw) } - public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeDeclaration: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var pattern: RawPatternSyntax { - layoutView.children[1].map(RawPatternSyntax.init(raw:))! + public var declaration: RawDeclSyntax { + layoutView.children[1].map(RawDeclSyntax.init(raw:))! } - public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? { + public var unexpectedAfterDeclaration: 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 RawCatchItemSyntax: RawSyntaxNodeProtocol { +public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14840,7 +14850,7 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .catchItem + return raw.kind == .throwStmt } public var raw: RawSyntax @@ -14855,54 +14865,44 @@ public struct RawCatchItemSyntax: 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: .catchItem, 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) -public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { +public struct RawCatchItemSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14910,7 +14910,7 @@ public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCaseLabel + return raw.kind == .catchItem } public var raw: RawSyntax @@ -14925,48 +14925,48 @@ public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? = nil, - caseKeyword: RawTokenSyntax, - _ unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? = nil, - caseItems: RawCaseItemListSyntax, - _ unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax, - _ unexpectedAfterColon: RawUnexpectedNodesSyntax? = nil, + _ 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: .switchCaseLabel, uninitializedCount: 7, arena: arena) { layout in + kind: .catchItem, 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 + 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 unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var caseKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var pattern: RawPatternSyntax? { + layoutView.children[1].map(RawPatternSyntax.init(raw:)) } - public var unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var caseItems: RawCaseItemListSyntax { - layoutView.children[3].map(RawCaseItemListSyntax.init(raw:))! + public var whereClause: RawWhereClauseSyntax? { + layoutView.children[3].map(RawWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var colon: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var trailingComma: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift index 954a367ff3e..b29355292ec 100644 --- a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift @@ -408,6 +408,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)) @@ -1880,14 +1960,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 1, verify(layout[1], as: RawExprSyntax.self)) assertNoError(kind, 2, verify(layout[2], 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)) @@ -1944,20 +2016,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)) @@ -2120,54 +2178,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)) @@ -2178,16 +2188,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 dc7dda60e1b..a3204da4247 100644 --- a/Sources/SwiftSyntax/generated/Misc.swift +++ b/Sources/SwiftSyntax/generated/Misc.swift @@ -142,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), @@ -245,7 +245,7 @@ extension Syntax { .node(SwitchCaseListSyntax.self), .node(SwitchCaseSyntax.self), .node(SwitchDefaultLabelSyntax.self), - .node(SwitchStmtSyntax.self), + .node(SwitchExprSyntax.self), .node(SymbolicReferenceExprSyntax.self), .node(TargetFunctionEntrySyntax.self), .node(TernaryExprSyntax.self), @@ -536,8 +536,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: @@ -742,8 +742,8 @@ extension SyntaxKind { return SwitchCaseSyntax.self case .switchDefaultLabel: return SwitchDefaultLabelSyntax.self - case .switchStmt: - return SwitchStmtSyntax.self + case .switchExpr: + return SwitchExprSyntax.self case .symbolicReferenceExpr: return SymbolicReferenceExprSyntax.self case .targetFunctionEntry: @@ -1069,7 +1069,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" @@ -1275,7 +1275,7 @@ extension SyntaxKind { return "switch case" case .switchDefaultLabel: return nil - case .switchStmt: + case .switchExpr: return "'switch' statement" case .symbolicReferenceExpr: return nil diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 0f8a42bf905..6640659c1e5 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -1041,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) } @@ -1865,11 +1865,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 b838352c503..c047633de4f 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, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .symbolicReferenceExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: + case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .symbolicReferenceExpr, .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, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .symbolicReferenceExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: + case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .poundColumnExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .symbolicReferenceExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: break default: fatalError("Unable to create ExprSyntax from \(data.raw.kind)") @@ -282,6 +282,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), @@ -304,6 +305,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { .node(StringLiteralExprSyntax.self), .node(SubscriptExprSyntax.self), .node(SuperRefExprSyntax.self), + .node(SwitchExprSyntax.self), .node(SymbolicReferenceExprSyntax.self), .node(TernaryExprSyntax.self), .node(TryExprSyntax.self), @@ -522,7 +524,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public init? < S: SyntaxProtocol > (_ node: S) { switch node.raw.kind { - case .breakStmt, .continueStmt, .declarationStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .ifStmt, .labeledStmt, .missingStmt, .poundAssertStmt, .repeatWhileStmt, .returnStmt, .switchStmt, .throwStmt, .whileStmt, .yieldStmt: + case .breakStmt, .continueStmt, .declarationStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .poundAssertStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: self._syntaxNode = node._syntaxNode default: return nil @@ -535,7 +537,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { internal init(_ data: SyntaxData) { #if DEBUG switch data.raw.kind { - case .breakStmt, .continueStmt, .declarationStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .ifStmt, .labeledStmt, .missingStmt, .poundAssertStmt, .repeatWhileStmt, .returnStmt, .switchStmt, .throwStmt, .whileStmt, .yieldStmt: + case .breakStmt, .continueStmt, .declarationStmt, .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)") @@ -580,13 +582,11 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { .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 c81fd16fdd2..b30adf31016 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -264,7 +264,7 @@ public enum SyntaxEnum { case ifConfigDecl(IfConfigDeclSyntax) - case ifStmt(IfStmtSyntax) + case ifExpr(IfExprSyntax) case implementsAttributeArguments(ImplementsAttributeArgumentsSyntax) @@ -470,7 +470,7 @@ public enum SyntaxEnum { case switchDefaultLabel(SwitchDefaultLabelSyntax) - case switchStmt(SwitchStmtSyntax) + case switchExpr(SwitchExprSyntax) case symbolicReferenceExpr(SymbolicReferenceExprSyntax) @@ -797,8 +797,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: @@ -1003,8 +1003,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 .symbolicReferenceExpr: return .symbolicReferenceExpr(SymbolicReferenceExprSyntax(self)!) case .targetFunctionEntry: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index f740228a57b..d392a983ae0 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -264,7 +264,7 @@ public enum SyntaxKind { case ifConfigDecl - case ifStmt + case ifExpr case implementsAttributeArguments @@ -470,7 +470,7 @@ public enum SyntaxKind { case switchDefaultLabel - case switchStmt + case switchExpr case symbolicReferenceExpr diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift index 67faf539b47..773f4fa4492 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift @@ -2075,6 +2075,293 @@ extension ExprListSyntax: BidirectionalCollection { } } +/// `SwitchCaseListSyntax` represents a collection of one or more +/// `Syntax` nodes. SwitchCaseListSyntax behaves +/// as a regular Swift collection, and has accessors that return new +/// versions of the collection with different children. +public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum Element: SyntaxChildChoices { + case `switchCase`(SwitchCaseSyntax) + case `ifConfigDecl`(IfConfigDeclSyntax) + public var _syntaxNode: Syntax { + switch self { + case .switchCase(let node): return node._syntaxNode + case .ifConfigDecl(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: SwitchCaseSyntax) { + self = .switchCase(node) + } + public init(_ node: IfConfigDeclSyntax) { + self = .ifConfigDecl(node) + } + public init?(_ node: S) { + if let node = node.as(SwitchCaseSyntax.self) { + self = .switchCase(node) + return + } + if let node = node.as(IfConfigDeclSyntax.self) { + self = .ifConfigDecl(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(SwitchCaseSyntax.self), + .node(IfConfigDeclSyntax.self), + ]) + } + } + + public let _syntaxNode: Syntax + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + data.raw.layoutView! + } + + public init?(_ node: S) { + guard node.raw.kind == .switchCaseList else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a Syntax node from the provided root and data. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .switchCaseList) + self._syntaxNode = Syntax(data) + } + + public init(_ children: [Element]) { + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + from: children.map { $0.raw }, arena: arena) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + /// The number of elements, `present` or `missing`, in this collection. + public var count: Int { return raw.layoutView!.children.count } + + /// Creates a new `SwitchCaseListSyntax` by replacing the underlying layout with + /// a different set of raw syntax nodes. + /// + /// - Parameter layout: The new list of raw syntax nodes underlying this + /// collection. + /// - Returns: A new `SwitchCaseListSyntax` with the new layout underlying it. + internal func replacingLayout( + _ layout: [RawSyntax?]) -> SwitchCaseListSyntax { + let arena = SyntaxArena() + let newRaw = layoutView.replacingLayout(with: layout, arena: arena) + let newData = data.replacingSelf(newRaw, arena: arena) + return SwitchCaseListSyntax(newData) + } + + /// Creates a new `SwitchCaseListSyntax` by appending the provided syntax element + /// to the children. + /// + /// - Parameter syntax: The element to append. + /// - Returns: A new `SwitchCaseListSyntax` with that element appended to the end. + public func appending(_ syntax: Element) -> SwitchCaseListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.append(syntax.raw) + return replacingLayout(newLayout) + } + + /// Creates a new `SwitchCaseListSyntax` by prepending the provided syntax element + /// to the children. + /// + /// - Parameter syntax: The element to prepend. + /// - Returns: A new `SwitchCaseListSyntax` with that element prepended to the + /// beginning. + public func prepending(_ syntax: Element) -> SwitchCaseListSyntax { + return inserting(syntax, at: 0) + } + + /// Creates a new `SwitchCaseListSyntax` by inserting the provided syntax element + /// at the provided index in the children. + /// + /// - Parameters: + /// - syntax: The element to insert. + /// - index: The index at which to insert the element in the collection. + /// + /// - Returns: A new `SwitchCaseListSyntax` with that element appended to the end. + public func inserting(_ syntax: Element, at index: Int) -> SwitchCaseListSyntax { + var newLayout = layoutView.formLayoutArray() + /// Make sure the index is a valid insertion index (0 to 1 past the end) + precondition((newLayout.startIndex...newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") + newLayout.insert(syntax.raw, at: index) + return replacingLayout(newLayout) + } + + /// Creates a new `SwitchCaseListSyntax` by replacing the syntax element + /// at the provided index. + /// + /// - Parameters: + /// - index: The index at which to replace the element in the collection. + /// - syntax: The element to replace with. + /// + /// - Returns: A new `SwitchCaseListSyntax` with the new element at the provided index. + public func replacing(childAt index: Int, with syntax: Element) -> SwitchCaseListSyntax { + var newLayout = layoutView.formLayoutArray() + /// Make sure the index is a valid index for replacing + precondition((newLayout.startIndex.. SwitchCaseListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.remove(at: index) + return replacingLayout(newLayout) + } + + /// Creates a new `SwitchCaseListSyntax` by removing the first element. + /// + /// - Returns: A new `SwitchCaseListSyntax` with the first element removed. + public func removingFirst() -> SwitchCaseListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.removeFirst() + return replacingLayout(newLayout) + } + + /// Creates a new `SwitchCaseListSyntax` by removing the last element. + /// + /// - Returns: A new `SwitchCaseListSyntax` with the last element removed. + public func removingLast() -> SwitchCaseListSyntax { + var newLayout = layoutView.formLayoutArray() + newLayout.removeLast() + return replacingLayout(newLayout) + } + + /// Returns a new `SwitchCaseListSyntax` with its leading trivia replaced + /// by the provided trivia. + public func withLeadingTrivia(_ leadingTrivia: Trivia) -> SwitchCaseListSyntax { + return SwitchCaseListSyntax(data.withLeadingTrivia(leadingTrivia, arena: SyntaxArena())) + } + + /// Returns a new `SwitchCaseListSyntax` with its trailing trivia replaced + /// by the provided trivia. + public func withTrailingTrivia(_ trailingTrivia: Trivia) -> SwitchCaseListSyntax { + return SwitchCaseListSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) + } + + /// Returns a new `SwitchCaseListSyntax` with its leading trivia removed. + public func withoutLeadingTrivia() -> SwitchCaseListSyntax { + return withLeadingTrivia([]) + } + + /// Returns a new `SwitchCaseListSyntax` with its trailing trivia removed. + public func withoutTrailingTrivia() -> SwitchCaseListSyntax { + return withTrailingTrivia([]) + } + + /// Returns a new `SwitchCaseListSyntax` with all trivia removed. + public func withoutTrivia() -> SwitchCaseListSyntax { + return withoutLeadingTrivia().withoutTrailingTrivia() + } + + /// The leading trivia (spaces, newlines, etc.) associated with this `SwitchCaseListSyntax`. + public var leadingTrivia: Trivia? { + get { + return raw.formLeadingTrivia() + } + set { + self = withLeadingTrivia(newValue ?? []) + } + } + + /// The trailing trivia (spaces, newlines, etc.) associated with this `SwitchCaseListSyntax`. + public var trailingTrivia: Trivia? { + get { + return raw.formTrailingTrivia() + } + set { + self = withTrailingTrivia(newValue ?? []) + } + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + return nil + } +} + +/// Conformance for `SwitchCaseListSyntax` to the `BidirectionalCollection` protocol. +extension SwitchCaseListSyntax: BidirectionalCollection { + public typealias Index = SyntaxChildrenIndex + + public struct Iterator: IteratorProtocol { + private let parent: Syntax + private var iterator: RawSyntaxChildren.Iterator + + init(parent: Syntax, rawChildren: RawSyntaxChildren) { + self.parent = parent + self.iterator = rawChildren.makeIterator() + } + + public mutating func next() -> Element? { + guard let (raw, info) = self.iterator.next() else { + return nil + } + let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) + let data = SyntaxData(absoluteRaw, parent: parent) + return Element(data) + } + } + + public func makeIterator() -> Iterator { + return Iterator(parent: Syntax(self), rawChildren: rawChildren) + } + + private var rawChildren: RawSyntaxChildren { + // We know children in a syntax collection cannot be missing. So we can + // use the low-level and faster RawSyntaxChildren collection instead of + // NonNilRawSyntaxChildren. + return RawSyntaxChildren(self.data.absoluteRaw) + } + + public var startIndex: SyntaxChildrenIndex { + return rawChildren.startIndex + } + public var endIndex: SyntaxChildrenIndex { + return rawChildren.endIndex + } + + public func index(after index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { + return rawChildren.index(after: index) + } + + public func index(before index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { + return rawChildren.index(before: index) + } + + public func distance(from start: SyntaxChildrenIndex, to end: SyntaxChildrenIndex) + -> Int { + return rawChildren.distance(from: start, to: end) + } + + public subscript(position: SyntaxChildrenIndex) -> Element { + let (raw, info) = rawChildren[position] + let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) + let data = SyntaxData(absoluteRaw, parent: Syntax(self)) + return Element(data) + } +} + /// `ClosureCaptureItemListSyntax` represents a collection of one or more /// `ClosureCaptureItemSyntax` nodes. ClosureCaptureItemListSyntax behaves /// as a regular Swift collection, and has accessors that return new @@ -7657,275 +7944,23 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable { public func withTrailingTrivia(_ trailingTrivia: Trivia) -> ObjCSelectorSyntax { return ObjCSelectorSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) } - - /// Returns a new `ObjCSelectorSyntax` with its leading trivia removed. - public func withoutLeadingTrivia() -> ObjCSelectorSyntax { - return withLeadingTrivia([]) - } - - /// Returns a new `ObjCSelectorSyntax` with its trailing trivia removed. - public func withoutTrailingTrivia() -> ObjCSelectorSyntax { - return withTrailingTrivia([]) - } - - /// Returns a new `ObjCSelectorSyntax` with all trivia removed. - public func withoutTrivia() -> ObjCSelectorSyntax { - return withoutLeadingTrivia().withoutTrailingTrivia() - } - - /// The leading trivia (spaces, newlines, etc.) associated with this `ObjCSelectorSyntax`. - public var leadingTrivia: Trivia? { - get { - return raw.formLeadingTrivia() - } - set { - self = withLeadingTrivia(newValue ?? []) - } - } - - /// The trailing trivia (spaces, newlines, etc.) associated with this `ObjCSelectorSyntax`. - public var trailingTrivia: Trivia? { - get { - return raw.formTrailingTrivia() - } - set { - self = withTrailingTrivia(newValue ?? []) - } - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - return nil - } -} - -/// Conformance for `ObjCSelectorSyntax` to the `BidirectionalCollection` protocol. -extension ObjCSelectorSyntax: BidirectionalCollection { - public typealias Index = SyntaxChildrenIndex - - public struct Iterator: IteratorProtocol { - private let parent: Syntax - private var iterator: RawSyntaxChildren.Iterator - - init(parent: Syntax, rawChildren: RawSyntaxChildren) { - self.parent = parent - self.iterator = rawChildren.makeIterator() - } - - public mutating func next() -> Element? { - guard let (raw, info) = self.iterator.next() else { - return nil - } - let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) - let data = SyntaxData(absoluteRaw, parent: parent) - return Element(data) - } - } - - public func makeIterator() -> Iterator { - return Iterator(parent: Syntax(self), rawChildren: rawChildren) - } - - private var rawChildren: RawSyntaxChildren { - // We know children in a syntax collection cannot be missing. So we can - // use the low-level and faster RawSyntaxChildren collection instead of - // NonNilRawSyntaxChildren. - return RawSyntaxChildren(self.data.absoluteRaw) - } - - public var startIndex: SyntaxChildrenIndex { - return rawChildren.startIndex - } - public var endIndex: SyntaxChildrenIndex { - return rawChildren.endIndex - } - - public func index(after index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { - return rawChildren.index(after: index) - } - - public func index(before index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { - return rawChildren.index(before: index) - } - - public func distance(from start: SyntaxChildrenIndex, to end: SyntaxChildrenIndex) - -> Int { - return rawChildren.distance(from: start, to: end) - } - - public subscript(position: SyntaxChildrenIndex) -> Element { - let (raw, info) = rawChildren[position] - let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) - let data = SyntaxData(absoluteRaw, parent: Syntax(self)) - return Element(data) - } -} - -/// `DifferentiabilityParamListSyntax` represents a collection of one or more -/// `DifferentiabilityParamSyntax` nodes. DifferentiabilityParamListSyntax behaves -/// as a regular Swift collection, and has accessors that return new -/// versions of the collection with different children. -public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable { - public typealias Element = DifferentiabilityParamSyntax - - public let _syntaxNode: Syntax - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - data.raw.layoutView! - } - - public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParamList else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a Syntax node from the provided root and data. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .differentiabilityParamList) - self._syntaxNode = Syntax(data) - } - - public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, - from: children.map { $0.raw }, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { return raw.layoutView!.children.count } - - /// Creates a new `DifferentiabilityParamListSyntax` by replacing the underlying layout with - /// a different set of raw syntax nodes. - /// - /// - Parameter layout: The new list of raw syntax nodes underlying this - /// collection. - /// - Returns: A new `DifferentiabilityParamListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> DifferentiabilityParamListSyntax { - let arena = SyntaxArena() - let newRaw = layoutView.replacingLayout(with: layout, arena: arena) - let newData = data.replacingSelf(newRaw, arena: arena) - return DifferentiabilityParamListSyntax(newData) - } - - /// Creates a new `DifferentiabilityParamListSyntax` by appending the provided syntax element - /// to the children. - /// - /// - Parameter syntax: The element to append. - /// - Returns: A new `DifferentiabilityParamListSyntax` with that element appended to the end. - public func appending(_ syntax: Element) -> DifferentiabilityParamListSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.append(syntax.raw) - return replacingLayout(newLayout) - } - - /// Creates a new `DifferentiabilityParamListSyntax` by prepending the provided syntax element - /// to the children. - /// - /// - Parameter syntax: The element to prepend. - /// - Returns: A new `DifferentiabilityParamListSyntax` with that element prepended to the - /// beginning. - public func prepending(_ syntax: Element) -> DifferentiabilityParamListSyntax { - return inserting(syntax, at: 0) - } - - /// Creates a new `DifferentiabilityParamListSyntax` by inserting the provided syntax element - /// at the provided index in the children. - /// - /// - Parameters: - /// - syntax: The element to insert. - /// - index: The index at which to insert the element in the collection. - /// - /// - Returns: A new `DifferentiabilityParamListSyntax` with that element appended to the end. - public func inserting(_ syntax: Element, at index: Int) -> DifferentiabilityParamListSyntax { - var newLayout = layoutView.formLayoutArray() - /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex...newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") - newLayout.insert(syntax.raw, at: index) - return replacingLayout(newLayout) - } - - /// Creates a new `DifferentiabilityParamListSyntax` by replacing the syntax element - /// at the provided index. - /// - /// - Parameters: - /// - index: The index at which to replace the element in the collection. - /// - syntax: The element to replace with. - /// - /// - Returns: A new `DifferentiabilityParamListSyntax` with the new element at the provided index. - public func replacing(childAt index: Int, with syntax: Element) -> DifferentiabilityParamListSyntax { - var newLayout = layoutView.formLayoutArray() - /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex.. DifferentiabilityParamListSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.remove(at: index) - return replacingLayout(newLayout) - } - - /// Creates a new `DifferentiabilityParamListSyntax` by removing the first element. - /// - /// - Returns: A new `DifferentiabilityParamListSyntax` with the first element removed. - public func removingFirst() -> DifferentiabilityParamListSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.removeFirst() - return replacingLayout(newLayout) - } - - /// Creates a new `DifferentiabilityParamListSyntax` by removing the last element. - /// - /// - Returns: A new `DifferentiabilityParamListSyntax` with the last element removed. - public func removingLast() -> DifferentiabilityParamListSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.removeLast() - return replacingLayout(newLayout) - } - - /// Returns a new `DifferentiabilityParamListSyntax` with its leading trivia replaced - /// by the provided trivia. - public func withLeadingTrivia(_ leadingTrivia: Trivia) -> DifferentiabilityParamListSyntax { - return DifferentiabilityParamListSyntax(data.withLeadingTrivia(leadingTrivia, arena: SyntaxArena())) - } - - /// Returns a new `DifferentiabilityParamListSyntax` with its trailing trivia replaced - /// by the provided trivia. - public func withTrailingTrivia(_ trailingTrivia: Trivia) -> DifferentiabilityParamListSyntax { - return DifferentiabilityParamListSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) - } - - /// Returns a new `DifferentiabilityParamListSyntax` with its leading trivia removed. - public func withoutLeadingTrivia() -> DifferentiabilityParamListSyntax { + + /// Returns a new `ObjCSelectorSyntax` with its leading trivia removed. + public func withoutLeadingTrivia() -> ObjCSelectorSyntax { return withLeadingTrivia([]) } - /// Returns a new `DifferentiabilityParamListSyntax` with its trailing trivia removed. - public func withoutTrailingTrivia() -> DifferentiabilityParamListSyntax { + /// Returns a new `ObjCSelectorSyntax` with its trailing trivia removed. + public func withoutTrailingTrivia() -> ObjCSelectorSyntax { return withTrailingTrivia([]) } - /// Returns a new `DifferentiabilityParamListSyntax` with all trivia removed. - public func withoutTrivia() -> DifferentiabilityParamListSyntax { + /// Returns a new `ObjCSelectorSyntax` with all trivia removed. + public func withoutTrivia() -> ObjCSelectorSyntax { return withoutLeadingTrivia().withoutTrailingTrivia() } - /// The leading trivia (spaces, newlines, etc.) associated with this `DifferentiabilityParamListSyntax`. + /// The leading trivia (spaces, newlines, etc.) associated with this `ObjCSelectorSyntax`. public var leadingTrivia: Trivia? { get { return raw.formLeadingTrivia() @@ -7935,7 +7970,7 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable } } - /// The trailing trivia (spaces, newlines, etc.) associated with this `DifferentiabilityParamListSyntax`. + /// The trailing trivia (spaces, newlines, etc.) associated with this `ObjCSelectorSyntax`. public var trailingTrivia: Trivia? { get { return raw.formTrailingTrivia() @@ -7950,8 +7985,8 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable } } -/// Conformance for `DifferentiabilityParamListSyntax` to the `BidirectionalCollection` protocol. -extension DifferentiabilityParamListSyntax: BidirectionalCollection { +/// Conformance for `ObjCSelectorSyntax` to the `BidirectionalCollection` protocol. +extension ObjCSelectorSyntax: BidirectionalCollection { public typealias Index = SyntaxChildrenIndex public struct Iterator: IteratorProtocol { @@ -8012,12 +8047,12 @@ extension DifferentiabilityParamListSyntax: BidirectionalCollection { } } -/// `BackDeployVersionListSyntax` represents a collection of one or more -/// `BackDeployVersionArgumentSyntax` nodes. BackDeployVersionListSyntax behaves +/// `DifferentiabilityParamListSyntax` represents a collection of one or more +/// `DifferentiabilityParamSyntax` nodes. DifferentiabilityParamListSyntax behaves /// as a regular Swift collection, and has accessors that return new /// versions of the collection with different children. -public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { - public typealias Element = BackDeployVersionArgumentSyntax +public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable { + public typealias Element = DifferentiabilityParamSyntax public let _syntaxNode: Syntax @@ -8027,7 +8062,7 @@ public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .backDeployVersionList else { return nil } + guard node.raw.kind == .differentiabilityParamList else { return nil } self._syntaxNode = node._syntaxNode } @@ -8035,13 +8070,13 @@ public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .backDeployVersionList) + assert(data.raw.kind == .differentiabilityParamList) self._syntaxNode = Syntax(data) } public init(_ children: [Element]) { let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.backDeployVersionList, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, from: children.map { $0.raw }, arena: arena) return SyntaxData.forRoot(raw) } @@ -8051,50 +8086,50 @@ public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { /// The number of elements, `present` or `missing`, in this collection. public var count: Int { return raw.layoutView!.children.count } - /// Creates a new `BackDeployVersionListSyntax` by replacing the underlying layout with + /// Creates a new `DifferentiabilityParamListSyntax` by replacing the underlying layout with /// a different set of raw syntax nodes. /// /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. - /// - Returns: A new `BackDeployVersionListSyntax` with the new layout underlying it. + /// - Returns: A new `DifferentiabilityParamListSyntax` with the new layout underlying it. internal func replacingLayout( - _ layout: [RawSyntax?]) -> BackDeployVersionListSyntax { + _ layout: [RawSyntax?]) -> DifferentiabilityParamListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) - return BackDeployVersionListSyntax(newData) + return DifferentiabilityParamListSyntax(newData) } - /// Creates a new `BackDeployVersionListSyntax` by appending the provided syntax element + /// Creates a new `DifferentiabilityParamListSyntax` by appending the provided syntax element /// to the children. /// /// - Parameter syntax: The element to append. - /// - Returns: A new `BackDeployVersionListSyntax` with that element appended to the end. - public func appending(_ syntax: Element) -> BackDeployVersionListSyntax { + /// - Returns: A new `DifferentiabilityParamListSyntax` with that element appended to the end. + public func appending(_ syntax: Element) -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.append(syntax.raw) return replacingLayout(newLayout) } - /// Creates a new `BackDeployVersionListSyntax` by prepending the provided syntax element + /// Creates a new `DifferentiabilityParamListSyntax` by prepending the provided syntax element /// to the children. /// /// - Parameter syntax: The element to prepend. - /// - Returns: A new `BackDeployVersionListSyntax` with that element prepended to the + /// - Returns: A new `DifferentiabilityParamListSyntax` with that element prepended to the /// beginning. - public func prepending(_ syntax: Element) -> BackDeployVersionListSyntax { + public func prepending(_ syntax: Element) -> DifferentiabilityParamListSyntax { return inserting(syntax, at: 0) } - /// Creates a new `BackDeployVersionListSyntax` by inserting the provided syntax element + /// Creates a new `DifferentiabilityParamListSyntax` by inserting the provided syntax element /// at the provided index in the children. /// /// - Parameters: /// - syntax: The element to insert. /// - index: The index at which to insert the element in the collection. /// - /// - Returns: A new `BackDeployVersionListSyntax` with that element appended to the end. - public func inserting(_ syntax: Element, at index: Int) -> BackDeployVersionListSyntax { + /// - Returns: A new `DifferentiabilityParamListSyntax` with that element appended to the end. + public func inserting(_ syntax: Element, at index: Int) -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) precondition((newLayout.startIndex...newLayout.endIndex).contains(index), @@ -8103,15 +8138,15 @@ public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { return replacingLayout(newLayout) } - /// Creates a new `BackDeployVersionListSyntax` by replacing the syntax element + /// Creates a new `DifferentiabilityParamListSyntax` by replacing the syntax element /// at the provided index. /// /// - Parameters: /// - index: The index at which to replace the element in the collection. /// - syntax: The element to replace with. /// - /// - Returns: A new `BackDeployVersionListSyntax` with the new element at the provided index. - public func replacing(childAt index: Int, with syntax: Element) -> BackDeployVersionListSyntax { + /// - Returns: A new `DifferentiabilityParamListSyntax` with the new element at the provided index. + public func replacing(childAt index: Int, with syntax: Element) -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing precondition((newLayout.startIndex.. BackDeployVersionListSyntax { + public func removing(childAt index: Int) -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.remove(at: index) return replacingLayout(newLayout) } - /// Creates a new `BackDeployVersionListSyntax` by removing the first element. + /// Creates a new `DifferentiabilityParamListSyntax` by removing the first element. /// - /// - Returns: A new `BackDeployVersionListSyntax` with the first element removed. - public func removingFirst() -> BackDeployVersionListSyntax { + /// - Returns: A new `DifferentiabilityParamListSyntax` with the first element removed. + public func removingFirst() -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.removeFirst() return replacingLayout(newLayout) } - /// Creates a new `BackDeployVersionListSyntax` by removing the last element. + /// Creates a new `DifferentiabilityParamListSyntax` by removing the last element. /// - /// - Returns: A new `BackDeployVersionListSyntax` with the last element removed. - public func removingLast() -> BackDeployVersionListSyntax { + /// - Returns: A new `DifferentiabilityParamListSyntax` with the last element removed. + public func removingLast() -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.removeLast() return replacingLayout(newLayout) } - /// Returns a new `BackDeployVersionListSyntax` with its leading trivia replaced + /// Returns a new `DifferentiabilityParamListSyntax` with its leading trivia replaced /// by the provided trivia. - public func withLeadingTrivia(_ leadingTrivia: Trivia) -> BackDeployVersionListSyntax { - return BackDeployVersionListSyntax(data.withLeadingTrivia(leadingTrivia, arena: SyntaxArena())) + public func withLeadingTrivia(_ leadingTrivia: Trivia) -> DifferentiabilityParamListSyntax { + return DifferentiabilityParamListSyntax(data.withLeadingTrivia(leadingTrivia, arena: SyntaxArena())) } - /// Returns a new `BackDeployVersionListSyntax` with its trailing trivia replaced + /// Returns a new `DifferentiabilityParamListSyntax` with its trailing trivia replaced /// by the provided trivia. - public func withTrailingTrivia(_ trailingTrivia: Trivia) -> BackDeployVersionListSyntax { - return BackDeployVersionListSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) + public func withTrailingTrivia(_ trailingTrivia: Trivia) -> DifferentiabilityParamListSyntax { + return DifferentiabilityParamListSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) } - /// Returns a new `BackDeployVersionListSyntax` with its leading trivia removed. - public func withoutLeadingTrivia() -> BackDeployVersionListSyntax { + /// Returns a new `DifferentiabilityParamListSyntax` with its leading trivia removed. + public func withoutLeadingTrivia() -> DifferentiabilityParamListSyntax { return withLeadingTrivia([]) } - /// Returns a new `BackDeployVersionListSyntax` with its trailing trivia removed. - public func withoutTrailingTrivia() -> BackDeployVersionListSyntax { + /// Returns a new `DifferentiabilityParamListSyntax` with its trailing trivia removed. + public func withoutTrailingTrivia() -> DifferentiabilityParamListSyntax { return withTrailingTrivia([]) } - /// Returns a new `BackDeployVersionListSyntax` with all trivia removed. - public func withoutTrivia() -> BackDeployVersionListSyntax { + /// Returns a new `DifferentiabilityParamListSyntax` with all trivia removed. + public func withoutTrivia() -> DifferentiabilityParamListSyntax { return withoutLeadingTrivia().withoutTrailingTrivia() } - /// The leading trivia (spaces, newlines, etc.) associated with this `BackDeployVersionListSyntax`. + /// The leading trivia (spaces, newlines, etc.) associated with this `DifferentiabilityParamListSyntax`. public var leadingTrivia: Trivia? { get { return raw.formLeadingTrivia() @@ -8187,7 +8222,7 @@ public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { } } - /// The trailing trivia (spaces, newlines, etc.) associated with this `BackDeployVersionListSyntax`. + /// The trailing trivia (spaces, newlines, etc.) associated with this `DifferentiabilityParamListSyntax`. public var trailingTrivia: Trivia? { get { return raw.formTrailingTrivia() @@ -8202,8 +8237,8 @@ public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { } } -/// Conformance for `BackDeployVersionListSyntax` to the `BidirectionalCollection` protocol. -extension BackDeployVersionListSyntax: BidirectionalCollection { +/// Conformance for `DifferentiabilityParamListSyntax` to the `BidirectionalCollection` protocol. +extension DifferentiabilityParamListSyntax: BidirectionalCollection { public typealias Index = SyntaxChildrenIndex public struct Iterator: IteratorProtocol { @@ -8264,47 +8299,12 @@ extension BackDeployVersionListSyntax: BidirectionalCollection { } } -/// `SwitchCaseListSyntax` represents a collection of one or more -/// `Syntax` nodes. SwitchCaseListSyntax behaves +/// `BackDeployVersionListSyntax` represents a collection of one or more +/// `BackDeployVersionArgumentSyntax` nodes. BackDeployVersionListSyntax behaves /// as a regular Swift collection, and has accessors that return new /// versions of the collection with different children. -public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Element: SyntaxChildChoices { - case `switchCase`(SwitchCaseSyntax) - case `ifConfigDecl`(IfConfigDeclSyntax) - public var _syntaxNode: Syntax { - switch self { - case .switchCase(let node): return node._syntaxNode - case .ifConfigDecl(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: SwitchCaseSyntax) { - self = .switchCase(node) - } - public init(_ node: IfConfigDeclSyntax) { - self = .ifConfigDecl(node) - } - public init?(_ node: S) { - if let node = node.as(SwitchCaseSyntax.self) { - self = .switchCase(node) - return - } - if let node = node.as(IfConfigDeclSyntax.self) { - self = .ifConfigDecl(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(SwitchCaseSyntax.self), - .node(IfConfigDeclSyntax.self), - ]) - } - } +public struct BackDeployVersionListSyntax: SyntaxCollection, SyntaxHashable { + public typealias Element = BackDeployVersionArgumentSyntax public let _syntaxNode: Syntax @@ -8314,7 +8314,7 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .switchCaseList else { return nil } + guard node.raw.kind == .backDeployVersionList else { return nil } self._syntaxNode = node._syntaxNode } @@ -8322,13 +8322,13 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .switchCaseList) + assert(data.raw.kind == .backDeployVersionList) self._syntaxNode = Syntax(data) } public init(_ children: [Element]) { let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.backDeployVersionList, from: children.map { $0.raw }, arena: arena) return SyntaxData.forRoot(raw) } @@ -8338,50 +8338,50 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { /// The number of elements, `present` or `missing`, in this collection. public var count: Int { return raw.layoutView!.children.count } - /// Creates a new `SwitchCaseListSyntax` by replacing the underlying layout with + /// Creates a new `BackDeployVersionListSyntax` by replacing the underlying layout with /// a different set of raw syntax nodes. /// /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. - /// - Returns: A new `SwitchCaseListSyntax` with the new layout underlying it. + /// - Returns: A new `BackDeployVersionListSyntax` with the new layout underlying it. internal func replacingLayout( - _ layout: [RawSyntax?]) -> SwitchCaseListSyntax { + _ layout: [RawSyntax?]) -> BackDeployVersionListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) - return SwitchCaseListSyntax(newData) + return BackDeployVersionListSyntax(newData) } - /// Creates a new `SwitchCaseListSyntax` by appending the provided syntax element + /// Creates a new `BackDeployVersionListSyntax` by appending the provided syntax element /// to the children. /// /// - Parameter syntax: The element to append. - /// - Returns: A new `SwitchCaseListSyntax` with that element appended to the end. - public func appending(_ syntax: Element) -> SwitchCaseListSyntax { + /// - Returns: A new `BackDeployVersionListSyntax` with that element appended to the end. + public func appending(_ syntax: Element) -> BackDeployVersionListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.append(syntax.raw) return replacingLayout(newLayout) } - /// Creates a new `SwitchCaseListSyntax` by prepending the provided syntax element + /// Creates a new `BackDeployVersionListSyntax` by prepending the provided syntax element /// to the children. /// /// - Parameter syntax: The element to prepend. - /// - Returns: A new `SwitchCaseListSyntax` with that element prepended to the + /// - Returns: A new `BackDeployVersionListSyntax` with that element prepended to the /// beginning. - public func prepending(_ syntax: Element) -> SwitchCaseListSyntax { + public func prepending(_ syntax: Element) -> BackDeployVersionListSyntax { return inserting(syntax, at: 0) } - /// Creates a new `SwitchCaseListSyntax` by inserting the provided syntax element + /// Creates a new `BackDeployVersionListSyntax` by inserting the provided syntax element /// at the provided index in the children. /// /// - Parameters: /// - syntax: The element to insert. /// - index: The index at which to insert the element in the collection. /// - /// - Returns: A new `SwitchCaseListSyntax` with that element appended to the end. - public func inserting(_ syntax: Element, at index: Int) -> SwitchCaseListSyntax { + /// - Returns: A new `BackDeployVersionListSyntax` with that element appended to the end. + public func inserting(_ syntax: Element, at index: Int) -> BackDeployVersionListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) precondition((newLayout.startIndex...newLayout.endIndex).contains(index), @@ -8390,15 +8390,15 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { return replacingLayout(newLayout) } - /// Creates a new `SwitchCaseListSyntax` by replacing the syntax element + /// Creates a new `BackDeployVersionListSyntax` by replacing the syntax element /// at the provided index. /// /// - Parameters: /// - index: The index at which to replace the element in the collection. /// - syntax: The element to replace with. /// - /// - Returns: A new `SwitchCaseListSyntax` with the new element at the provided index. - public func replacing(childAt index: Int, with syntax: Element) -> SwitchCaseListSyntax { + /// - Returns: A new `BackDeployVersionListSyntax` with the new element at the provided index. + public func replacing(childAt index: Int, with syntax: Element) -> BackDeployVersionListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing precondition((newLayout.startIndex.. SwitchCaseListSyntax { + public func removing(childAt index: Int) -> BackDeployVersionListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.remove(at: index) return replacingLayout(newLayout) } - /// Creates a new `SwitchCaseListSyntax` by removing the first element. + /// Creates a new `BackDeployVersionListSyntax` by removing the first element. /// - /// - Returns: A new `SwitchCaseListSyntax` with the first element removed. - public func removingFirst() -> SwitchCaseListSyntax { + /// - Returns: A new `BackDeployVersionListSyntax` with the first element removed. + public func removingFirst() -> BackDeployVersionListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.removeFirst() return replacingLayout(newLayout) } - /// Creates a new `SwitchCaseListSyntax` by removing the last element. + /// Creates a new `BackDeployVersionListSyntax` by removing the last element. /// - /// - Returns: A new `SwitchCaseListSyntax` with the last element removed. - public func removingLast() -> SwitchCaseListSyntax { + /// - Returns: A new `BackDeployVersionListSyntax` with the last element removed. + public func removingLast() -> BackDeployVersionListSyntax { var newLayout = layoutView.formLayoutArray() newLayout.removeLast() return replacingLayout(newLayout) } - /// Returns a new `SwitchCaseListSyntax` with its leading trivia replaced + /// Returns a new `BackDeployVersionListSyntax` with its leading trivia replaced /// by the provided trivia. - public func withLeadingTrivia(_ leadingTrivia: Trivia) -> SwitchCaseListSyntax { - return SwitchCaseListSyntax(data.withLeadingTrivia(leadingTrivia, arena: SyntaxArena())) + public func withLeadingTrivia(_ leadingTrivia: Trivia) -> BackDeployVersionListSyntax { + return BackDeployVersionListSyntax(data.withLeadingTrivia(leadingTrivia, arena: SyntaxArena())) } - /// Returns a new `SwitchCaseListSyntax` with its trailing trivia replaced + /// Returns a new `BackDeployVersionListSyntax` with its trailing trivia replaced /// by the provided trivia. - public func withTrailingTrivia(_ trailingTrivia: Trivia) -> SwitchCaseListSyntax { - return SwitchCaseListSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) + public func withTrailingTrivia(_ trailingTrivia: Trivia) -> BackDeployVersionListSyntax { + return BackDeployVersionListSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) } - /// Returns a new `SwitchCaseListSyntax` with its leading trivia removed. - public func withoutLeadingTrivia() -> SwitchCaseListSyntax { + /// Returns a new `BackDeployVersionListSyntax` with its leading trivia removed. + public func withoutLeadingTrivia() -> BackDeployVersionListSyntax { return withLeadingTrivia([]) } - /// Returns a new `SwitchCaseListSyntax` with its trailing trivia removed. - public func withoutTrailingTrivia() -> SwitchCaseListSyntax { + /// Returns a new `BackDeployVersionListSyntax` with its trailing trivia removed. + public func withoutTrailingTrivia() -> BackDeployVersionListSyntax { return withTrailingTrivia([]) } - /// Returns a new `SwitchCaseListSyntax` with all trivia removed. - public func withoutTrivia() -> SwitchCaseListSyntax { + /// Returns a new `BackDeployVersionListSyntax` with all trivia removed. + public func withoutTrivia() -> BackDeployVersionListSyntax { return withoutLeadingTrivia().withoutTrailingTrivia() } - /// The leading trivia (spaces, newlines, etc.) associated with this `SwitchCaseListSyntax`. + /// The leading trivia (spaces, newlines, etc.) associated with this `BackDeployVersionListSyntax`. public var leadingTrivia: Trivia? { get { return raw.formLeadingTrivia() @@ -8474,7 +8474,7 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { } } - /// The trailing trivia (spaces, newlines, etc.) associated with this `SwitchCaseListSyntax`. + /// The trailing trivia (spaces, newlines, etc.) associated with this `BackDeployVersionListSyntax`. public var trailingTrivia: Trivia? { get { return raw.formTrailingTrivia() @@ -8489,8 +8489,8 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { } } -/// Conformance for `SwitchCaseListSyntax` to the `BidirectionalCollection` protocol. -extension SwitchCaseListSyntax: BidirectionalCollection { +/// Conformance for `BackDeployVersionListSyntax` to the `BidirectionalCollection` protocol. +extension BackDeployVersionListSyntax: BidirectionalCollection { public typealias Index = SyntaxChildrenIndex public struct Iterator: IteratorProtocol { @@ -11615,6 +11615,11 @@ extension ExprListSyntax: CustomReflectable { return Mirror(self, unlabeledChildren: self.map{ $0 }) } } +extension SwitchCaseListSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, unlabeledChildren: self.map{ $0 }) + } +} extension ClosureCaptureItemListSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, unlabeledChildren: self.map{ $0 }) @@ -11735,11 +11740,6 @@ extension BackDeployVersionListSyntax: CustomReflectable { return Mirror(self, unlabeledChildren: self.map{ $0 }) } } -extension SwitchCaseListSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, unlabeledChildren: self.map{ $0 }) - } -} extension CatchClauseListSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, unlabeledChildren: self.map{ $0 }) diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift index b0ca37890c7..6b49bb62606 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift @@ -1224,6 +1224,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.ifKeyword, 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.switchKeyword, 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.caseKeyword, 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.defaultKeyword, 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?] = [ @@ -5961,26 +6203,6 @@ public enum SyntaxFactory { return ExpressionStmtSyntax(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?] = [ @@ -6153,49 +6375,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.switchKeyword, 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 { @@ -6750,150 +6929,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.ifKeyword, 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.defaultKeyword, 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?] = [ @@ -6929,41 +6964,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.caseKeyword, 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 8f1d45965ad..b589eff4bf9 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 @@ -1276,13 +1325,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 @@ -1311,13 +1353,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 +1479,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 +1486,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 @@ -2378,6 +2378,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) @@ -3728,16 +3798,6 @@ open class SyntaxRewriter { 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 visitImplRepeatWhileStmtSyntax(_ data: SyntaxData) -> Syntax { let node = RepeatWhileStmtSyntax(data) @@ -3778,16 +3838,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) @@ -3968,46 +4018,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) @@ -4018,16 +4028,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) @@ -4696,6 +4696,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: @@ -4966,8 +4980,6 @@ open class SyntaxRewriter { return visitImplDeferStmtSyntax case .expressionStmt: return visitImplExpressionStmtSyntax - case .switchCaseList: - return visitImplSwitchCaseListSyntax case .repeatWhileStmt: return visitImplRepeatWhileStmtSyntax case .guardStmt: @@ -4976,8 +4988,6 @@ open class SyntaxRewriter { return visitImplWhereClauseSyntax case .forInStmt: return visitImplForInStmtSyntax - case .switchStmt: - return visitImplSwitchStmtSyntax case .catchClauseList: return visitImplCatchClauseListSyntax case .doStmt: @@ -5014,18 +5024,8 @@ open class SyntaxRewriter { return visitImplDeclarationStmtSyntax 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: @@ -5235,6 +5235,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: @@ -5505,8 +5519,6 @@ open class SyntaxRewriter { return visitImplDeferStmtSyntax(data) case .expressionStmt: return visitImplExpressionStmtSyntax(data) - case .switchCaseList: - return visitImplSwitchCaseListSyntax(data) case .repeatWhileStmt: return visitImplRepeatWhileStmtSyntax(data) case .guardStmt: @@ -5515,8 +5527,6 @@ open class SyntaxRewriter { return visitImplWhereClauseSyntax(data) case .forInStmt: return visitImplForInStmtSyntax(data) - case .switchStmt: - return visitImplSwitchStmtSyntax(data) case .catchClauseList: return visitImplCatchClauseListSyntax(data) case .doStmt: @@ -5553,18 +5563,8 @@ open class SyntaxRewriter { return visitImplDeclarationStmtSyntax(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/SyntaxTraits.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift index 2df5bdb2186..8deaee05888 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift @@ -188,6 +188,10 @@ extension TupleExprSyntax: ParenthesizedSyntax {} extension TupleExprElementSyntax: WithTrailingCommaSyntax {} extension ArrayElementSyntax: WithTrailingCommaSyntax {} extension DictionaryElementSyntax: WithTrailingCommaSyntax {} +extension IfExprSyntax: WithCodeBlockSyntax {} +extension SwitchExprSyntax: BracedSyntax {} +extension SwitchCaseSyntax: WithStatementsSyntax {} +extension CaseItemSyntax: WithTrailingCommaSyntax {} extension ClosureCaptureItemSyntax: WithTrailingCommaSyntax {} extension ClosureParamSyntax: WithTrailingCommaSyntax {} extension ClosureExprSyntax: BracedSyntax, WithStatementsSyntax {} @@ -225,12 +229,8 @@ extension DeferStmtSyntax: WithCodeBlockSyntax {} extension RepeatWhileStmtSyntax: WithCodeBlockSyntax {} extension GuardStmtSyntax: WithCodeBlockSyntax {} extension ForInStmtSyntax: WithCodeBlockSyntax {} -extension SwitchStmtSyntax: BracedSyntax {} extension DoStmtSyntax: WithCodeBlockSyntax {} extension ConditionElementSyntax: WithTrailingCommaSyntax {} -extension IfStmtSyntax: WithCodeBlockSyntax {} -extension SwitchCaseSyntax: WithStatementsSyntax {} -extension CaseItemSyntax: WithTrailingCommaSyntax {} extension CatchItemSyntax: WithTrailingCommaSyntax {} extension CatchClauseSyntax: WithCodeBlockSyntax {} extension GenericRequirementSyntax: WithTrailingCommaSyntax {} diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift index 23494510852..5f3299c4f5b 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift @@ -195,6 +195,34 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: BooleanLiteralExprSyntax) -> ResultType + /// Visiting `IfExprSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: IfExprSyntax) -> ResultType + /// Visiting `SwitchExprSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: SwitchExprSyntax) -> ResultType + /// Visiting `SwitchCaseListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: SwitchCaseListSyntax) -> ResultType + /// Visiting `SwitchCaseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: SwitchCaseSyntax) -> ResultType + /// Visiting `SwitchCaseLabelSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: SwitchCaseLabelSyntax) -> ResultType + /// Visiting `SwitchDefaultLabelSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType + /// Visiting `CaseItemSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: CaseItemSyntax) -> ResultType /// Visiting `UnresolvedTernaryExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -735,10 +763,6 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ExpressionStmtSyntax) -> ResultType - /// Visiting `SwitchCaseListSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: SwitchCaseListSyntax) -> ResultType /// Visiting `RepeatWhileStmtSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -755,10 +779,6 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ForInStmtSyntax) -> ResultType - /// Visiting `SwitchStmtSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: SwitchStmtSyntax) -> ResultType /// Visiting `CatchClauseListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -831,30 +851,10 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ThrowStmtSyntax) -> ResultType - /// Visiting `IfStmtSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: IfStmtSyntax) -> ResultType - /// Visiting `SwitchCaseSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: SwitchCaseSyntax) -> ResultType - /// Visiting `SwitchDefaultLabelSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType - /// Visiting `CaseItemSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: CaseItemSyntax) -> ResultType /// Visiting `CatchItemSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: CatchItemSyntax) -> ResultType - /// Visiting `SwitchCaseLabelSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: SwitchCaseLabelSyntax) -> ResultType /// Visiting `CatchClauseSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -1342,6 +1342,48 @@ extension SyntaxTransformVisitor { public func visit(_ node: BooleanLiteralExprSyntax) -> ResultType { visitAny(Syntax(node)) } + /// Visiting `IfExprSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: IfExprSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `SwitchExprSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: SwitchExprSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `SwitchCaseListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: SwitchCaseListSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `SwitchCaseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: SwitchCaseSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `SwitchCaseLabelSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: SwitchCaseLabelSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `SwitchDefaultLabelSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `CaseItemSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: CaseItemSyntax) -> ResultType { + visitAny(Syntax(node)) + } /// Visiting `UnresolvedTernaryExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2152,12 +2194,6 @@ extension SyntaxTransformVisitor { public func visit(_ node: ExpressionStmtSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `SwitchCaseListSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: SwitchCaseListSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `RepeatWhileStmtSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2182,12 +2218,6 @@ extension SyntaxTransformVisitor { public func visit(_ node: ForInStmtSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `SwitchStmtSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: SwitchStmtSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `CatchClauseListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2296,42 +2326,12 @@ extension SyntaxTransformVisitor { public func visit(_ node: ThrowStmtSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `IfStmtSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: IfStmtSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `SwitchCaseSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: SwitchCaseSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `SwitchDefaultLabelSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `CaseItemSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: CaseItemSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `CatchItemSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. public func visit(_ node: CatchItemSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `SwitchCaseLabelSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: SwitchCaseLabelSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `CatchClauseSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2749,6 +2749,20 @@ extension SyntaxTransformVisitor { return visit(derived) case .booleanLiteralExpr(let derived): return visit(derived) + case .ifExpr(let derived): + return visit(derived) + case .switchExpr(let derived): + return visit(derived) + case .switchCaseList(let derived): + return visit(derived) + case .switchCase(let derived): + return visit(derived) + case .switchCaseLabel(let derived): + return visit(derived) + case .switchDefaultLabel(let derived): + return visit(derived) + case .caseItem(let derived): + return visit(derived) case .unresolvedTernaryExpr(let derived): return visit(derived) case .ternaryExpr(let derived): @@ -3019,8 +3033,6 @@ extension SyntaxTransformVisitor { return visit(derived) case .expressionStmt(let derived): return visit(derived) - case .switchCaseList(let derived): - return visit(derived) case .repeatWhileStmt(let derived): return visit(derived) case .guardStmt(let derived): @@ -3029,8 +3041,6 @@ extension SyntaxTransformVisitor { return visit(derived) case .forInStmt(let derived): return visit(derived) - case .switchStmt(let derived): - return visit(derived) case .catchClauseList(let derived): return visit(derived) case .doStmt(let derived): @@ -3067,18 +3077,8 @@ extension SyntaxTransformVisitor { return visit(derived) case .throwStmt(let derived): return visit(derived) - case .ifStmt(let derived): - return visit(derived) - case .switchCase(let derived): - return visit(derived) - case .switchDefaultLabel(let derived): - return visit(derived) - case .caseItem(let derived): - return visit(derived) case .catchItem(let derived): return visit(derived) - case .switchCaseLabel(let derived): - return visit(derived) case .catchClause(let derived): return visit(derived) case .poundAssertStmt(let derived): diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift index f48228894e5..a1603f2407c 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift @@ -481,6 +481,76 @@ open class SyntaxVisitor { /// The function called after visiting `BooleanLiteralExprSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: BooleanLiteralExprSyntax) {} + /// Visiting `IfExprSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: IfExprSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `IfExprSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: IfExprSyntax) {} + /// Visiting `SwitchExprSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: SwitchExprSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `SwitchExprSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: SwitchExprSyntax) {} + /// Visiting `SwitchCaseListSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: SwitchCaseListSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `SwitchCaseListSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: SwitchCaseListSyntax) {} + /// Visiting `SwitchCaseSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: SwitchCaseSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `SwitchCaseSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: SwitchCaseSyntax) {} + /// Visiting `SwitchCaseLabelSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: SwitchCaseLabelSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `SwitchCaseLabelSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: SwitchCaseLabelSyntax) {} + /// Visiting `SwitchDefaultLabelSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: SwitchDefaultLabelSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `SwitchDefaultLabelSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: SwitchDefaultLabelSyntax) {} + /// Visiting `CaseItemSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: CaseItemSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `CaseItemSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: CaseItemSyntax) {} /// Visiting `UnresolvedTernaryExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1831,16 +1901,6 @@ open class SyntaxVisitor { /// The function called after visiting `ExpressionStmtSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: ExpressionStmtSyntax) {} - /// Visiting `SwitchCaseListSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: SwitchCaseListSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `SwitchCaseListSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: SwitchCaseListSyntax) {} /// Visiting `RepeatWhileStmtSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1881,16 +1941,6 @@ open class SyntaxVisitor { /// The function called after visiting `ForInStmtSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: ForInStmtSyntax) {} - /// Visiting `SwitchStmtSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: SwitchStmtSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `SwitchStmtSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: SwitchStmtSyntax) {} /// Visiting `CatchClauseListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -2071,46 +2121,6 @@ open class SyntaxVisitor { /// The function called after visiting `ThrowStmtSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: ThrowStmtSyntax) {} - /// Visiting `IfStmtSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: IfStmtSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `IfStmtSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: IfStmtSyntax) {} - /// Visiting `SwitchCaseSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: SwitchCaseSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `SwitchCaseSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: SwitchCaseSyntax) {} - /// Visiting `SwitchDefaultLabelSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: SwitchDefaultLabelSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `SwitchDefaultLabelSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: SwitchDefaultLabelSyntax) {} - /// Visiting `CaseItemSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: CaseItemSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `CaseItemSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: CaseItemSyntax) {} /// Visiting `CatchItemSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -2121,16 +2131,6 @@ open class SyntaxVisitor { /// The function called after visiting `CatchItemSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: CatchItemSyntax) {} - /// Visiting `SwitchCaseLabelSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: SwitchCaseLabelSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `SwitchCaseLabelSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: SwitchCaseLabelSyntax) {} /// Visiting `CatchClauseSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -3167,6 +3167,83 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + 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 { + visitChildren(node) + } + visitPost(node) + } + + /// Implementation detail of doVisit(_:_:). Do not call directly. + 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 { + visitChildren(node) + } + visitPost(node) + } + + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplSwitchCaseListSyntax(_ data: SyntaxData) { + let node = SwitchCaseListSyntax(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 visitImplSwitchCaseSyntax(_ data: SyntaxData) { + let node = SwitchCaseSyntax(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 visitImplSwitchCaseLabelSyntax(_ data: SyntaxData) { + let node = SwitchCaseLabelSyntax(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 visitImplSwitchDefaultLabelSyntax(_ data: SyntaxData) { + let node = SwitchDefaultLabelSyntax(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 visitImplCaseItemSyntax(_ data: SyntaxData) { + let node = CaseItemSyntax(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 visitImplUnresolvedTernaryExprSyntax(_ data: SyntaxData) { let node = UnresolvedTernaryExprSyntax(data) @@ -4652,17 +4729,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplSwitchCaseListSyntax(_ data: SyntaxData) { - let node = SwitchCaseListSyntax(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 visitImplRepeatWhileStmtSyntax(_ data: SyntaxData) { let node = RepeatWhileStmtSyntax(data) @@ -4707,17 +4773,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplSwitchStmtSyntax(_ data: SyntaxData) { - let node = SwitchStmtSyntax(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 visitImplCatchClauseListSyntax(_ data: SyntaxData) { let node = CatchClauseListSyntax(data) @@ -4916,50 +4971,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplIfStmtSyntax(_ data: SyntaxData) { - let node = IfStmtSyntax(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 visitImplSwitchCaseSyntax(_ data: SyntaxData) { - let node = SwitchCaseSyntax(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 visitImplSwitchDefaultLabelSyntax(_ data: SyntaxData) { - let node = SwitchDefaultLabelSyntax(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 visitImplCaseItemSyntax(_ data: SyntaxData) { - let node = CaseItemSyntax(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 visitImplCatchItemSyntax(_ data: SyntaxData) { let node = CatchItemSyntax(data) @@ -4971,17 +4982,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplSwitchCaseLabelSyntax(_ data: SyntaxData) { - let node = SwitchCaseLabelSyntax(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 visitImplCatchClauseSyntax(_ data: SyntaxData) { let node = CatchClauseSyntax(data) @@ -5676,6 +5676,20 @@ open class SyntaxVisitor { visitImplIntegerLiteralExprSyntax(data) case .booleanLiteralExpr: visitImplBooleanLiteralExprSyntax(data) + case .ifExpr: + visitImplIfExprSyntax(data) + case .switchExpr: + visitImplSwitchExprSyntax(data) + case .switchCaseList: + visitImplSwitchCaseListSyntax(data) + case .switchCase: + visitImplSwitchCaseSyntax(data) + case .switchCaseLabel: + visitImplSwitchCaseLabelSyntax(data) + case .switchDefaultLabel: + visitImplSwitchDefaultLabelSyntax(data) + case .caseItem: + visitImplCaseItemSyntax(data) case .unresolvedTernaryExpr: visitImplUnresolvedTernaryExprSyntax(data) case .ternaryExpr: @@ -5946,8 +5960,6 @@ open class SyntaxVisitor { visitImplDeferStmtSyntax(data) case .expressionStmt: visitImplExpressionStmtSyntax(data) - case .switchCaseList: - visitImplSwitchCaseListSyntax(data) case .repeatWhileStmt: visitImplRepeatWhileStmtSyntax(data) case .guardStmt: @@ -5956,8 +5968,6 @@ open class SyntaxVisitor { visitImplWhereClauseSyntax(data) case .forInStmt: visitImplForInStmtSyntax(data) - case .switchStmt: - visitImplSwitchStmtSyntax(data) case .catchClauseList: visitImplCatchClauseListSyntax(data) case .doStmt: @@ -5994,18 +6004,8 @@ open class SyntaxVisitor { visitImplDeclarationStmtSyntax(data) case .throwStmt: visitImplThrowStmtSyntax(data) - case .ifStmt: - visitImplIfStmtSyntax(data) - case .switchCase: - visitImplSwitchCaseSyntax(data) - case .switchDefaultLabel: - visitImplSwitchDefaultLabelSyntax(data) - case .caseItem: - visitImplCaseItemSyntax(data) case .catchItem: visitImplCatchItemSyntax(data) - case .switchCaseLabel: - visitImplSwitchCaseLabelSyntax(data) case .catchClause: 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 19596c82027..0644f3d1106 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift @@ -4224,6 +4224,772 @@ 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 = .ifKeyword(), + _ 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 + ) { + 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.ifKeyword, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.conditionElementList, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlock, arena: arena) + 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 = .switchKeyword(), + _ 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 + ) { + 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.switchKeyword, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.switchCaseList, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) + 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 525da35d731..e24a5f666db 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift @@ -1885,324 +1885,263 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - 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? { @@ -2214,265 +2153,252 @@ 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 = .caseKeyword(), + _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, + caseItems: CaseItemListSyntax, + _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.caseKeyword, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.caseItemList, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) 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, ]) } @@ -2498,174 +2424,173 @@ 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 = .defaultKeyword(), + _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeDefaultKeyword?.raw, + defaultKeyword.raw, + unexpectedBetweenDefaultKeywordAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.defaultKeyword, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) 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, ]) } @@ -2674,7 +2599,7 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: @@ -2687,730 +2612,576 @@ 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 = .inKeyword(), - _ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) 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? { - get { - let childData = data.child(at: 10, parent: Syntax(self)) + 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 + ) { + 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + 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: 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.inKeyword, arena: arena) - 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 struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax + 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 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 - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndClosure?.raw, - closure.raw, - unexpectedAfterClosure?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return MultipleTrailingClosureElementSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) - 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.closureExpr, arena: arena) - 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, ]) } @@ -3419,7 +3190,7 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -3430,132 +3201,258 @@ 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeContent?.raw, - content.raw, - unexpectedAfterContent?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + unexpectedBeforeLeftSquare?.raw, + leftSquare.raw, + unexpectedBetweenLeftSquareAndItems?.raw, + items?.raw, + unexpectedBetweenItemsAndRightSquare?.raw, + rightSquare.raw, + unexpectedAfterRightSquare?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.stringSegment(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) + 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, ]) } @@ -3567,587 +3464,670 @@ 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 = .stringInterpolationAnchorToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.backslash, arena: arena) - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) - 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 = .inKeyword(), + _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.stringInterpolationAnchor, arena: arena) - 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 - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforePeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndComponent?.raw, - component.raw, - unexpectedAfterComponent?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return KeyPathComponentSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) } - public var unexpectedAfterComponent: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsTokAndOutput: 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 = withUnexpectedAfterComponent(value) + self = withUnexpectedBetweenThrowsTokAndOutput(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 `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: 4, with: raw, arena: arena) - return KeyPathComponentSyntax(newData) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.inKeyword, arena: arena) + let newData = data.replacingChild(at: 13, with: raw, arena: arena) + return ClosureSignatureSyntax(newData) + } + + public var unexpectedAfterInTok: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 14, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterInTok(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 { + 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.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, ]) } @@ -4156,233 +4136,261 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.closureExpr, arena: arena) 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, ]) } @@ -4391,7 +4399,7 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: @@ -4408,565 +4416,467 @@ 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBracket?.raw, - leftBracket.raw, - unexpectedBetweenLeftBracketAndArgumentList?.raw, - argumentList.raw, - unexpectedBetweenArgumentListAndRightBracket?.raw, - rightBracket.raw, - unexpectedAfterRightBracket?.raw, + unexpectedBeforeContent?.raw, + content.raw, + unexpectedAfterContent?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.stringSegment(""), arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) - 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 = .stringInterpolationAnchorToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.postfixQuestionMark, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.backslash, arena: arena) 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 struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax + 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 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 - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndComma?.raw, - comma?.raw, - unexpectedAfterComma?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + 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() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return YieldExprListElementSyntax(newData) + 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) } - public var unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? { + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return ExpressionSegmentSyntax(newData) + } + + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.stringInterpolationAnchor, arena: arena) + 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, ]) } @@ -4982,177 +4892,242 @@ 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 - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeInitializerClause, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(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 + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforePeriod?.raw, + period?.raw, + unexpectedBetweenPeriodAndComponent?.raw, + component.raw, + unexpectedAfterComponent?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout( + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.equal, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) 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, ]) } @@ -5165,7 +5140,7 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "type" + return nil case 4: return nil default: @@ -5174,237 +5149,220 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.functionParameterList, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + 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, ]) } @@ -5417,7 +5375,7 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "parameters" + return nil case 4: return nil case 5: @@ -5430,173 +5388,239 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.arrow, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) 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() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) + 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, ]) } @@ -5609,277 +5633,320 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.parameterClause, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.postfixQuestionMark, arena: arena) 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 + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndComma?.raw, + comma?.raw, + unexpectedAfterComma?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + 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 { + /// 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: 4, with: raw, arena: arena) - return FunctionSignatureSyntax(newData) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + 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, ]) } @@ -5895,338 +5962,177 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.poundIfKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.equal, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) 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, ]) } @@ -6239,421 +6145,438 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) 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() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.functionParameterList, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.stringLiteral(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) - 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 + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeArrow?.raw, + arrow.raw, + unexpectedBetweenArrowAndReturnType?.raw, + returnType.raw, + unexpectedAfterReturnType?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.arrow, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.integerLiteral(""), arena: arena) - let newData = data.replacingChild(at: 13, with: raw, arena: arena) - return PoundSourceLocationArgsSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + 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, ]) } @@ -6666,257 +6589,277 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.parameterClause, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + 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, ]) } @@ -6936,180 +6879,334 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 { + /// 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 DeclModifierSyntax(newData) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundIfKeyword, arena: arena) 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, ]) } @@ -7122,386 +7219,421 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.stringLiteral(""), arena: arena) + 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 - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndInheritedTypeCollection?.raw, - inheritedTypeCollection.raw, - unexpectedAfterInheritedTypeCollection?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TypeInheritanceClauseSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.inheritedTypeList, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return TypeInheritanceClauseSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.integerLiteral(""), arena: arena) + 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, ]) } @@ -7517,243 +7649,254 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.memberDeclList, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) 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 { + /// 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, ]) } @@ -7779,180 +7922,174 @@ 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeDecl?.raw, - decl.raw, - unexpectedBetweenDeclAndSemicolon?.raw, - semicolon?.raw, - unexpectedAfterSemicolon?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndDetail?.raw, + detail?.raw, + unexpectedAfterDetail?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingDecl, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) 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, ]) } @@ -7974,190 +8111,172 @@ 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndEOFToken?.raw, - eofToken.raw, - unexpectedAfterEOFToken?.raw, + unexpectedBeforeTypeName?.raw, + typeName.raw, + unexpectedBetweenTypeNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena) - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + 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, ]) } @@ -8179,171 +8298,190 @@ 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, + unexpectedBeforeColon?.raw, + colon.raw, + unexpectedBetweenColonAndInheritedTypeCollection?.raw, + inheritedTypeCollection.raw, + unexpectedAfterInheritedTypeCollection?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.equal, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) 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() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.inheritedTypeList, arena: arena) 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, ]) } @@ -8365,605 +8503,436 @@ 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, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? = nil, + members: MemberDeclListSyntax, + _ unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.memberDeclList, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) 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 + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeDecl?.raw, + decl.raw, + unexpectedBetweenDeclAndSemicolon?.raw, + semicolon?.raw, + unexpectedAfterSemicolon?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingDecl, arena: arena) + 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, ]) } @@ -8972,40 +8941,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") @@ -9013,186 +8954,190 @@ 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: - AccessLevelModifierSyntax +// MARK: - SourceFileSyntax -public struct AccessLevelModifierSyntax: SyntaxProtocol, SyntaxHashable { +public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessLevelModifier else { return nil } + guard node.raw.kind == .sourceFile else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessLevelModifierSyntax` 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 == .accessLevelModifier) + assert(data.raw.kind == .sourceFile) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndModifier: UnexpectedNodesSyntax? = nil, - modifier: DeclModifierDetailSyntax? = nil, - _ unexpectedAfterModifier: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? = nil, + eofToken: TokenSyntax, + _ unexpectedAfterEOFToken: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndModifier?.raw, - modifier?.raw, - unexpectedAfterModifier?.raw, + unexpectedBeforeStatements?.raw, + statements.raw, + unexpectedBetweenStatementsAndEOFToken?.raw, + eofToken.raw, + unexpectedAfterEOFToken?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessLevelModifier, 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?) -> AccessLevelModifierSyntax { + /// 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 AccessLevelModifierSyntax(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?) -> AccessLevelModifierSyntax { + /// 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() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AccessLevelModifierSyntax(newData) + return SourceFileSyntax(newData) } - public var unexpectedBetweenNameAndModifier: 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 = withUnexpectedBetweenNameAndModifier(value) + self = withUnexpectedBetweenStatementsAndEOFToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndModifier` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndModifier` to replace the node's - /// current `unexpectedBetweenNameAndModifier`, if present. - public func withUnexpectedBetweenNameAndModifier(_ newChild: UnexpectedNodesSyntax?) -> AccessLevelModifierSyntax { + /// 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 AccessLevelModifierSyntax(newData) + return SourceFileSyntax(newData) } - public var modifier: DeclModifierDetailSyntax? { + public var eofToken: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return DeclModifierDetailSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withModifier(value) + self = withEOFToken(value) } } - /// Returns a copy of the receiver with its `modifier` replaced. - /// - param newChild: The new `modifier` to replace the node's - /// current `modifier`, if present. - public func withModifier(_ newChild: DeclModifierDetailSyntax?) -> AccessLevelModifierSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AccessLevelModifierSyntax(newData) + return SourceFileSyntax(newData) } - public var unexpectedAfterModifier: 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 = withUnexpectedAfterModifier(value) + self = withUnexpectedAfterEOFToken(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterModifier` replaced. - /// - param newChild: The new `unexpectedAfterModifier` to replace the node's - /// current `unexpectedAfterModifier`, if present. - public func withUnexpectedAfterModifier(_ newChild: UnexpectedNodesSyntax?) -> AccessLevelModifierSyntax { + /// 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 AccessLevelModifierSyntax(newData) + return SourceFileSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndModifier, - \Self.modifier, - \Self.unexpectedAfterModifier, + \Self.unexpectedBeforeStatements, + \Self.statements, + \Self.unexpectedBetweenStatementsAndEOFToken, + \Self.eofToken, + \Self.unexpectedAfterEOFToken, ]) } @@ -9201,7 +9146,7 @@ public struct AccessLevelModifierSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: @@ -9214,172 +9159,171 @@ public struct AccessLevelModifierSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AccessLevelModifierSyntax: 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), - "unexpectedBetweenNameAndModifier": unexpectedBetweenNameAndModifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "modifier": modifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterModifier": unexpectedAfterModifier.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: - AccessPathComponentSyntax +// MARK: - InitializerClauseSyntax -public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { +public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessPathComponent else { return nil } + guard node.raw.kind == .initializerClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessPathComponentSyntax` 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 == .accessPathComponent) + assert(data.raw.kind == .initializerClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? = nil, - trailingDot: TokenSyntax? = nil, - _ unexpectedAfterTrailingDot: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, + equal: TokenSyntax = .equalToken(), + _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, + value: V, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingDot?.raw, - trailingDot?.raw, - unexpectedAfterTrailingDot?.raw, + unexpectedBeforeEqual?.raw, + equal.raw, + unexpectedBetweenEqualAndValue?.raw, + value.raw, + unexpectedAfterValue?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessPathComponent, from: layout, arena: arena, + kind: SyntaxKind.initializerClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: 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 = withUnexpectedBeforeName(value) + self = withUnexpectedBeforeEqual(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 `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 AccessPathComponentSyntax(newData) + return InitializerClauseSyntax(newData) } - public var name: TokenSyntax { + public var equal: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withEqual(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 { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.equal, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AccessPathComponentSyntax(newData) + return InitializerClauseSyntax(newData) } - public var unexpectedBetweenNameAndTrailingDot: 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 = withUnexpectedBetweenNameAndTrailingDot(value) + self = withUnexpectedBetweenEqualAndValue(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 `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 AccessPathComponentSyntax(newData) + return InitializerClauseSyntax(newData) } - public var trailingDot: TokenSyntax? { + public var value: ExprSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withTrailingDot(value) + self = withValue(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 `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 raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AccessPathComponentSyntax(newData) + return InitializerClauseSyntax(newData) } - public var unexpectedAfterTrailingDot: 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 = withUnexpectedAfterTrailingDot(value) + self = withUnexpectedAfterValue(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 `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 AccessPathComponentSyntax(newData) + return InitializerClauseSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndTrailingDot, - \Self.trailingDot, - \Self.unexpectedAfterTrailingDot, + \Self.unexpectedBeforeEqual, + \Self.equal, + \Self.unexpectedBetweenEqualAndValue, + \Self.value, + \Self.unexpectedAfterValue, ]) } @@ -9388,7 +9332,7 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: @@ -9401,476 +9345,605 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AccessPathComponentSyntax: CustomReflectable { +extension InitializerClauseSyntax: 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, + "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: - AccessorParameterSyntax +// MARK: - FunctionParameterSyntax -public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { +public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorParameter else { return nil } + guard node.raw.kind == .functionParameter else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessorParameterSyntax` 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 == .accessorParameter) + assert(data.raw.kind == .functionParameter) 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, + _ 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorParameter, from: layout, arena: arena, + kind: SyntaxKind.functionParameter, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - 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 = withUnexpectedBeforeLeftParen(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AccessorParameterSyntax(newData) - } - - public var leftParen: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - 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?) -> AccessorParameterSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + /// 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 = withUnexpectedBeforeAttributes(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 { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return FunctionParameterSyntax(newData) + } + + public var attributes: AttributeListSyntax? { + get { + let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } + return AttributeListSyntax(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) + } + 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 AccessorParameterSyntax(newData) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenLeftParenAndName: 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 = withUnexpectedBetweenLeftParenAndName(value) + self = withUnexpectedBetweenAttributesAndModifiers(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 `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 AccessorParameterSyntax(newData) + return FunctionParameterSyntax(newData) } - public var name: TokenSyntax { + public var modifiers: ModifierListSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return ModifierListSyntax(childData!) } set(value) { - self = withName(value) + self = withModifiers(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 { + /// Adds the provided `Modifier` to the node's `modifiers` + /// collection. + /// - param element: The new `Modifier` to add to the node's + /// `modifiers` collection. + /// - returns: A copy of the receiver with the provided `Modifier` + /// appended to its `modifiers` collection. + public func addModifier(_ element: DeclModifierSyntax) -> FunctionParameterSyntax { + var collection: RawSyntax let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return FunctionParameterSyntax(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 { + let arena = SyntaxArena() + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AccessorParameterSyntax(newData) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenNameAndRightParen: 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 = withUnexpectedBetweenNameAndRightParen(value) + self = withUnexpectedBetweenModifiersAndFirstName(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 `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 AccessorParameterSyntax(newData) + return FunctionParameterSyntax(newData) } - public var rightParen: 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 = withRightParen(value) + self = withFirstName(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 { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AccessorParameterSyntax(newData) + return FunctionParameterSyntax(newData) } - public var unexpectedAfterRightParen: 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 = withUnexpectedAfterRightParen(value) + self = withUnexpectedBetweenFirstNameAndSecondName(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 { + /// 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 AccessorParameterSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndName, - \Self.name, - \Self.unexpectedBetweenNameAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, - ]) + return FunctionParameterSyntax(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 "name" - case 4: - return nil - case 5: - return nil - case 6: - return nil - default: - fatalError("Invalid index") + 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) } } -} -extension AccessorParameterSyntax: 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, - ]) + /// 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) } -} - -// MARK: - AccessorBlockSyntax -public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .accessorBlock else { return nil } - self._syntaxNode = node._syntaxNode + 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) + } } - /// 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 == .accessorBlock) - self._syntaxNode = Syntax(data) + /// 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) } - 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, - trailingTrivia: Trivia? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndAccessors?.raw, - accessors.raw, - unexpectedBetweenAccessorsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorBlock, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) + 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) } - self.init(data) } - public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { + /// 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) + } + + public var unexpectedBetweenColonAndType: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftBrace(value) + self = withUnexpectedBetweenColonAndType(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 `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: 0, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var leftBrace: TokenSyntax { + public var type: TypeSyntax? { get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 11, parent: Syntax(self)) + if childData == nil { return nil } + return TypeSyntax(childData!) } set(value) { - self = withLeftBrace(value) + self = withType(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 { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 11, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 12, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftBraceAndAccessors(value) + self = withUnexpectedBetweenTypeAndEllipsis(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 `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: 2, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + let newData = data.replacingChild(at: 12, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var accessors: AccessorListSyntax { + public var ellipsis: TokenSyntax? { get { - let childData = data.child(at: 3, parent: Syntax(self)) - return AccessorListSyntax(childData!) + let childData = data.child(at: 13, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withAccessors(value) - } - } - - /// 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) + self = withEllipsis(value) } - 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 { + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.accessorList, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 13, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenEllipsisAndDefaultArgument: 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 = withUnexpectedBetweenAccessorsAndRightBrace(value) + self = withUnexpectedBetweenEllipsisAndDefaultArgument(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 `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: 4, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + let newData = data.replacingChild(at: 14, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var rightBrace: TokenSyntax { + public var defaultArgument: InitializerClauseSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 15, parent: Syntax(self)) + if childData == nil { return nil } + return InitializerClauseSyntax(childData!) } set(value) { - self = withRightBrace(value) + self = withDefaultArgument(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 15, with: raw, arena: arena) + return FunctionParameterSyntax(newData) } - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 16, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightBrace(value) + self = withUnexpectedBetweenDefaultArgumentAndTrailingComma(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 `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: 6, with: raw, arena: arena) - return AccessorBlockSyntax(newData) + let newData = data.replacingChild(at: 16, with: raw, arena: arena) + 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 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) + } + + 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, ]) } @@ -9879,371 +9952,414 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "attributes" case 2: return nil case 3: - return nil + 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: + return nil default: fatalError("Invalid index") } } } -extension AccessorBlockSyntax: CustomReflectable { +extension FunctionParameterSyntax: 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, + "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: - 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), - ]) - } - } +// MARK: - AccessLevelModifierSyntax +public struct AccessLevelModifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .patternBinding else { return nil } + guard node.raw.kind == .accessLevelModifier else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PatternBindingSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AccessLevelModifierSyntax` 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) + assert(data.raw.kind == .accessLevelModifier) self._syntaxNode = Syntax(data) } - public init( + 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, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndModifier: UnexpectedNodesSyntax? = nil, + modifier: DeclModifierDetailSyntax? = nil, + _ unexpectedAfterModifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndModifier?.raw, + modifier?.raw, + unexpectedAfterModifier?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.patternBinding, from: layout, arena: arena, + kind: SyntaxKind.accessLevelModifier, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePattern: 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 = withUnexpectedBeforePattern(value) + self = withUnexpectedBeforeName(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 `unexpectedBeforeName` replaced. + /// - param newChild: The new `unexpectedBeforeName` to replace the node's + /// current `unexpectedBeforeName`, if present. + public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> AccessLevelModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PatternBindingSyntax(newData) + return AccessLevelModifierSyntax(newData) } - public var pattern: PatternSyntax { + public var name: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return PatternSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withPattern(value) + self = withName(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 `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax?) -> AccessLevelModifierSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PatternBindingSyntax(newData) + return AccessLevelModifierSyntax(newData) } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndModifier: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPatternAndTypeAnnotation(value) + self = withUnexpectedBetweenNameAndModifier(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 `unexpectedBetweenNameAndModifier` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndModifier` to replace the node's + /// current `unexpectedBetweenNameAndModifier`, if present. + public func withUnexpectedBetweenNameAndModifier(_ newChild: UnexpectedNodesSyntax?) -> AccessLevelModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PatternBindingSyntax(newData) + return AccessLevelModifierSyntax(newData) } - public var typeAnnotation: TypeAnnotationSyntax? { + public var modifier: DeclModifierDetailSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return TypeAnnotationSyntax(childData!) + return DeclModifierDetailSyntax(childData!) } set(value) { - self = withTypeAnnotation(value) + self = withModifier(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 `modifier` replaced. + /// - param newChild: The new `modifier` to replace the node's + /// current `modifier`, if present. + public func withModifier(_ newChild: DeclModifierDetailSyntax?) -> AccessLevelModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PatternBindingSyntax(newData) + return AccessLevelModifierSyntax(newData) } - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + public var unexpectedAfterModifier: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenTypeAnnotationAndInitializer(value) + self = withUnexpectedAfterModifier(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 `unexpectedAfterModifier` replaced. + /// - param newChild: The new `unexpectedAfterModifier` to replace the node's + /// current `unexpectedAfterModifier`, if present. + public func withUnexpectedAfterModifier(_ newChild: UnexpectedNodesSyntax?) -> AccessLevelModifierSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PatternBindingSyntax(newData) + return AccessLevelModifierSyntax(newData) } - public var initializer: InitializerClauseSyntax? { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return InitializerClauseSyntax(childData!) - } - set(value) { - self = withInitializer(value) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndModifier, + \Self.modifier, + \Self.unexpectedAfterModifier, + ]) + } + + 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") } } +} - /// 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 newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PatternBindingSyntax(newData) +extension AccessLevelModifierSyntax: 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), + "unexpectedBetweenNameAndModifier": unexpectedBetweenNameAndModifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "modifier": modifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterModifier": unexpectedAfterModifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) } +} - public var unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? { +// MARK: - AccessPathComponentSyntax + +public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .accessPathComponent else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// 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 == .accessPathComponent) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? = nil, + trailingDot: TokenSyntax? = nil, + _ unexpectedAfterTrailingDot: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndTrailingDot?.raw, + trailingDot?.raw, + unexpectedAfterTrailingDot?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.accessPathComponent, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeName: 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 = withUnexpectedBetweenInitializerAndAccessor(value) + self = withUnexpectedBeforeName(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 { + /// 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: 6, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return AccessPathComponentSyntax(newData) } - public var accessor: Accessor? { + public var name: TokenSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return Accessor(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + return TokenSyntax(childData!) } set(value) { - self = withAccessor(value) + self = withName(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 `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: 7, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return AccessPathComponentSyntax(newData) } - public var unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingDot: 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 = withUnexpectedBetweenAccessorAndTrailingComma(value) + self = withUnexpectedBetweenNameAndTrailingDot(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 `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: 8, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return AccessPathComponentSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var trailingDot: TokenSyntax? { get { - let childData = data.child(at: 9, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withTrailingDot(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 { + /// 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: 9, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return AccessPathComponentSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingDot: 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 = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedAfterTrailingDot(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 { + /// 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: 10, with: raw, arena: arena) - return PatternBindingSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return AccessPathComponentSyntax(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.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndTrailingDot, + \Self.trailingDot, + \Self.unexpectedAfterTrailingDot, ]) } @@ -10252,24 +10368,12 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "name" case 2: return nil case 3: - 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: + case 4: return nil default: fatalError("Invalid index") @@ -10277,287 +10381,218 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { } } -extension PatternBindingSyntax: CustomReflectable { +extension AccessPathComponentSyntax: 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, - "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: - EnumCaseElementSyntax +// MARK: - AccessorParameterSyntax -/// -/// 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 AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumCaseElement else { return nil } + guard node.raw.kind == .accessorParameter else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `EnumCaseElementSyntax` 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 == .enumCaseElement) + assert(data.raw.kind == .accessorParameter) 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, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndAssociatedValue?.raw, - associatedValue?.raw, - unexpectedBetweenAssociatedValueAndRawValue?.raw, - rawValue?.raw, - unexpectedBetweenRawValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndName?.raw, + name.raw, + unexpectedBetweenNameAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseElement, from: layout, arena: arena, + kind: SyntaxKind.accessorParameter, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeIdentifier: 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 = withUnexpectedBeforeIdentifier(value) + self = withUnexpectedBeforeLeftParen(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 `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 EnumCaseElementSyntax(newData) + return AccessorParameterSyntax(newData) } - /// The name of this case. - public var identifier: TokenSyntax { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withIdentifier(value) + self = withLeftParen(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + return AccessorParameterSyntax(newData) } - public var unexpectedBetweenIdentifierAndAssociatedValue: 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 = withUnexpectedBetweenIdentifierAndAssociatedValue(value) + self = withUnexpectedBetweenLeftParenAndName(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 `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 EnumCaseElementSyntax(newData) + return AccessorParameterSyntax(newData) } - /// The set of associated values of the case. - public var associatedValue: ParameterClauseSyntax? { + public var name: 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 = withName(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 `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax?) -> AccessorParameterSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + return AccessorParameterSyntax(newData) } - public var unexpectedBetweenAssociatedValueAndRawValue: 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 = withUnexpectedBetweenAssociatedValueAndRawValue(value) + self = withUnexpectedBetweenNameAndRightParen(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 { + /// 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 EnumCaseElementSyntax(newData) + return AccessorParameterSyntax(newData) } - /// - /// The raw value of this enum element, if present. - /// - public var rawValue: InitializerClauseSyntax? { + public var rightParen: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return InitializerClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withRawValue(value) + self = withRightParen(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 { + /// 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 raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return EnumCaseElementSyntax(newData) + return AccessorParameterSyntax(newData) } - public var unexpectedBetweenRawValueAndTrailingComma: 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 = withUnexpectedBetweenRawValueAndTrailingComma(value) + self = withUnexpectedAfterRightParen(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 { + /// 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 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) + return AccessorParameterSyntax(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.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndName, + \Self.name, + \Self.unexpectedBetweenNameAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -10570,192 +10605,252 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "associated values" + return "name" 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 EnumCaseElementSyntax: CustomReflectable { +extension AccessorParameterSyntax: 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, - ]) - } -} - -// MARK: - DesignatedTypeElementSyntax + "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, + ]) + } +} -public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { +// MARK: - AccessorBlockSyntax + +public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .designatedTypeElement else { return nil } + guard node.raw.kind == .accessorBlock else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DesignatedTypeElementSyntax` 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 == .designatedTypeElement) + assert(data.raw.kind == .accessorBlock) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, - leadingComma: TokenSyntax = .commaToken(), - _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedAfterName: 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeadingComma?.raw, - leadingComma.raw, - unexpectedBetweenLeadingCommaAndName?.raw, - name.raw, - unexpectedAfterName?.raw, + unexpectedBeforeLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndAccessors?.raw, + accessors.raw, + unexpectedBetweenAccessorsAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.designatedTypeElement, from: layout, arena: arena, + kind: SyntaxKind.accessorBlock, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeadingComma: 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 = withUnexpectedBeforeLeadingComma(value) + self = withUnexpectedBeforeLeftBrace(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 `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 DesignatedTypeElementSyntax(newData) + return AccessorBlockSyntax(newData) } - public var leadingComma: TokenSyntax { + public var leftBrace: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeadingComma(value) + self = withLeftBrace(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DesignatedTypeElementSyntax(newData) + return AccessorBlockSyntax(newData) } - public var unexpectedBetweenLeadingCommaAndName: 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 = withUnexpectedBetweenLeadingCommaAndName(value) + self = withUnexpectedBetweenLeftBraceAndAccessors(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 `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 DesignatedTypeElementSyntax(newData) + return AccessorBlockSyntax(newData) } - public var name: TokenSyntax { + public var accessors: AccessorListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + return AccessorListSyntax(childData!) } set(value) { - self = withName(value) + self = withAccessors(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?) -> DesignatedTypeElementSyntax { + /// 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() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.accessorList, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DesignatedTypeElementSyntax(newData) + return AccessorBlockSyntax(newData) } - public var unexpectedAfterName: 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 = withUnexpectedAfterName(value) + self = withUnexpectedBetweenAccessorsAndRightBrace(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 `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 DesignatedTypeElementSyntax(newData) + return AccessorBlockSyntax(newData) + } + + public var rightBrace: TokenSyntax { + get { + let childData = data.child(at: 5, 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?) -> AccessorBlockSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return AccessorBlockSyntax(newData) + } + + 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 = 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?) -> AccessorBlockSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return AccessorBlockSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeadingComma, - \Self.leadingComma, - \Self.unexpectedBetweenLeadingCommaAndName, - \Self.name, - \Self.unexpectedAfterName, + \Self.unexpectedBeforeLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndAccessors, + \Self.accessors, + \Self.unexpectedBetweenAccessorsAndRightBrace, + \Self.rightBrace, + \Self.unexpectedAfterRightBrace, ]) } @@ -10771,521 +10866,678 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension DesignatedTypeElementSyntax: CustomReflectable { +extension AccessorBlockSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeadingComma": unexpectedBeforeLeadingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leadingComma": Syntax(leadingComma).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeadingCommaAndName": unexpectedBetweenLeadingCommaAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedAfterName": unexpectedAfterName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - OperatorPrecedenceAndTypesSyntax +// 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), + ]) + } + } -/// -/// A clause to specify precedence group in infix operator declarations, and designated types in any operator declaration. -/// -public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .operatorPrecedenceAndTypes else { return nil } + guard node.raw.kind == .patternBinding else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OperatorPrecedenceAndTypesSyntax` 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 == .operatorPrecedenceAndTypes) + assert(data.raw.kind == .patternBinding) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, - precedenceGroup: TokenSyntax, - _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, - designatedTypes: DesignatedTypeListSyntax, - _ unexpectedAfterDesignatedTypes: 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndPrecedenceGroup?.raw, - precedenceGroup.raw, - unexpectedBetweenPrecedenceGroupAndDesignatedTypes?.raw, - designatedTypes.raw, - unexpectedAfterDesignatedTypes?.raw, + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer?.raw, + unexpectedBetweenInitializerAndAccessor?.raw, + accessor?.raw, + unexpectedBetweenAccessorAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.operatorPrecedenceAndTypes, from: layout, arena: arena, + kind: SyntaxKind.patternBinding, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeColon: 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 = withUnexpectedBeforeColon(value) + self = withUnexpectedBeforePattern(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 `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 OperatorPrecedenceAndTypesSyntax(newData) + return PatternBindingSyntax(newData) } - public var colon: TokenSyntax { + public var pattern: PatternSyntax { get { let childData = data.child(at: 1, 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?) -> OperatorPrecedenceAndTypesSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return PatternBindingSyntax(newData) } - public var unexpectedBetweenColonAndPrecedenceGroup: 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 = withUnexpectedBetweenColonAndPrecedenceGroup(value) + self = withUnexpectedBetweenPatternAndTypeAnnotation(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 `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 OperatorPrecedenceAndTypesSyntax(newData) + return PatternBindingSyntax(newData) } - /// - /// The precedence group for this operator - /// - public var precedenceGroup: 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 = withPrecedenceGroup(value) + self = withTypeAnnotation(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 { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return PatternBindingSyntax(newData) } - public var unexpectedBetweenPrecedenceGroupAndDesignatedTypes: 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 = withUnexpectedBetweenPrecedenceGroupAndDesignatedTypes(value) + self = withUnexpectedBetweenTypeAnnotationAndInitializer(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 `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 OperatorPrecedenceAndTypesSyntax(newData) + return PatternBindingSyntax(newData) } - /// - /// The designated types associated with this operator. - /// - public var designatedTypes: DesignatedTypeListSyntax { + public var initializer: InitializerClauseSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return DesignatedTypeListSyntax(childData!) + if childData == nil { return nil } + return InitializerClauseSyntax(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 = withInitializer(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 `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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.designatedTypeList, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) + return PatternBindingSyntax(newData) } - public var unexpectedAfterDesignatedTypes: 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 = withUnexpectedAfterDesignatedTypes(value) + self = withUnexpectedBetweenInitializerAndAccessor(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 { + /// 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 OperatorPrecedenceAndTypesSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeColon, - \Self.colon, - \Self.unexpectedBetweenColonAndPrecedenceGroup, - \Self.precedenceGroup, - \Self.unexpectedBetweenPrecedenceGroupAndDesignatedTypes, - \Self.designatedTypes, - \Self.unexpectedAfterDesignatedTypes, - ]) + return PatternBindingSyntax(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 "precedence group" - case 4: - return nil - case 5: - return nil - case 6: - return nil - default: - fatalError("Invalid index") + 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) } } -} -extension OperatorPrecedenceAndTypesSyntax: 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, - ]) + /// 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) } -} -// MARK: - PrecedenceGroupRelationSyntax + 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.unexpectedBeforePattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedBetweenInitializerAndAccessor, + \Self.accessor, + \Self.unexpectedBetweenAccessorAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, + ]) + } + + 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 "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 PatternBindingSyntax: 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, + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + +// MARK: - EnumCaseElementSyntax /// -/// Specify the new precedence group's relation to existing precedence -/// groups. -/// -public struct PrecedenceGroupRelationSyntax: 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 == .precedenceGroupRelation else { return nil } + guard node.raw.kind == .enumCaseElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupRelationSyntax` 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 == .precedenceGroupRelation) + assert(data.raw.kind == .enumCaseElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? = nil, - higherThanOrLowerThan: TokenSyntax, - _ unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? = nil, - otherNames: PrecedenceGroupNameListSyntax, - _ unexpectedAfterOtherNames: 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeHigherThanOrLowerThan?.raw, - higherThanOrLowerThan.raw, - unexpectedBetweenHigherThanOrLowerThanAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndOtherNames?.raw, - otherNames.raw, - unexpectedAfterOtherNames?.raw, + unexpectedBeforeIdentifier?.raw, + identifier.raw, + unexpectedBetweenIdentifierAndAssociatedValue?.raw, + associatedValue?.raw, + unexpectedBetweenAssociatedValueAndRawValue?.raw, + rawValue?.raw, + unexpectedBetweenRawValueAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupRelation, from: layout, arena: arena, + kind: SyntaxKind.enumCaseElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeHigherThanOrLowerThan: 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 = withUnexpectedBeforeHigherThanOrLowerThan(value) + self = withUnexpectedBeforeIdentifier(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 `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 PrecedenceGroupRelationSyntax(newData) + return EnumCaseElementSyntax(newData) } - /// - /// The relation to specified other precedence groups. - /// - public var higherThanOrLowerThan: 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 = withHigherThanOrLowerThan(value) + self = withIdentifier(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return EnumCaseElementSyntax(newData) } - public var unexpectedBetweenHigherThanOrLowerThanAndColon: 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 = withUnexpectedBetweenHigherThanOrLowerThanAndColon(value) + self = withUnexpectedBetweenIdentifierAndAssociatedValue(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 `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 PrecedenceGroupRelationSyntax(newData) + return EnumCaseElementSyntax(newData) } - public var colon: TokenSyntax { + /// The set of associated values of the case. + public var associatedValue: ParameterClauseSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return ParameterClauseSyntax(childData!) } set(value) { - self = withColon(value) + self = withAssociatedValue(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + return EnumCaseElementSyntax(newData) } - public var unexpectedBetweenColonAndOtherNames: 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 = withUnexpectedBetweenColonAndOtherNames(value) + self = withUnexpectedBetweenAssociatedValueAndRawValue(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 `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 PrecedenceGroupRelationSyntax(newData) + return EnumCaseElementSyntax(newData) } /// - /// The name of other precedence group to which this precedence - /// group relates. + /// The raw value of this enum element, if present. /// - public var otherNames: PrecedenceGroupNameListSyntax { + public var rawValue: 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) + self = withRawValue(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 + /// 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() - 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 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) } - 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 `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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.precedenceGroupNameList, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return EnumCaseElementSyntax(newData) } - public var unexpectedAfterOtherNames: UnexpectedNodesSyntax? { + /// + /// The trailing comma of this element, if the case has + /// multiple elements. + /// + public var trailingComma: TokenSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + 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 = withUnexpectedAfterOtherNames(value) + self = withUnexpectedAfterTrailingComma(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 `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: 6, with: raw, arena: arena) - return PrecedenceGroupRelationSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return EnumCaseElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeHigherThanOrLowerThan, - \Self.higherThanOrLowerThan, - \Self.unexpectedBetweenHigherThanOrLowerThanAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndOtherNames, - \Self.otherNames, - \Self.unexpectedAfterOtherNames, + \Self.unexpectedBeforeIdentifier, + \Self.identifier, + \Self.unexpectedBetweenIdentifierAndAssociatedValue, + \Self.associatedValue, + \Self.unexpectedBetweenAssociatedValueAndRawValue, + \Self.rawValue, + \Self.unexpectedBetweenRawValueAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -11298,187 +11550,192 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { 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 PrecedenceGroupRelationSyntax: CustomReflectable { +extension EnumCaseElementSyntax: 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, + "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: - PrecedenceGroupNameElementSyntax +// MARK: - DesignatedTypeElementSyntax -public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { +public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupNameElement else { return nil } + guard node.raw.kind == .designatedTypeElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupNameElementSyntax` 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 == .precedenceGroupNameElement) + assert(data.raw.kind == .designatedTypeElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, + leadingComma: TokenSyntax = .commaToken(), + _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, + unexpectedBeforeLeadingComma?.raw, + leadingComma.raw, + unexpectedBetweenLeadingCommaAndName?.raw, name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedAfterName?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupNameElement, from: layout, arena: arena, + kind: SyntaxKind.designatedTypeElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: 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 = withUnexpectedBeforeName(value) + self = withUnexpectedBeforeLeadingComma(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 `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 PrecedenceGroupNameElementSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var name: TokenSyntax { + public var leadingComma: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withLeadingComma(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupNameElementSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var unexpectedBetweenNameAndTrailingComma: 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 = withUnexpectedBetweenNameAndTrailingComma(value) + self = withUnexpectedBetweenLeadingCommaAndName(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 `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 PrecedenceGroupNameElementSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var name: 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 = withName(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 `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 raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupNameElementSyntax(newData) + return DesignatedTypeElementSyntax(newData) } - public var unexpectedAfterTrailingComma: 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 = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedAfterName(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 `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 PrecedenceGroupNameElementSyntax(newData) + return DesignatedTypeElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, + \Self.unexpectedBeforeLeadingComma, + \Self.leadingComma, + \Self.unexpectedBetweenLeadingCommaAndName, \Self.name, - \Self.unexpectedBetweenNameAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedAfterName, ]) } @@ -11487,7 +11744,7 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: @@ -11500,1425 +11757,708 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { } } -extension PrecedenceGroupNameElementSyntax: CustomReflectable { +extension DesignatedTypeElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeName": unexpectedBeforeName.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), - "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, + "unexpectedAfterName": unexpectedAfterName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - PrecedenceGroupAssignmentSyntax +// MARK: - OperatorPrecedenceAndTypesSyntax /// -/// Specifies the precedence of an operator when used in an operation -/// that includes optional chaining. +/// A clause to specify precedence group in infix operator declarations, and designated types in any operator declaration. /// -public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { +public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssignment else { return nil } + guard node.raw.kind == .operatorPrecedenceAndTypes else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupAssignmentSyntax` 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 == .precedenceGroupAssignment) + assert(data.raw.kind == .operatorPrecedenceAndTypes) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? = nil, - assignmentKeyword: TokenSyntax = .identifier("assignment"), - _ unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, - flag: TokenSyntax, - _ unexpectedAfterFlag: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, + precedenceGroup: TokenSyntax, + _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, + designatedTypes: DesignatedTypeListSyntax, + _ unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeAssignmentKeyword?.raw, - assignmentKeyword.raw, - unexpectedBetweenAssignmentKeywordAndColon?.raw, + unexpectedBeforeColon?.raw, colon.raw, - unexpectedBetweenColonAndFlag?.raw, - flag.raw, - unexpectedAfterFlag?.raw, + unexpectedBetweenColonAndPrecedenceGroup?.raw, + precedenceGroup.raw, + unexpectedBetweenPrecedenceGroupAndDesignatedTypes?.raw, + designatedTypes.raw, + unexpectedAfterDesignatedTypes?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssignment, from: layout, arena: arena, + kind: SyntaxKind.operatorPrecedenceAndTypes, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAssignmentKeyword: 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 = withUnexpectedBeforeAssignmentKeyword(value) + self = withUnexpectedBeforeColon(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 `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 PrecedenceGroupAssignmentSyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var assignmentKeyword: TokenSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withAssignmentKeyword(value) + self = withColon(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var unexpectedBetweenAssignmentKeywordAndColon: 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 = withUnexpectedBetweenAssignmentKeywordAndColon(value) + self = withUnexpectedBetweenColonAndPrecedenceGroup(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 `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 PrecedenceGroupAssignmentSyntax(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?) -> PrecedenceGroupAssignmentSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupAssignmentSyntax(newData) + return OperatorPrecedenceAndTypesSyntax(newData) } - public var unexpectedBetweenColonAndFlag: 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 = withUnexpectedBetweenColonAndFlag(value) + self = withUnexpectedBetweenPrecedenceGroupAndDesignatedTypes(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 `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 PrecedenceGroupAssignmentSyntax(newData) + return OperatorPrecedenceAndTypesSyntax(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. + /// The designated types associated with this operator. /// - public var flag: TokenSyntax { + public var designatedTypes: DesignatedTypeListSyntax { 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.trueKeyword, arena: arena) - 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!) + return DesignatedTypeListSyntax(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) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeAssignmentKeyword, - \Self.assignmentKeyword, - \Self.unexpectedBetweenAssignmentKeywordAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndFlag, - \Self.flag, - \Self.unexpectedAfterFlag, - ]) - } - - 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 PrecedenceGroupAssignmentSyntax: 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, - ]) - } -} - -// MARK: - PrecedenceGroupAssociativitySyntax - -/// -/// Specifies how a sequence of operators with the same precedence level -/// are grouped together in the absence of grouping parentheses. -/// -public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssociativity else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// 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 == .precedenceGroupAssociativity) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? = nil, - associativityKeyword: TokenSyntax = .identifier("associativity"), - _ unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeAssociativityKeyword?.raw, - associativityKeyword.raw, - unexpectedBetweenAssociativityKeywordAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssociativity, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) + self = withDesignatedTypes(value) } - self.init(data) } - 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 = withUnexpectedBeforeAssociativityKeyword(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) - } - - public var associativityKeyword: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withAssociativityKeyword(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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) - } - - 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 = withUnexpectedBetweenAssociativityKeywordAndColon(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(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?) -> PrecedenceGroupAssociativitySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(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?) -> PrecedenceGroupAssociativitySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(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 - /// - 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?) -> PrecedenceGroupAssociativitySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) - } - - 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 = withUnexpectedAfterValue(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return PrecedenceGroupAssociativitySyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeAssociativityKeyword, - \Self.associativityKeyword, - \Self.unexpectedBetweenAssociativityKeywordAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedAfterValue, - ]) - } - - 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 PrecedenceGroupAssociativitySyntax: 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, - "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, - ]) - } -} - -// MARK: - CustomAttributeSyntax - -/// -/// A custom `@` attribute. -/// -public struct CustomAttributeSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .customAttribute else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `CustomAttributeSyntax` 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 == .customAttribute) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, - atSignToken: TokenSyntax = .atSignToken(), - _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, - attributeName: A, - _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax? = nil, - _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeAtSignToken?.raw, - atSignToken.raw, - unexpectedBetweenAtSignTokenAndAttributeName?.raw, - attributeName.raw, - unexpectedBetweenAttributeNameAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArgumentList?.raw, - argumentList?.raw, - unexpectedBetweenArgumentListAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.customAttribute, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - 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 = withUnexpectedBeforeAtSignToken(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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - /// The `@` sign. - public var atSignToken: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withAtSignToken(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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.atSign, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - 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 = withUnexpectedBetweenAtSignTokenAndAttributeName(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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return CustomAttributeSyntax(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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return CustomAttributeSyntax(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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - public var leftParen: TokenSyntax? { - 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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - public var unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLeftParenAndArgumentList(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndArgumentList` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndArgumentList` to replace the node's - /// current `unexpectedBetweenLeftParenAndArgumentList`, if present. - public func withUnexpectedBetweenLeftParenAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - public var argumentList: TupleExprElementListSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TupleExprElementListSyntax(childData!) - } - set(value) { - self = withArgumentList(value) - } - } - - /// 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) -> CustomAttributeSyntax { - 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 CustomAttributeSyntax(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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - public var unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenArgumentListAndRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenArgumentListAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenArgumentListAndRightParen` to replace the node's - /// current `unexpectedBetweenArgumentListAndRightParen`, if present. - public func withUnexpectedBetweenArgumentListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - 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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return CustomAttributeSyntax(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?) -> CustomAttributeSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return CustomAttributeSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeAtSignToken, - \Self.atSignToken, - \Self.unexpectedBetweenAtSignTokenAndAttributeName, - \Self.attributeName, - \Self.unexpectedBetweenAttributeNameAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndArgumentList, - \Self.argumentList, - \Self.unexpectedBetweenArgumentListAndRightParen, - \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 - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension CustomAttributeSyntax: 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, - "unexpectedBetweenLeftParenAndArgumentList": unexpectedBetweenLeftParenAndArgumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "argumentList": argumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenArgumentListAndRightParen": unexpectedBetweenArgumentListAndRightParen.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: - AttributeSyntax - -/// -/// An `@` attribute. -/// -public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { - public enum Argument: SyntaxChildChoices { - case `token`(TokenSyntax) - case `stringExpr`(StringLiteralExprSyntax) - case `availability`(AvailabilitySpecListSyntax) - case `specializeArguments`(SpecializeAttributeSpecListSyntax) - case `objCName`(ObjCSelectorSyntax) - case `implementsArguments`(ImplementsAttributeArgumentsSyntax) - case `differentiableArguments`(DifferentiableAttributeArgumentsSyntax) - case `derivativeRegistrationArguments`(DerivativeRegistrationAttributeArgumentsSyntax) - case `namedAttributeString`(NamedAttributeStringArgumentSyntax) - case `backDeployArguments`(BackDeployAttributeSpecListSyntax) - case `conventionArguments`(ConventionAttributeArgumentsSyntax) - case `conventionWitnessMethodArguments`(ConventionWitnessMethodAttributeArgumentsSyntax) - case `opaqueReturnTypeOfAttributeArguments`(OpaqueReturnTypeOfAttributeArgumentsSyntax) - case `tokenList`(TokenListSyntax) - public var _syntaxNode: Syntax { - switch self { - case .token(let node): return node._syntaxNode - case .stringExpr(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 .namedAttributeString(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 .tokenList(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: TokenSyntax) { - self = .token(node) - } - public init(_ node: StringLiteralExprSyntax) { - self = .stringExpr(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: NamedAttributeStringArgumentSyntax) { - self = .namedAttributeString(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: TokenListSyntax) { - self = .tokenList(node) - } - public init?(_ node: S) { - if let node = node.as(TokenSyntax.self) { - self = .token(node) - return - } - if let node = node.as(StringLiteralExprSyntax.self) { - self = .stringExpr(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(NamedAttributeStringArgumentSyntax.self) { - self = .namedAttributeString(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(TokenListSyntax.self) { - self = .tokenList(node) - return - } - return nil + /// 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) + } - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(TokenSyntax.self), - .node(StringLiteralExprSyntax.self), - .node(AvailabilitySpecListSyntax.self), - .node(SpecializeAttributeSpecListSyntax.self), - .node(ObjCSelectorSyntax.self), - .node(ImplementsAttributeArgumentsSyntax.self), - .node(DifferentiableAttributeArgumentsSyntax.self), - .node(DerivativeRegistrationAttributeArgumentsSyntax.self), - .node(NamedAttributeStringArgumentSyntax.self), - .node(BackDeployAttributeSpecListSyntax.self), - .node(ConventionAttributeArgumentsSyntax.self), - .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), - .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), - .node(TokenListSyntax.self), - ]) + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.designatedTypeList, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return OperatorPrecedenceAndTypesSyntax(newData) + } + + 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 = withUnexpectedAfterDesignatedTypes(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 + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return OperatorPrecedenceAndTypesSyntax(newData) + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeColon, + \Self.colon, + \Self.unexpectedBetweenColonAndPrecedenceGroup, + \Self.precedenceGroup, + \Self.unexpectedBetweenPrecedenceGroupAndDesignatedTypes, + \Self.designatedTypes, + \Self.unexpectedAfterDesignatedTypes, + ]) + } + + 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 "precedence group" + case 4: + return nil + case 5: + return nil + case 6: + return nil + default: + fatalError("Invalid index") } } +} + +extension OperatorPrecedenceAndTypesSyntax: 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, + ]) + } +} + +// MARK: - PrecedenceGroupRelationSyntax +/// +/// 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 == .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( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, - atSignToken: TokenSyntax = .atSignToken(), - _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, - attributeName: TokenSyntax, - _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, - argument: Argument? = nil, - _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedBetweenRightParenAndTokenList: UnexpectedNodesSyntax? = nil, - tokenList: TokenListSyntax? = nil, - _ unexpectedAfterTokenList: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? = nil, + higherThanOrLowerThan: TokenSyntax, + _ unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? = nil, + otherNames: PrecedenceGroupNameListSyntax, + _ unexpectedAfterOtherNames: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeAtSignToken?.raw, - atSignToken.raw, - unexpectedBetweenAtSignTokenAndAttributeName?.raw, - attributeName.raw, - unexpectedBetweenAttributeNameAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArgument?.raw, - argument?.raw, - unexpectedBetweenArgumentAndRightParen?.raw, - rightParen?.raw, - unexpectedBetweenRightParenAndTokenList?.raw, - tokenList?.raw, - unexpectedAfterTokenList?.raw, + unexpectedBeforeHigherThanOrLowerThan?.raw, + higherThanOrLowerThan.raw, + unexpectedBetweenHigherThanOrLowerThanAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndOtherNames?.raw, + otherNames.raw, + unexpectedAfterOtherNames?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.atSign, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) 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: TokenSyntax { + public var colon: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) 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: TokenSyntax?) -> 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) 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!) + return PrecedenceGroupNameListSyntax(childData!) } set(value) { - self = withLeftParen(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) } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return PrecedenceGroupRelationSyntax(newData) } - /// 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 { + /// 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 raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.precedenceGroupNameList, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AttributeSyntax(newData) + return PrecedenceGroupRelationSyntax(newData) } - public var unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? { + public var unexpectedAfterOtherNames: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndArgument(value) + self = withUnexpectedAfterOtherNames(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 { + /// 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: 6, with: raw, arena: arena) - return AttributeSyntax(newData) + return PrecedenceGroupRelationSyntax(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) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeHigherThanOrLowerThan, + \Self.higherThanOrLowerThan, + \Self.unexpectedBetweenHigherThanOrLowerThanAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndOtherNames, + \Self.otherNames, + \Self.unexpectedAfterOtherNames, + ]) + } + + 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 `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) +extension PrecedenceGroupRelationSyntax: 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, + ]) } +} - public var unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? { +// MARK: - PrecedenceGroupNameElementSyntax + +public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .precedenceGroupNameElement else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// 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 == .precedenceGroupNameElement) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.precedenceGroupNameElement, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeName: 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 = withUnexpectedBetweenArgumentAndRightParen(value) + self = withUnexpectedBeforeName(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 { + /// 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: 8, with: raw, arena: arena) - return AttributeSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(newData) } - /// - /// If the attribute takes arguments, the closing parenthesis. - /// - public var rightParen: TokenSyntax? { + public var name: 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 = withRightParen(value) + self = withName(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 { + /// 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: 9, with: raw, arena: arena) - return AttributeSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(newData) } - public var unexpectedBetweenRightParenAndTokenList: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingComma: 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 = withUnexpectedBetweenRightParenAndTokenList(value) + self = withUnexpectedBetweenNameAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenRightParenAndTokenList` replaced. - /// - param newChild: The new `unexpectedBetweenRightParenAndTokenList` to replace the node's - /// current `unexpectedBetweenRightParenAndTokenList`, if present. - public func withUnexpectedBetweenRightParenAndTokenList(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + /// 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: 10, with: raw, arena: arena) - return AttributeSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(newData) } - public var tokenList: TokenListSyntax? { + public var trailingComma: TokenSyntax? { get { - let childData = data.child(at: 11, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return TokenListSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withTokenList(value) - } - } - - /// Adds the provided `Token` to the node's `tokenList` - /// collection. - /// - param element: The new `Token` to add to the node's - /// `tokenList` collection. - /// - returns: A copy of the receiver with the provided `Token` - /// appended to its `tokenList` collection. - public func addToken(_ element: TokenSyntax) -> AttributeSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[11] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tokenList, - from: [element.raw], arena: arena) + self = withTrailingComma(value) } - let newData = data.replacingChild(at: 11, with: collection, arena: arena) - return AttributeSyntax(newData) } - /// Returns a copy of the receiver with its `tokenList` replaced. - /// - param newChild: The new `tokenList` to replace the node's - /// current `tokenList`, if present. - public func withTokenList(_ newChild: TokenListSyntax?) -> AttributeSyntax { + /// 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: 11, with: raw, arena: arena) - return AttributeSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(newData) } - public var unexpectedAfterTokenList: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: 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 = withUnexpectedAfterTokenList(value) + self = withUnexpectedAfterTrailingComma(value) } - } - - /// Returns a copy of the receiver with its `unexpectedAfterTokenList` replaced. - /// - param newChild: The new `unexpectedAfterTokenList` to replace the node's - /// current `unexpectedAfterTokenList`, if present. - public func withUnexpectedAfterTokenList(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + } + + /// 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: 12, with: raw, arena: arena) - return AttributeSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return PrecedenceGroupNameElementSyntax(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.unexpectedBetweenRightParenAndTokenList, - \Self.tokenList, - \Self.unexpectedAfterTokenList, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -12927,28 +12467,12 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "name" case 2: return nil case 3: - 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 - case 11: - return nil - case 12: + case 4: return nil default: fatalError("Invalid index") @@ -12956,144 +12480,131 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AttributeSyntax: CustomReflectable { +extension PrecedenceGroupNameElementSyntax: 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, - "unexpectedBetweenRightParenAndTokenList": unexpectedBetweenRightParenAndTokenList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "tokenList": tokenList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterTokenList": unexpectedAfterTokenList.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: - AvailabilityEntrySyntax +// MARK: - PrecedenceGroupAssignmentSyntax /// -/// The availability argument for the _specialize attribute +/// Specifies the precedence of an operator when used in an operation +/// that includes optional chaining. /// -public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityEntry else { return nil } + guard node.raw.kind == .precedenceGroupAssignment else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AvailabilityEntrySyntax` 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 == .availabilityEntry) + 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(), - _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, - availabilityList: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax = .semicolonToken(), - _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, + flag: TokenSyntax, + _ unexpectedAfterFlag: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, + unexpectedBeforeAssignmentKeyword?.raw, + assignmentKeyword.raw, + unexpectedBetweenAssignmentKeywordAndColon?.raw, colon.raw, - unexpectedBetweenColonAndAvailabilityList?.raw, - availabilityList.raw, - unexpectedBetweenAvailabilityListAndSemicolon?.raw, - semicolon.raw, - unexpectedAfterSemicolon?.raw, + unexpectedBetweenColonAndFlag?.raw, + flag.raw, + unexpectedAfterFlag?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityEntry, 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?) -> AvailabilityEntrySyntax { + /// 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 AvailabilityEntrySyntax(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?) -> AvailabilityEntrySyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AvailabilityEntrySyntax(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?) -> AvailabilityEntrySyntax { + /// 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 AvailabilityEntrySyntax(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)) @@ -13107,146 +12618,91 @@ public struct AvailabilityEntrySyntax: 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?) -> AvailabilityEntrySyntax { + public func withColon(_ newChild: TokenSyntax?) -> PrecedenceGroupAssignmentSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) + return PrecedenceGroupAssignmentSyntax(newData) } - public var unexpectedBetweenColonAndAvailabilityList: 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 = withUnexpectedBetweenColonAndAvailabilityList(value) + self = withUnexpectedBetweenColonAndFlag(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 { + /// 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 AvailabilityEntrySyntax(newData) + return PrecedenceGroupAssignmentSyntax(newData) } - public var availabilityList: AvailabilitySpecListSyntax { + /// + /// 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 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilitySpecList, arena: arena) - 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) - } - } - - /// 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 AvailabilityEntrySyntax(newData) - } - - public var semicolon: TokenSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withSemicolon(value) + self = withFlag(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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.semicolon, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return AvailabilityEntrySyntax(newData) + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.trueKeyword, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return PrecedenceGroupAssignmentSyntax(newData) } - public var unexpectedAfterSemicolon: 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 = withUnexpectedAfterSemicolon(value) + self = withUnexpectedAfterFlag(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 `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 AvailabilityEntrySyntax(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.unexpectedBetweenColonAndAvailabilityList, - \Self.availabilityList, - \Self.unexpectedBetweenAvailabilityListAndSemicolon, - \Self.semicolon, - \Self.unexpectedAfterSemicolon, + \Self.unexpectedBetweenColonAndFlag, + \Self.flag, + \Self.unexpectedAfterFlag, ]) } @@ -13255,7 +12711,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -13266,151 +12722,139 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension AvailabilityEntrySyntax: 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), - "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, + "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: - LabeledSpecializeEntrySyntax +// MARK: - PrecedenceGroupAssociativitySyntax /// -/// A labeled argument for the `@_specialize` attribute like -/// `exported: true` +/// Specifies how a sequence of operators with the same precedence level +/// are grouped together in the absence of grouping parentheses. /// -public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .labeledSpecializeEntry else { return nil } + guard node.raw.kind == .precedenceGroupAssociativity else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `LabeledSpecializeEntrySyntax` 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 == .labeledSpecializeEntry) + 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(), _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, value: TokenSyntax, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, + unexpectedBeforeAssociativityKeyword?.raw, + associativityKeyword.raw, + unexpectedBetweenAssociativityKeywordAndColon?.raw, colon.raw, unexpectedBetweenColonAndValue?.raw, value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedAfterValue?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.labeledSpecializeEntry, 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?) -> LabeledSpecializeEntrySyntax { + /// 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 LabeledSpecializeEntrySyntax(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?) -> LabeledSpecializeEntrySyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(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?) -> LabeledSpecializeEntrySyntax { + /// 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 LabeledSpecializeEntrySyntax(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)) @@ -13424,11 +12868,11 @@ 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?) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { @@ -13445,14 +12889,19 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { /// 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 { + public func withUnexpectedBetweenColonAndValue(_ newChild: UnexpectedNodesSyntax?) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - /// The value for this argument + /// + /// 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)) @@ -13466,90 +12915,43 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { /// 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 { + public func withValue(_ newChild: TokenSyntax?) -> PrecedenceGroupAssociativitySyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + return PrecedenceGroupAssociativitySyntax(newData) } - public var unexpectedBetweenValueAndTrailingComma: 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 = withUnexpectedBetweenValueAndTrailingComma(value) + self = withUnexpectedAfterValue(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 { + /// 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: 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: 7, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(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?) -> LabeledSpecializeEntrySyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return LabeledSpecializeEntrySyntax(newData) + 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.unexpectedBetweenColonAndValue, \Self.value, - \Self.unexpectedBetweenValueAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedAfterValue, ]) } @@ -13558,7 +12960,7 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -13566,12 +12968,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") @@ -13579,281 +12977,341 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { } } -extension LabeledSpecializeEntrySyntax: 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), "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, + "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - TargetFunctionEntrySyntax +// MARK: - CustomAttributeSyntax /// -/// A labeled argument for the `@_specialize` attribute with a function -/// decl value like -/// `target: myFunc(_:)` +/// A custom `@` attribute. /// -public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct CustomAttributeSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .targetFunctionEntry else { return nil } + guard node.raw.kind == .customAttribute else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `TargetFunctionEntrySyntax` node from the given `SyntaxData`. This assumes + /// Creates a `CustomAttributeSyntax` 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 == .customAttribute) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = 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, + _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, + atSignToken: TokenSyntax = .atSignToken(), + _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, + attributeName: A, + _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax? = nil, + _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndDeclname?.raw, - declname.raw, - unexpectedBetweenDeclnameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeAtSignToken?.raw, + atSignToken.raw, + unexpectedBetweenAtSignTokenAndAttributeName?.raw, + attributeName.raw, + unexpectedBetweenAttributeNameAndLeftParen?.raw, + leftParen?.raw, + unexpectedBetweenLeftParenAndArgumentList?.raw, + argumentList?.raw, + unexpectedBetweenArgumentListAndRightParen?.raw, + rightParen?.raw, + unexpectedAfterRightParen?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.targetFunctionEntry, from: layout, arena: arena, + kind: SyntaxKind.customAttribute, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: 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 = withUnexpectedBeforeLabel(value) + self = withUnexpectedBeforeAtSignToken(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 `unexpectedBeforeAtSignToken` replaced. + /// - param newChild: The new `unexpectedBeforeAtSignToken` to replace the node's + /// current `unexpectedBeforeAtSignToken`, if present. + public func withUnexpectedBeforeAtSignToken(_ newChild: UnexpectedNodesSyntax?) -> CustomAttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - /// The label of the argument - public var label: TokenSyntax { + /// The `@` sign. + public var atSignToken: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLabel(value) + self = withAtSignToken(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 `atSignToken` replaced. + /// - param newChild: The new `atSignToken` to replace the node's + /// current `atSignToken`, if present. + public func withAtSignToken(_ newChild: TokenSyntax?) -> CustomAttributeSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.atSign, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - public var unexpectedBetweenLabelAndColon: 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 = withUnexpectedBetweenLabelAndColon(value) + self = withUnexpectedBetweenAtSignTokenAndAttributeName(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 `unexpectedBetweenAtSignTokenAndAttributeName` replaced. + /// - param newChild: The new `unexpectedBetweenAtSignTokenAndAttributeName` to replace the node's + /// current `unexpectedBetweenAtSignTokenAndAttributeName`, if present. + public func withUnexpectedBetweenAtSignTokenAndAttributeName(_ newChild: UnexpectedNodesSyntax?) -> CustomAttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - /// The colon separating the label and the value - public var colon: TokenSyntax { + /// The name of the attribute. + public var attributeName: TypeSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + return TypeSyntax(childData!) } set(value) { - self = withColon(value) + self = withAttributeName(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?) -> TargetFunctionEntrySyntax { + /// 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?) -> CustomAttributeSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { + 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 = withUnexpectedBetweenColonAndDeclname(value) + self = withUnexpectedBetweenAttributeNameAndLeftParen(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 `unexpectedBetweenAttributeNameAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenAttributeNameAndLeftParen` to replace the node's + /// current `unexpectedBetweenAttributeNameAndLeftParen`, if present. + public func withUnexpectedBetweenAttributeNameAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> CustomAttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - /// The value for this argument - public var declname: DeclNameSyntax { + public var leftParen: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return DeclNameSyntax(childData!) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withDeclname(value) + self = withLeftParen(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 `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax?) -> CustomAttributeSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.declName, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - public var unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDeclnameAndTrailingComma(value) + self = withUnexpectedBetweenLeftParenAndArgumentList(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 { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndArgumentList` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndArgumentList` to replace the node's + /// current `unexpectedBetweenLeftParenAndArgumentList`, if present. + public func withUnexpectedBetweenLeftParenAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> CustomAttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - /// - /// A trailing comma if this argument is followed by another one - /// - public var trailingComma: TokenSyntax? { + public var argumentList: TupleExprElementListSyntax? { get { let childData = data.child(at: 7, parent: Syntax(self)) if childData == nil { return nil } - return TokenSyntax(childData!) + return TupleExprElementListSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withArgumentList(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 { + /// 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) -> CustomAttributeSyntax { + 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 CustomAttributeSyntax(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?) -> CustomAttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentListAndRightParen: 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 = withUnexpectedBetweenArgumentListAndRightParen(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 `unexpectedBetweenArgumentListAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenArgumentListAndRightParen` to replace the node's + /// current `unexpectedBetweenArgumentListAndRightParen`, if present. + public func withUnexpectedBetweenArgumentListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> CustomAttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return TargetFunctionEntrySyntax(newData) + return CustomAttributeSyntax(newData) + } + + 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?) -> CustomAttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return CustomAttributeSyntax(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?) -> CustomAttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return CustomAttributeSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndDeclname, - \Self.declname, - \Self.unexpectedBetweenDeclnameAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeAtSignToken, + \Self.atSignToken, + \Self.unexpectedBetweenAtSignTokenAndAttributeName, + \Self.attributeName, + \Self.unexpectedBetweenAttributeNameAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndArgumentList, + \Self.argumentList, + \Self.unexpectedBetweenArgumentListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -13862,74 +13320,186 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: - return nil + return "name" case 4: return nil case 5: - return "declaration name" + 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 TargetFunctionEntrySyntax: CustomReflectable { +extension CustomAttributeSyntax: 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), - "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, + "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, + "unexpectedBetweenLeftParenAndArgumentList": unexpectedBetweenLeftParenAndArgumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "argumentList": argumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenArgumentListAndRightParen": unexpectedBetweenArgumentListAndRightParen.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: - NamedAttributeStringArgumentSyntax +// MARK: - AttributeSyntax /// -/// The argument for the `@_dynamic_replacement` or `@_private` -/// attribute of the form `for: "function()"` or `sourceFile: -/// "Src.swift"` +/// An `@` attribute. /// -public struct NamedAttributeStringArgumentSyntax: SyntaxProtocol, SyntaxHashable { - public enum StringOrDeclname: SyntaxChildChoices { - case `string`(TokenSyntax) - case `declname`(DeclNameSyntax) +public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { + public enum Argument: SyntaxChildChoices { + case `token`(TokenSyntax) + case `stringExpr`(StringLiteralExprSyntax) + case `availability`(AvailabilitySpecListSyntax) + case `specializeArguments`(SpecializeAttributeSpecListSyntax) + case `objCName`(ObjCSelectorSyntax) + case `implementsArguments`(ImplementsAttributeArgumentsSyntax) + case `differentiableArguments`(DifferentiableAttributeArgumentsSyntax) + case `derivativeRegistrationArguments`(DerivativeRegistrationAttributeArgumentsSyntax) + case `namedAttributeString`(NamedAttributeStringArgumentSyntax) + case `backDeployArguments`(BackDeployAttributeSpecListSyntax) + case `conventionArguments`(ConventionAttributeArgumentsSyntax) + case `conventionWitnessMethodArguments`(ConventionWitnessMethodAttributeArgumentsSyntax) + case `opaqueReturnTypeOfAttributeArguments`(OpaqueReturnTypeOfAttributeArgumentsSyntax) + case `tokenList`(TokenListSyntax) public var _syntaxNode: Syntax { switch self { - case .string(let node): return node._syntaxNode - case .declname(let node): return node._syntaxNode + case .token(let node): return node._syntaxNode + case .stringExpr(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 .namedAttributeString(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 .tokenList(let node): return node._syntaxNode } } init(_ data: SyntaxData) { self.init(Syntax(data))! } public init(_ node: TokenSyntax) { - self = .string(node) + self = .token(node) } - public init(_ node: DeclNameSyntax) { - self = .declname(node) + public init(_ node: StringLiteralExprSyntax) { + self = .stringExpr(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: NamedAttributeStringArgumentSyntax) { + self = .namedAttributeString(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: TokenListSyntax) { + self = .tokenList(node) } public init?(_ node: S) { if let node = node.as(TokenSyntax.self) { - self = .string(node) + self = .token(node) return } - if let node = node.as(DeclNameSyntax.self) { - self = .declname(node) + if let node = node.as(StringLiteralExprSyntax.self) { + self = .stringExpr(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(NamedAttributeStringArgumentSyntax.self) { + self = .namedAttributeString(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(TokenListSyntax.self) { + self = .tokenList(node) return } return nil @@ -13938,7 +13508,19 @@ public struct NamedAttributeStringArgumentSyntax: SyntaxProtocol, SyntaxHashable public static var structure: SyntaxNodeStructure { return .choices([ .node(TokenSyntax.self), - .node(DeclNameSyntax.self), + .node(StringLiteralExprSyntax.self), + .node(AvailabilitySpecListSyntax.self), + .node(SpecializeAttributeSpecListSyntax.self), + .node(ObjCSelectorSyntax.self), + .node(ImplementsAttributeArgumentsSyntax.self), + .node(DifferentiableAttributeArgumentsSyntax.self), + .node(DerivativeRegistrationAttributeArgumentsSyntax.self), + .node(NamedAttributeStringArgumentSyntax.self), + .node(BackDeployAttributeSpecListSyntax.self), + .node(ConventionAttributeArgumentsSyntax.self), + .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), + .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), + .node(TokenListSyntax.self), ]) } } @@ -13946,202 +13528,377 @@ public struct NamedAttributeStringArgumentSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .namedAttributeStringArgument else { return nil } + guard node.raw.kind == .attribute else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `NamedAttributeStringArgumentSyntax` 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 == .namedAttributeStringArgument) + assert(data.raw.kind == .attribute) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeNameTok: UnexpectedNodesSyntax? = nil, - nameTok: TokenSyntax, - _ unexpectedBetweenNameTokAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndStringOrDeclname: UnexpectedNodesSyntax? = nil, - stringOrDeclname: StringOrDeclname, - _ unexpectedAfterStringOrDeclname: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, + atSignToken: TokenSyntax = .atSignToken(), + _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, + attributeName: TokenSyntax, + _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, + argument: Argument? = nil, + _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedBetweenRightParenAndTokenList: UnexpectedNodesSyntax? = nil, + tokenList: TokenListSyntax? = nil, + _ unexpectedAfterTokenList: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeNameTok?.raw, - nameTok.raw, - unexpectedBetweenNameTokAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndStringOrDeclname?.raw, - stringOrDeclname.raw, - unexpectedAfterStringOrDeclname?.raw, + unexpectedBeforeAtSignToken?.raw, + atSignToken.raw, + unexpectedBetweenAtSignTokenAndAttributeName?.raw, + attributeName.raw, + unexpectedBetweenAttributeNameAndLeftParen?.raw, + leftParen?.raw, + unexpectedBetweenLeftParenAndArgument?.raw, + argument?.raw, + unexpectedBetweenArgumentAndRightParen?.raw, + rightParen?.raw, + unexpectedBetweenRightParenAndTokenList?.raw, + tokenList?.raw, + unexpectedAfterTokenList?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.namedAttributeStringArgument, from: layout, arena: arena, + kind: SyntaxKind.attribute, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeNameTok: 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 = withUnexpectedBeforeNameTok(value) + self = withUnexpectedBeforeAtSignToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeNameTok` replaced. - /// - param newChild: The new `unexpectedBeforeNameTok` to replace the node's - /// current `unexpectedBeforeNameTok`, if present. - public func withUnexpectedBeforeNameTok(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { + /// 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 NamedAttributeStringArgumentSyntax(newData) + return AttributeSyntax(newData) } - /// The label of the argument - public var nameTok: TokenSyntax { + /// The `@` sign. + public var atSignToken: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withNameTok(value) + self = withAtSignToken(value) } } - /// Returns a copy of the receiver with its `nameTok` replaced. - /// - param newChild: The new `nameTok` to replace the node's - /// current `nameTok`, if present. - public func withNameTok(_ newChild: TokenSyntax?) -> NamedAttributeStringArgumentSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.atSign, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return NamedAttributeStringArgumentSyntax(newData) + return AttributeSyntax(newData) } - public var unexpectedBetweenNameTokAndColon: 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 = withUnexpectedBetweenNameTokAndColon(value) + self = withUnexpectedBetweenAtSignTokenAndAttributeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameTokAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenNameTokAndColon` to replace the node's - /// current `unexpectedBetweenNameTokAndColon`, if present. - public func withUnexpectedBetweenNameTokAndColon(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { + /// 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 NamedAttributeStringArgumentSyntax(newData) + return AttributeSyntax(newData) } - /// The colon separating the label and the value - public var colon: TokenSyntax { + /// The name of the attribute. + public var attributeName: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withColon(value) + self = withAttributeName(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?) -> NamedAttributeStringArgumentSyntax { + /// 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: TokenSyntax?) -> AttributeSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return NamedAttributeStringArgumentSyntax(newData) + return AttributeSyntax(newData) } - public var unexpectedBetweenColonAndStringOrDeclname: UnexpectedNodesSyntax? { + 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 = withUnexpectedBetweenColonAndStringOrDeclname(value) + self = withUnexpectedBetweenAttributeNameAndLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndStringOrDeclname` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndStringOrDeclname` to replace the node's - /// current `unexpectedBetweenColonAndStringOrDeclname`, if present. - public func withUnexpectedBetweenColonAndStringOrDeclname(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { + /// 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 NamedAttributeStringArgumentSyntax(newData) + return AttributeSyntax(newData) } - public var stringOrDeclname: StringOrDeclname { + /// + /// If the attribute takes arguments, the opening parenthesis. + /// + public var leftParen: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return StringOrDeclname(childData!) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withStringOrDeclname(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `stringOrDeclname` replaced. - /// - param newChild: The new `stringOrDeclname` to replace the node's - /// current `stringOrDeclname`, if present. - public func withStringOrDeclname(_ newChild: StringOrDeclname?) -> NamedAttributeStringArgumentSyntax { + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return NamedAttributeStringArgumentSyntax(newData) + return AttributeSyntax(newData) } - public var unexpectedAfterStringOrDeclname: UnexpectedNodesSyntax? { + 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 = withUnexpectedAfterStringOrDeclname(value) + self = withUnexpectedBetweenLeftParenAndArgument(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterStringOrDeclname` replaced. - /// - param newChild: The new `unexpectedAfterStringOrDeclname` to replace the node's - /// current `unexpectedAfterStringOrDeclname`, if present. - public func withUnexpectedAfterStringOrDeclname(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { + /// 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 unexpectedBetweenRightParenAndTokenList: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 10, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenRightParenAndTokenList(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenRightParenAndTokenList` replaced. + /// - param newChild: The new `unexpectedBetweenRightParenAndTokenList` to replace the node's + /// current `unexpectedBetweenRightParenAndTokenList`, if present. + public func withUnexpectedBetweenRightParenAndTokenList(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return AttributeSyntax(newData) + } + + public var tokenList: TokenListSyntax? { + get { + let childData = data.child(at: 11, parent: Syntax(self)) + if childData == nil { return nil } + return TokenListSyntax(childData!) + } + set(value) { + self = withTokenList(value) + } + } + + /// Adds the provided `Token` to the node's `tokenList` + /// collection. + /// - param element: The new `Token` to add to the node's + /// `tokenList` collection. + /// - returns: A copy of the receiver with the provided `Token` + /// appended to its `tokenList` collection. + public func addToken(_ element: TokenSyntax) -> AttributeSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[11] { + 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: 11, with: collection, arena: arena) + return AttributeSyntax(newData) + } + + /// Returns a copy of the receiver with its `tokenList` replaced. + /// - param newChild: The new `tokenList` to replace the node's + /// current `tokenList`, if present. + public func withTokenList(_ newChild: TokenListSyntax?) -> AttributeSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 11, with: raw, arena: arena) + return AttributeSyntax(newData) + } + + public var unexpectedAfterTokenList: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 12, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterTokenList(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterTokenList` replaced. + /// - param newChild: The new `unexpectedAfterTokenList` to replace the node's + /// current `unexpectedAfterTokenList`, if present. + public func withUnexpectedAfterTokenList(_ newChild: UnexpectedNodesSyntax?) -> AttributeSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return NamedAttributeStringArgumentSyntax(newData) + let newData = data.replacingChild(at: 12, with: raw, arena: arena) + return AttributeSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeNameTok, - \Self.nameTok, - \Self.unexpectedBetweenNameTokAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndStringOrDeclname, - \Self.stringOrDeclname, - \Self.unexpectedAfterStringOrDeclname, + \Self.unexpectedBeforeAtSignToken, + \Self.atSignToken, + \Self.unexpectedBetweenAtSignTokenAndAttributeName, + \Self.attributeName, + \Self.unexpectedBetweenAttributeNameAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndArgument, + \Self.argument, + \Self.unexpectedBetweenArgumentAndRightParen, + \Self.rightParen, + \Self.unexpectedBetweenRightParenAndTokenList, + \Self.tokenList, + \Self.unexpectedAfterTokenList, ]) } @@ -14150,198 +13907,326 @@ public struct NamedAttributeStringArgumentSyntax: SyntaxProtocol, SyntaxHashable case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: - return nil + return "name" 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 + case 11: + return nil + case 12: + return nil default: fatalError("Invalid index") } } } -extension NamedAttributeStringArgumentSyntax: CustomReflectable { +extension AttributeSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeNameTok": unexpectedBeforeNameTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "nameTok": Syntax(nameTok).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenNameTokAndColon": unexpectedBetweenNameTokAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndStringOrDeclname": unexpectedBetweenColonAndStringOrDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "stringOrDeclname": Syntax(stringOrDeclname).asProtocol(SyntaxProtocol.self), - "unexpectedAfterStringOrDeclname": unexpectedAfterStringOrDeclname.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, + "unexpectedBetweenRightParenAndTokenList": unexpectedBetweenRightParenAndTokenList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "tokenList": tokenList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterTokenList": unexpectedAfterTokenList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DeclNameSyntax +// MARK: - AvailabilityEntrySyntax -public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The availability argument for the _specialize attribute +/// +public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declName else { return nil } + guard node.raw.kind == .availabilityEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclNameSyntax` 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 == .declName) + assert(data.raw.kind == .availabilityEntry) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDeclBaseName: 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeDeclBaseName?.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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declName, from: layout, arena: arena, + kind: SyntaxKind.availabilityEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDeclBaseName: 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 = withUnexpectedBeforeDeclBaseName(value) + self = withUnexpectedBeforeLabel(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 `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 DeclNameSyntax(newData) + return AvailabilityEntrySyntax(newData) } - /// - /// The base name of the protocol's requirement. - /// - public var declBaseName: TokenSyntax { + /// The label of the argument + public var label: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withDeclBaseName(value) + self = withLabel(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DeclNameSyntax(newData) + return AvailabilityEntrySyntax(newData) } - public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: 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 = withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(value) + self = withUnexpectedBetweenLabelAndColon(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilitySpecList, arena: arena) + 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) + } + } + + /// 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: 2, with: raw, arena: arena) - return DeclNameSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + 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: 3, parent: Syntax(self)) - if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) + let childData = data.child(at: 7, parent: Syntax(self)) + 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?) -> DeclNameSyntax { + /// 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 newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DeclNameSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.semicolon, arena: arena) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return AvailabilityEntrySyntax(newData) } - public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterSemicolon: 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 = 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?) -> DeclNameSyntax { + /// 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: 4, with: raw, arena: arena) - return DeclNameSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return AvailabilityEntrySyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDeclBaseName, - \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, ]) } @@ -14350,297 +14235,301 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "base name" + return "label" case 2: return nil case 3: - return "arguments" + 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 DeclNameSyntax: CustomReflectable { +extension AvailabilityEntrySyntax: 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, + "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: - ImplementsAttributeArgumentsSyntax +// MARK: - LabeledSpecializeEntrySyntax /// -/// The arguments for the `@_implements` attribute of the form -/// `Type, methodName(arg1Label:arg2Label:)` +/// A labeled argument for the `@_specialize` attribute like +/// `exported: true` /// -public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .implementsAttributeArguments else { return nil } + guard node.raw.kind == .labeledSpecializeEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ImplementsAttributeArgumentsSyntax` 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 == .implementsAttributeArguments) + assert(data.raw.kind == .labeledSpecializeEntry) 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(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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, + unexpectedBetweenColonAndValue?.raw, + value.raw, + unexpectedBetweenValueAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.implementsAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.labeledSpecializeEntry, 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?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(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?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(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?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(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?) -> LabeledSpecializeEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } - public var unexpectedBetweenCommaAndDeclBaseName: 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 = withUnexpectedBetweenCommaAndDeclBaseName(value) + self = withUnexpectedBetweenColonAndValue(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 `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 ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } - /// - /// The base name of the protocol's requirement. - /// - public var declBaseName: TokenSyntax { + /// 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 = withDeclBaseName(value) + self = withValue(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 { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } - public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: 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 = withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(value) + self = withUnexpectedBetweenValueAndTrailingComma(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 `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 ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } /// - /// The argument labels of the protocol's requirement if it - /// is a function requirement. + /// A trailing comma if this argument is followed by another one /// - public var declNameArguments: DeclNameArgumentsSyntax? { + public var trailingComma: 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 = withTrailingComma(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 `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: 7, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(newData) } - public var unexpectedAfterDeclNameArguments: 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 = withUnexpectedAfterDeclNameArguments(value) + self = withUnexpectedAfterTrailingComma(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 `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: 8, with: raw, arena: arena) - return ImplementsAttributeArgumentsSyntax(newData) + return LabeledSpecializeEntrySyntax(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.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedBetweenValueAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -14649,7 +14538,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 0: return nil case 1: - return "type" + return "label" case 2: return nil case 3: @@ -14657,11 +14546,11 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 4: return nil case 5: - return "declaration base name" + return "value" case 6: return nil case 7: - return "declaration name arguments" + return nil case 8: return nil default: @@ -14670,182 +14559,281 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } -extension ImplementsAttributeArgumentsSyntax: CustomReflectable { +extension LabeledSpecializeEntrySyntax: 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), + "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: - ObjCSelectorPieceSyntax +// MARK: - TargetFunctionEntrySyntax /// -/// 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 with a function +/// decl value like +/// `target: myFunc(_:)` /// -public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { +public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .objCSelectorPiece else { return nil } + guard node.raw.kind == .targetFunctionEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ObjCSelectorPieceSyntax` 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 == .objCSelectorPiece) + assert(data.raw.kind == .targetFunctionEntry) 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(), + _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, + declname: DeclNameSyntax, + _ unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name?.raw, - unexpectedBetweenNameAndColon?.raw, - colon?.raw, - unexpectedAfterColon?.raw, + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndDeclname?.raw, + declname.raw, + unexpectedBetweenDeclnameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.objCSelectorPiece, from: layout, arena: arena, + kind: SyntaxKind.targetFunctionEntry, 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?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + return TargetFunctionEntrySyntax(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?) -> TargetFunctionEntrySyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + return TargetFunctionEntrySyntax(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?) -> TargetFunctionEntrySyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return TargetFunctionEntrySyntax(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?) -> TargetFunctionEntrySyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) + } + + 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 = withUnexpectedBetweenColonAndDeclname(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 { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) + } + + /// 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 = withDeclname(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 { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.declName, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) + } + + public var unexpectedBetweenDeclnameAndTrailingComma: 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: 2, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return TargetFunctionEntrySyntax(newData) } - public var colon: TokenSyntax? { + /// + /// A trailing comma if this argument is followed by another one + /// + public var trailingComma: 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) { - 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?) -> ObjCSelectorPieceSyntax { + /// 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: 3, with: raw, arena: arena) - return ObjCSelectorPieceSyntax(newData) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return TargetFunctionEntrySyntax(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?) -> TargetFunctionEntrySyntax { 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 TargetFunctionEntrySyntax(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.unexpectedBetweenColonAndDeclname, + \Self.declname, + \Self.unexpectedBetweenDeclnameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -14854,342 +14842,286 @@ 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 "declaration name" + case 6: + return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension ObjCSelectorPieceSyntax: CustomReflectable { +extension TargetFunctionEntrySyntax: 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), + "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: - DifferentiableAttributeArgumentsSyntax +// MARK: - NamedAttributeStringArgumentSyntax /// -/// The arguments for the `@differentiable` attribute: an optional -/// differentiability kind, an optional differentiability parameter clause, -/// and an optional 'where' clause. +/// The argument for the `@_dynamic_replacement` or `@_private` +/// attribute of the form `for: "function()"` or `sourceFile: +/// "Src.swift"` /// -public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct NamedAttributeStringArgumentSyntax: SyntaxProtocol, SyntaxHashable { + public enum StringOrDeclname: SyntaxChildChoices { + case `string`(TokenSyntax) + case `declname`(DeclNameSyntax) + public var _syntaxNode: Syntax { + switch self { + case .string(let node): return node._syntaxNode + case .declname(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: TokenSyntax) { + self = .string(node) + } + public init(_ node: DeclNameSyntax) { + self = .declname(node) + } + public init?(_ node: S) { + if let node = node.as(TokenSyntax.self) { + self = .string(node) + return + } + if let node = node.as(DeclNameSyntax.self) { + self = .declname(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(TokenSyntax.self), + .node(DeclNameSyntax.self), + ]) + } + } + public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiableAttributeArguments else { return nil } + guard node.raw.kind == .namedAttributeStringArgument else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiableAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `NamedAttributeStringArgumentSyntax` 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 == .namedAttributeStringArgument) 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, + _ unexpectedBeforeNameTok: UnexpectedNodesSyntax? = nil, + nameTok: TokenSyntax, + _ unexpectedBetweenNameTokAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndStringOrDeclname: UnexpectedNodesSyntax? = nil, + stringOrDeclname: StringOrDeclname, + _ unexpectedAfterStringOrDeclname: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiableAttributeArguments, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - 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 = withUnexpectedBeforeDiffKind(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) - } - - 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 = withDiffKind(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) - } - - 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 = withUnexpectedBetweenDiffKindAndDiffKindComma(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) - } - - /// - /// The comma following the differentiability kind, if it exists. - /// - 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 = withDiffKindComma(value) + unexpectedBeforeNameTok?.raw, + nameTok.raw, + unexpectedBetweenNameTokAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndStringOrDeclname?.raw, + stringOrDeclname.raw, + unexpectedAfterStringOrDeclname?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.namedAttributeStringArgument, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } + self.init(data) } - /// 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 newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) - } - - public var unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBeforeNameTok: 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 = withUnexpectedBetweenDiffKindCommaAndDiffParams(value) + self = withUnexpectedBeforeNameTok(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 `unexpectedBeforeNameTok` replaced. + /// - param newChild: The new `unexpectedBeforeNameTok` to replace the node's + /// current `unexpectedBeforeNameTok`, if present. + public func withUnexpectedBeforeNameTok(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return NamedAttributeStringArgumentSyntax(newData) } - public var diffParams: DifferentiabilityParamsClauseSyntax? { + /// The label of the argument + public var nameTok: TokenSyntax { get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return DifferentiabilityParamsClauseSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + return TokenSyntax(childData!) } set(value) { - self = withDiffParams(value) + self = withNameTok(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 { + /// Returns a copy of the receiver with its `nameTok` replaced. + /// - param newChild: The new `nameTok` to replace the node's + /// current `nameTok`, if present. + public func withNameTok(_ newChild: TokenSyntax?) -> NamedAttributeStringArgumentSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return NamedAttributeStringArgumentSyntax(newData) } - public var unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameTokAndColon: 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 = withUnexpectedBetweenDiffParamsAndDiffParamsComma(value) + self = withUnexpectedBetweenNameTokAndColon(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 { + /// Returns a copy of the receiver with its `unexpectedBetweenNameTokAndColon` replaced. + /// - param newChild: The new `unexpectedBetweenNameTokAndColon` to replace the node's + /// current `unexpectedBetweenNameTokAndColon`, if present. + public func withUnexpectedBetweenNameTokAndColon(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return NamedAttributeStringArgumentSyntax(newData) } - /// - /// The comma following the differentiability parameters clause, - /// if it exists. - /// - public var diffParamsComma: TokenSyntax? { + /// The colon separating the label and the value + public var colon: TokenSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withDiffParamsComma(value) + self = withColon(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 `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax?) -> NamedAttributeStringArgumentSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return NamedAttributeStringArgumentSyntax(newData) } - public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndStringOrDeclname: 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 = withUnexpectedBetweenDiffParamsCommaAndWhereClause(value) + self = withUnexpectedBetweenColonAndStringOrDeclname(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 `unexpectedBetweenColonAndStringOrDeclname` replaced. + /// - param newChild: The new `unexpectedBetweenColonAndStringOrDeclname` to replace the node's + /// current `unexpectedBetweenColonAndStringOrDeclname`, if present. + public func withUnexpectedBetweenColonAndStringOrDeclname(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { 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: 4, with: raw, arena: arena) + return NamedAttributeStringArgumentSyntax(newData) } - public var whereClause: GenericWhereClauseSyntax? { + public var stringOrDeclname: StringOrDeclname { get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return GenericWhereClauseSyntax(childData!) + let childData = data.child(at: 5, parent: Syntax(self)) + return StringOrDeclname(childData!) } set(value) { - self = withWhereClause(value) + self = withStringOrDeclname(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 `stringOrDeclname` replaced. + /// - param newChild: The new `stringOrDeclname` to replace the node's + /// current `stringOrDeclname`, if present. + public func withStringOrDeclname(_ newChild: StringOrDeclname?) -> NamedAttributeStringArgumentSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return DifferentiableAttributeArgumentsSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return NamedAttributeStringArgumentSyntax(newData) } - public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { + public var unexpectedAfterStringOrDeclname: 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 = withUnexpectedAfterWhereClause(value) + self = withUnexpectedAfterStringOrDeclname(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 `unexpectedAfterStringOrDeclname` replaced. + /// - param newChild: The new `unexpectedAfterStringOrDeclname` to replace the node's + /// current `unexpectedAfterStringOrDeclname`, if present. + public func withUnexpectedAfterStringOrDeclname(_ newChild: UnexpectedNodesSyntax?) -> NamedAttributeStringArgumentSyntax { 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: 6, with: raw, arena: arena) + return NamedAttributeStringArgumentSyntax(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.unexpectedBeforeNameTok, + \Self.nameTok, + \Self.unexpectedBetweenNameTokAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndStringOrDeclname, + \Self.stringOrDeclname, + \Self.unexpectedAfterStringOrDeclname, ]) } @@ -15198,7 +15130,7 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: @@ -15206,282 +15138,190 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash case 4: return nil case 5: - return nil + return "value" case 6: return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension DifferentiableAttributeArgumentsSyntax: CustomReflectable { +extension NamedAttributeStringArgumentSyntax: 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), - ]) - } + "unexpectedBeforeNameTok": unexpectedBeforeNameTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "nameTok": Syntax(nameTok).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenNameTokAndColon": unexpectedBetweenNameTokAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndStringOrDeclname": unexpectedBetweenColonAndStringOrDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "stringOrDeclname": Syntax(stringOrDeclname).asProtocol(SyntaxProtocol.self), + "unexpectedAfterStringOrDeclname": unexpectedAfterStringOrDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) } +} + +// 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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) + self = withUnexpectedBeforeDeclBaseName(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 { + /// 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: 0, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + return DeclNameSyntax(newData) } - /// The "wrt" label. - public var wrtLabel: TokenSyntax { + /// + /// The base name of the protocol's requirement. + /// + public var declBaseName: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withWrtLabel(value) + self = withDeclBaseName(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 { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + return DeclNameSyntax(newData) } - public var unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenWrtLabelAndColon(value) + self = withUnexpectedBetweenDeclBaseNameAndDeclNameArguments(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 { + /// 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: 2, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + return DeclNameSyntax(newData) } /// - /// The colon separating "wrt" and the parameter list. + /// The argument labels of the protocol's requirement if it + /// is a function requirement. /// - public var colon: TokenSyntax { + public var declNameArguments: DeclNameArgumentsSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return DeclNameArgumentsSyntax(childData!) } set(value) { - self = withColon(value) + self = withDeclNameArguments(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + return DeclNameSyntax(newData) } - public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { + public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenColonAndParameters(value) + self = withUnexpectedAfterDeclNameArguments(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 `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: 4, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) - } - - public var parameters: Parameters { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return Parameters(childData!) - } - set(value) { - self = withParameters(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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) - } - - public var unexpectedAfterParameters: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterParameters(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DifferentiabilityParamsClauseSyntax(newData) + 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, ]) } @@ -15490,258 +15330,297 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) 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!) + return TokenSyntax(childData!) } set(value) { - self = withDiffParams(value) - } - } - - /// 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) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.differentiabilityParamList, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) 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, ]) } @@ -15750,7 +15629,7 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "type" case 2: return nil case 3: @@ -15758,187 +15637,195 @@ 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeParameter?.raw, - parameter.raw, - unexpectedBetweenParameterAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeName?.raw, + name?.raw, + unexpectedBetweenNameAndColon?.raw, + colon?.raw, + unexpectedAfterColon?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.selfKeyword, arena: arena) + 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, ]) } @@ -15947,7 +15834,7 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "name" case 2: return nil case 3: @@ -15960,426 +15847,329 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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) - } - } - - /// 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 DerivativeRegistrationAttributeArgumentsSyntax(newData) - } - - /// The "of" label. - public var ofLabel: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withOfLabel(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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) - } - - 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 = withUnexpectedBetweenOfLabelAndColon(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) - } - - /// - /// The colon separating the "of" label and the original - /// declaration name. - /// - 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?) -> DerivativeRegistrationAttributeArgumentsSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) - } - - 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 = withUnexpectedBetweenColonAndOriginalDeclName(value) + self = withUnexpectedBeforeDiffKind(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 `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: 4, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - /// The referenced original declaration name. - public var originalDeclName: QualifiedDeclNameSyntax { + public var diffKind: TokenSyntax? { get { - let childData = data.child(at: 5, parent: Syntax(self)) - return QualifiedDeclNameSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withOriginalDeclName(value) + self = withDiffKind(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 `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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.qualifiedDeclName, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffKindAndDiffKindComma: 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 = withUnexpectedBetweenOriginalDeclNameAndPeriod(value) + self = withUnexpectedBetweenDiffKindAndDiffKindComma(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 `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: 6, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } /// - /// The period separating the original declaration name and the - /// accessor name. + /// The comma following the differentiability kind, if it exists. /// - public var period: TokenSyntax? { + public var diffKindComma: 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 = withPeriod(value) + self = withDiffKindComma(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?) -> 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 newData = data.replacingChild(at: 7, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffKindCommaAndDiffParams: 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 = withUnexpectedBetweenPeriodAndAccessorKind(value) + self = withUnexpectedBetweenDiffKindCommaAndDiffParams(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 `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: 8, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - /// The accessor name. - public var accessorKind: TokenSyntax? { + public var diffParams: DifferentiabilityParamsClauseSyntax? { get { - let childData = data.child(at: 9, parent: Syntax(self)) + let childData = data.child(at: 5, parent: Syntax(self)) if childData == nil { return nil } - return TokenSyntax(childData!) + return DifferentiabilityParamsClauseSyntax(childData!) } set(value) { - self = withAccessorKind(value) + self = withDiffParams(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 `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: 9, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffParamsAndDiffParamsComma: 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 = withUnexpectedBetweenAccessorKindAndComma(value) + self = withUnexpectedBetweenDiffParamsAndDiffParamsComma(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 `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: 10, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var comma: TokenSyntax? { + /// + /// The comma following the differentiability parameters clause, + /// if it exists. + /// + public var diffParamsComma: TokenSyntax? { get { - let childData = data.child(at: 11, parent: Syntax(self)) + let childData = data.child(at: 7, parent: Syntax(self)) if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withComma(value) + self = withDiffParamsComma(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 `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: 11, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 12, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCommaAndDiffParams(value) + self = withUnexpectedBetweenDiffParamsCommaAndWhereClause(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 `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: 12, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var diffParams: DifferentiabilityParamsClauseSyntax? { + public var whereClause: GenericWhereClauseSyntax? { get { - let childData = data.child(at: 13, parent: Syntax(self)) + let childData = data.child(at: 9, parent: Syntax(self)) if childData == nil { return nil } - return DifferentiabilityParamsClauseSyntax(childData!) + return GenericWhereClauseSyntax(childData!) } set(value) { - self = withDiffParams(value) + self = withWhereClause(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 `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: 13, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } - public var unexpectedAfterDiffParams: UnexpectedNodesSyntax? { + public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 14, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterDiffParams(value) + self = withUnexpectedAfterWhereClause(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 `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: 14, with: raw, arena: arena) - return DerivativeRegistrationAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return DifferentiableAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeOfLabel, - \Self.ofLabel, - \Self.unexpectedBetweenOfLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndOriginalDeclName, - \Self.originalDeclName, - \Self.unexpectedBetweenOriginalDeclNameAndPeriod, - \Self.period, - \Self.unexpectedBetweenPeriodAndAccessorKind, - \Self.accessorKind, - \Self.unexpectedBetweenAccessorKindAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndDiffParams, + \Self.unexpectedBeforeDiffKind, + \Self.diffKind, + \Self.unexpectedBetweenDiffKindAndDiffKindComma, + \Self.diffKindComma, + \Self.unexpectedBetweenDiffKindCommaAndDiffParams, \Self.diffParams, - \Self.unexpectedAfterDiffParams, + \Self.unexpectedBetweenDiffParamsAndDiffParamsComma, + \Self.diffParamsComma, + \Self.unexpectedBetweenDiffParamsCommaAndWhereClause, + \Self.whereClause, + \Self.unexpectedAfterWhereClause, ]) } @@ -16407,344 +16197,271 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy 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 { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeOfLabel": unexpectedBeforeOfLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "ofLabel": Syntax(ofLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOfLabelAndColon": unexpectedBetweenOfLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndOriginalDeclName": unexpectedBetweenColonAndOriginalDeclName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "originalDeclName": Syntax(originalDeclName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOriginalDeclNameAndPeriod": unexpectedBetweenOriginalDeclNameAndPeriod.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenPeriodAndAccessorKind": unexpectedBetweenPeriodAndAccessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "accessorKind": accessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAccessorKindAndComma": unexpectedBetweenAccessorKindAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenCommaAndDiffParams": unexpectedBetweenCommaAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, +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, - "unexpectedAfterDiffParams": unexpectedAfterDiffParams.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: - QualifiedDeclNameSyntax +// 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), + ]) + } + } -/// -/// An optionally qualified function declaration name (e.g. `+(_:_:)`, -/// `A.B.C.foo(_:_:)`). -/// -public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .qualifiedDeclName else { return nil } + guard node.raw.kind == .differentiabilityParamsClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `QualifiedDeclNameSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DifferentiabilityParamsClauseSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .qualifiedDeclName) + assert(data.raw.kind == .differentiabilityParamsClause) 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, + _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, + wrtLabel: TokenSyntax = .identifier("wrt"), + _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, + parameters: Parameters, + _ unexpectedAfterParameters: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeBaseType?.raw, - baseType?.raw, - unexpectedBetweenBaseTypeAndDot?.raw, - dot?.raw, - unexpectedBetweenDotAndName?.raw, - name.raw, - unexpectedBetweenNameAndArguments?.raw, - arguments?.raw, - unexpectedAfterArguments?.raw, + unexpectedBeforeWrtLabel?.raw, + wrtLabel.raw, + unexpectedBetweenWrtLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndParameters?.raw, + parameters.raw, + unexpectedAfterParameters?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.qualifiedDeclName, from: layout, arena: arena, + kind: SyntaxKind.differentiabilityParamsClause, 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 - ) - } - - public var unexpectedBeforeBaseType: UnexpectedNodesSyntax? { + public var unexpectedBeforeWrtLabel: 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 = withUnexpectedBeforeWrtLabel(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 `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 QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsClauseSyntax(newData) } - /// - /// The base type of the qualified name, optionally specified. - /// - public var baseType: TypeSyntax? { + /// The "wrt" label. + public var wrtLabel: 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 = withWrtLabel(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 `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 raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsClauseSyntax(newData) } - public var unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? { + 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 = withUnexpectedBetweenBaseTypeAndDot(value) + self = withUnexpectedBetweenWrtLabelAndColon(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 `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: 2, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsClauseSyntax(newData) } - public var dot: TokenSyntax? { + /// + /// The colon separating "wrt" and the parameter list. + /// + 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 = withDot(value) + self = withColon(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 { + /// 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 raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + return DifferentiabilityParamsClauseSyntax(newData) } - public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDotAndName(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) - } - - /// - /// The base name of the referenced function. - /// - public var name: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withName(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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) - } - - 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 = withUnexpectedBetweenNameAndArguments(value) + self = withUnexpectedBetweenColonAndParameters(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 `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: 6, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - /// - /// The argument labels of the referenced function, optionally - /// specified. - /// - public var arguments: DeclNameArgumentsSyntax? { + public var parameters: Parameters { get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) + let childData = data.child(at: 5, parent: Syntax(self)) + return Parameters(childData!) } set(value) { - self = withArguments(value) + self = withParameters(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 { + /// 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: 7, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(newData) } - public var unexpectedAfterArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterParameters: 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 = withUnexpectedAfterArguments(value) + self = withUnexpectedAfterParameters(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 { + /// 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: 8, with: raw, arena: arena) - return QualifiedDeclNameSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return DifferentiabilityParamsClauseSyntax(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.unexpectedBeforeWrtLabel, + \Self.wrtLabel, + \Self.unexpectedBetweenWrtLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndParameters, + \Self.parameters, + \Self.unexpectedAfterParameters, ]) } @@ -16753,7 +16470,7 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "base type" + return nil case 2: return nil case 3: @@ -16761,197 +16478,250 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return "base name" + return "parameters" case 6: return nil - case 7: - return "arguments" - case 8: - return nil default: fatalError("Invalid index") } } } -extension QualifiedDeclNameSyntax: CustomReflectable { +extension DifferentiabilityParamsClauseSyntax: 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, + "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, ]) } } -// MARK: - FunctionDeclNameSyntax +// MARK: - DifferentiabilityParamsSyntax -/// A function declaration name (e.g. `foo(_:_:)`). -public struct FunctionDeclNameSyntax: SyntaxProtocol, SyntaxHashable { +/// The differentiability parameters. +public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionDeclName else { return nil } + guard node.raw.kind == .differentiabilityParams else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `FunctionDeclNameSyntax` 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 == .functionDeclName) + assert(data.raw.kind == .differentiabilityParams) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndArguments?.raw, - arguments?.raw, - unexpectedAfterArguments?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndDiffParams?.raw, + diffParams.raw, + unexpectedBetweenDiffParamsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionDeclName, from: layout, arena: arena, + kind: SyntaxKind.differentiabilityParams, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: 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 = withUnexpectedBeforeName(value) + self = withUnexpectedBeforeLeftParen(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?) -> FunctionDeclNameSyntax { + /// 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 FunctionDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - /// - /// The base name of the referenced function. - /// - public var name: TokenSyntax { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withName(value) + self = withLeftParen(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?) -> FunctionDeclNameSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return FunctionDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenNameAndArguments: 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 = withUnexpectedBetweenNameAndArguments(value) + self = withUnexpectedBetweenLeftParenAndDiffParams(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?) -> FunctionDeclNameSyntax { + /// 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 FunctionDeclNameSyntax(newData) + return DifferentiabilityParamsSyntax(newData) } - /// - /// The argument labels of the referenced function, optionally - /// specified. - /// - public var arguments: DeclNameArgumentsSyntax? { + /// The parameters for differentiation. + public var diffParams: DifferentiabilityParamListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) + return DifferentiabilityParamListSyntax(childData!) + } + set(value) { + self = withDiffParams(value) + } + } + + /// Adds the provided `DifferentiabilityParam` to the node's `diffParams` + /// collection. + /// - param element: The new `DifferentiabilityParam` to add to the node's + /// `diffParams` collection. + /// - returns: A copy of the receiver with the provided `DifferentiabilityParam` + /// appended to its `diffParams` collection. + public func addDifferentiabilityParam(_ element: DifferentiabilityParamSyntax) -> DifferentiabilityParamsSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return DifferentiabilityParamsSyntax(newData) + } + + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.differentiabilityParamList, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return DifferentiabilityParamsSyntax(newData) + } + + public var unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) + return UnexpectedNodesSyntax(childData!) } set(value) { - self = withArguments(value) + self = withUnexpectedBetweenDiffParamsAndRightParen(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 { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return DifferentiabilityParamsSyntax(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 `arguments` replaced. - /// - param newChild: The new `arguments` to replace the node's - /// current `arguments`, if present. - public func withArguments(_ newChild: DeclNameArgumentsSyntax?) -> FunctionDeclNameSyntax { + /// 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: 3, with: raw, arena: arena) - return FunctionDeclNameSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return DifferentiabilityParamsSyntax(newData) } - public var unexpectedAfterArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: 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 = withUnexpectedAfterArguments(value) + self = withUnexpectedAfterRightParen(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?) -> FunctionDeclNameSyntax { + /// 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: 4, with: raw, arena: arena) - return FunctionDeclNameSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return DifferentiabilityParamsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndArguments, - \Self.arguments, - \Self.unexpectedAfterArguments, + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDiffParams, + \Self.diffParams, + \Self.unexpectedBetweenDiffParamsAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -16960,261 +16730,195 @@ public struct FunctionDeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "base name" + return nil case 2: return nil case 3: - return "arguments" + return nil case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension FunctionDeclNameSyntax: CustomReflectable { +extension DifferentiabilityParamsSyntax: 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), - "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: BackDeployVersionListSyntax, - _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, + parameter: TokenSyntax, + _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.selfKeyword, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + 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: BackDeployVersionListSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return BackDeployVersionListSyntax(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: BackDeployVersionArgumentSyntax) -> 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.backDeployVersionList, - 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: BackDeployVersionListSyntax?) -> BackDeployAttributeSpecListSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.backDeployVersionList, arena: arena) - 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, ]) } @@ -17230,341 +16934,335 @@ 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: - BackDeployVersionArgumentSyntax +// MARK: - DerivativeRegistrationAttributeArgumentsSyntax /// -/// A single platform/version pair in a `@_backDeploy` 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 BackDeployVersionArgumentSyntax: SyntaxProtocol, SyntaxHashable { +public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .backDeployVersionArgument else { return nil } + guard node.raw.kind == .derivativeRegistrationAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `BackDeployVersionArgumentSyntax` 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 == .backDeployVersionArgument) + 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.backDeployVersionArgument, 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?) -> BackDeployVersionArgumentSyntax { + /// 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 BackDeployVersionArgumentSyntax(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?) -> BackDeployVersionArgumentSyntax { + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilityVersionRestriction, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return BackDeployVersionArgumentSyntax(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?) -> BackDeployVersionArgumentSyntax { + /// 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 BackDeployVersionArgumentSyntax(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?) -> BackDeployVersionArgumentSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return BackDeployVersionArgumentSyntax(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?) -> BackDeployVersionArgumentSyntax { + /// 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 BackDeployVersionArgumentSyntax(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 BackDeployVersionArgumentSyntax: 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.qualifiedDeclName, arena: arena) + 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 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) + } + } - public init?(_ node: S) { - guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { return nil } - self._syntaxNode = node._syntaxNode + /// 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) } - /// 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) + /// + /// 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) + } } - 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 - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeMangledName?.raw, - mangledName.raw, - unexpectedBetweenMangledNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndOrdinal?.raw, - ordinal.raw, - unexpectedAfterOrdinal?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) + /// 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 unexpectedBeforeMangledName: UnexpectedNodesSyntax? { + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.stringLiteral(""), arena: arena) - 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) { @@ -17575,85 +17273,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 ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) - 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.integerLiteral(""), arena: arena) - 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, ]) } @@ -17673,328 +17379,352 @@ 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( - 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, + 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, trailingTrivia: Trivia? = nil ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) 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) - } - } - - /// 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: 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) + self = withUnexpectedAfterArguments(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 { + } + + /// 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: 10, with: raw, arena: arena) - return ConventionAttributeArgumentsSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + 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, ]) } @@ -18003,7 +17733,7 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 0: return nil case 1: - return nil + return "base type" case 2: return nil case 3: @@ -18011,244 +17741,197 @@ 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: - FunctionDeclNameSyntax -/// -/// The arguments for the '@convention(witness_method: ...)'. -/// -public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +/// A function declaration name (e.g. `foo(_:_:)`). +public struct FunctionDeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { return nil } + guard node.raw.kind == .functionDeclName else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConventionWitnessMethodAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `FunctionDeclNameSyntax` 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 == .functionDeclName) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, - witnessMethodLabel: TokenSyntax, - _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, - protocolName: TokenSyntax, - _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeWitnessMethodLabel?.raw, - witnessMethodLabel.raw, - unexpectedBetweenWitnessMethodLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndProtocolName?.raw, - protocolName.raw, - unexpectedAfterProtocolName?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndArguments?.raw, + arguments?.raw, + unexpectedAfterArguments?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionWitnessMethodAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.functionDeclName, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWitnessMethodLabel: 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 = withUnexpectedBeforeWitnessMethodLabel(value) + self = withUnexpectedBeforeName(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 `unexpectedBeforeName` replaced. + /// - param newChild: The new `unexpectedBeforeName` to replace the node's + /// current `unexpectedBeforeName`, if present. + public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> FunctionDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return FunctionDeclNameSyntax(newData) } - public var witnessMethodLabel: TokenSyntax { + /// + /// The base name of the referenced function. + /// + public var name: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withWitnessMethodLabel(value) + self = withName(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 `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax?) -> FunctionDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return FunctionDeclNameSyntax(newData) } - public var unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndArguments: 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 = withUnexpectedBetweenNameAndArguments(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 `unexpectedBetweenNameAndArguments` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndArguments` to replace the node's + /// current `unexpectedBetweenNameAndArguments`, if present. + public func withUnexpectedBetweenNameAndArguments(_ newChild: UnexpectedNodesSyntax?) -> FunctionDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return FunctionDeclNameSyntax(newData) } - public var colon: TokenSyntax { + /// + /// The argument labels of the referenced function, optionally + /// specified. + /// + public var arguments: DeclNameArgumentsSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + 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?) -> ConventionWitnessMethodAttributeArgumentsSyntax { + /// 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?) -> FunctionDeclNameSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return FunctionDeclNameSyntax(newData) } - public var unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? { + public var unexpectedAfterArguments: 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 = withUnexpectedAfterArguments(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 `unexpectedAfterArguments` replaced. + /// - param newChild: The new `unexpectedAfterArguments` to replace the node's + /// current `unexpectedAfterArguments`, if present. + public func withUnexpectedAfterArguments(_ newChild: UnexpectedNodesSyntax?) -> FunctionDeclNameSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) - } - - public var protocolName: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withProtocolName(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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) - } - - 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 = withUnexpectedAfterProtocolName(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 { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + return FunctionDeclNameSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWitnessMethodLabel, - \Self.witnessMethodLabel, - \Self.unexpectedBetweenWitnessMethodLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndProtocolName, - \Self.protocolName, - \Self.unexpectedAfterProtocolName, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndArguments, + \Self.arguments, + \Self.unexpectedAfterArguments, ]) } @@ -18257,190 +17940,261 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S 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 nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension ConventionWitnessMethodAttributeArgumentsSyntax: CustomReflectable { +extension FunctionDeclNameSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeWitnessMethodLabel": unexpectedBeforeWitnessMethodLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "witnessMethodLabel": Syntax(witnessMethodLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenWitnessMethodLabelAndColon": unexpectedBetweenWitnessMethodLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndProtocolName": unexpectedBetweenColonAndProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "protocolName": Syntax(protocolName).asProtocol(SyntaxProtocol.self), - "unexpectedAfterProtocolName": unexpectedAfterProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "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: - WhereClauseSyntax +// MARK: - BackDeployAttributeSpecListSyntax -public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// A collection of arguments for the `@_backDeploy` attribute +/// +public struct BackDeployAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .whereClause else { return nil } + guard node.raw.kind == .backDeployAttributeSpecList else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `WhereClauseSyntax` 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 == .whereClause) + assert(data.raw.kind == .backDeployAttributeSpecList) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, - whereKeyword: TokenSyntax = .whereKeyword(), - _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, - guardResult: G, - _ unexpectedAfterGuardResult: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, + beforeLabel: TokenSyntax = .identifier("before"), + _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, + versionList: BackDeployVersionListSyntax, + _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeWhereKeyword?.raw, - whereKeyword.raw, - unexpectedBetweenWhereKeywordAndGuardResult?.raw, - guardResult.raw, - unexpectedAfterGuardResult?.raw, + unexpectedBeforeBeforeLabel?.raw, + beforeLabel.raw, + unexpectedBetweenBeforeLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndVersionList?.raw, + versionList.raw, + unexpectedAfterVersionList?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.whereClause, from: layout, arena: arena, + kind: SyntaxKind.backDeployAttributeSpecList, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWhereKeyword: 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 = withUnexpectedBeforeWhereKeyword(value) + self = withUnexpectedBeforeBeforeLabel(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 `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 WhereClauseSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var whereKeyword: TokenSyntax { + /// The "before" label. + public var beforeLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withWhereKeyword(value) + self = withBeforeLabel(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.whereKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return WhereClauseSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var unexpectedBetweenWhereKeywordAndGuardResult: 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 = withUnexpectedBetweenWhereKeywordAndGuardResult(value) + self = withUnexpectedBetweenBeforeLabelAndColon(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 `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 WhereClauseSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var guardResult: ExprSyntax { + /// + /// The colon separating "before" and the parameter list. + /// + 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?) -> BackDeployAttributeSpecListSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return WhereClauseSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) } - public var unexpectedAfterGuardResult: 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 = withUnexpectedAfterGuardResult(value) + self = withUnexpectedBetweenColonAndVersionList(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 `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 WhereClauseSyntax(newData) + return BackDeployAttributeSpecListSyntax(newData) + } + + /// + /// The list of OS versions in which the declaration became ABI + /// stable. + /// + public var versionList: BackDeployVersionListSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return BackDeployVersionListSyntax(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: BackDeployVersionArgumentSyntax) -> 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.backDeployVersionList, + 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: BackDeployVersionListSyntax?) -> BackDeployAttributeSpecListSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.backDeployVersionList, arena: arena) + 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) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWhereKeyword, - \Self.whereKeyword, - \Self.unexpectedBetweenWhereKeywordAndGuardResult, - \Self.guardResult, - \Self.unexpectedAfterGuardResult, + \Self.unexpectedBeforeBeforeLabel, + \Self.beforeLabel, + \Self.unexpectedBetweenBeforeLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndVersionList, + \Self.versionList, + \Self.unexpectedAfterVersionList, ]) } @@ -18456,512 +18210,430 @@ 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 BackDeployAttributeSpecListSyntax: 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, + "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, ]) } } -// MARK: - YieldListSyntax +// MARK: - BackDeployVersionArgumentSyntax -public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// A single platform/version pair in a `@_backDeploy` attribute, +/// e.g. `iOS 10.1`. +/// +public struct BackDeployVersionArgumentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .yieldList else { return nil } + guard node.raw.kind == .backDeployVersionArgument else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `YieldListSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `BackDeployVersionArgumentSyntax` 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) + assert(data.raw.kind == .backDeployVersionArgument) 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, + _ unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? = nil, + availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax, + _ unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElementList?.raw, - elementList.raw, - unexpectedBetweenElementListAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeAvailabilityVersionRestriction?.raw, + availabilityVersionRestriction.raw, + unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldList, from: layout, arena: arena, + kind: SyntaxKind.backDeployVersionArgument, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: 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 = withUnexpectedBeforeLeftParen(value) + self = withUnexpectedBeforeAvailabilityVersionRestriction(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 `unexpectedBeforeAvailabilityVersionRestriction` replaced. + /// - param newChild: The new `unexpectedBeforeAvailabilityVersionRestriction` to replace the node's + /// current `unexpectedBeforeAvailabilityVersionRestriction`, if present. + public func withUnexpectedBeforeAvailabilityVersionRestriction(_ newChild: UnexpectedNodesSyntax?) -> BackDeployVersionArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return YieldListSyntax(newData) + return BackDeployVersionArgumentSyntax(newData) } - public var leftParen: TokenSyntax { + public var availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return AvailabilityVersionRestrictionSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withAvailabilityVersionRestriction(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 `availabilityVersionRestriction` replaced. + /// - param newChild: The new `availabilityVersionRestriction` to replace the node's + /// current `availabilityVersionRestriction`, if present. + public func withAvailabilityVersionRestriction(_ newChild: AvailabilityVersionRestrictionSyntax?) -> BackDeployVersionArgumentSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilityVersionRestriction, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return YieldListSyntax(newData) + return BackDeployVersionArgumentSyntax(newData) } - public var unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: 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 = withUnexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma(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 `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma` replaced. + /// - param newChild: The new `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma` to replace the node's + /// current `unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma`, if present. + public func withUnexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> BackDeployVersionArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return YieldListSyntax(newData) + return BackDeployVersionArgumentSyntax(newData) } - public var elementList: YieldExprListSyntax { + /// + /// A trailing comma if the argument is followed by another + /// argument + /// + public var trailingComma: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return YieldExprListSyntax(childData!) + if childData == nil { return nil } + 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 = withTrailingComma(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 `trailingComma` replaced. + /// - param newChild: The new `trailingComma` to replace the node's + /// current `trailingComma`, if present. + public func withTrailingComma(_ newChild: TokenSyntax?) -> BackDeployVersionArgumentSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.yieldExprList, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return YieldListSyntax(newData) + return BackDeployVersionArgumentSyntax(newData) } - public var unexpectedBetweenElementListAndRightParen: 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 = withUnexpectedBetweenElementListAndRightParen(value) + self = withUnexpectedAfterTrailingComma(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 `unexpectedAfterTrailingComma` replaced. + /// - param newChild: The new `unexpectedAfterTrailingComma` to replace the node's + /// current `unexpectedAfterTrailingComma`, if present. + public func withUnexpectedAfterTrailingComma(_ newChild: UnexpectedNodesSyntax?) -> BackDeployVersionArgumentSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return YieldListSyntax(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?) -> YieldListSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return YieldListSyntax(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?) -> YieldListSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return YieldListSyntax(newData) + return BackDeployVersionArgumentSyntax(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 `unavailability`(UnavailabilityConditionSyntax) - 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 .unavailability(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: UnavailabilityConditionSyntax) { - self = .unavailability(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(UnavailabilityConditionSyntax.self) { - self = .unavailability(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.unexpectedBeforeAvailabilityVersionRestriction, + \Self.availabilityVersionRestriction, + \Self.unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, + ]) + } + + 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 static var structure: SyntaxNodeStructure { - return .choices([ - .node(ExprSyntax.self), - .node(AvailabilityConditionSyntax.self), - .node(UnavailabilityConditionSyntax.self), - .node(MatchingPatternConditionSyntax.self), - .node(OptionalBindingConditionSyntax.self), - .node(HasSymbolConditionSyntax.self), - ]) - } +extension BackDeployVersionArgumentSyntax: 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, + ]) } +} + +// MARK: - OpaqueReturnTypeOfAttributeArgumentsSyntax +/// +/// The arguments for the '@_opaqueReturnTypeOf()'. +/// +public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conditionElement else { return nil } + guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConditionElementSyntax` 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 == .conditionElement) + assert(data.raw.kind == .opaqueReturnTypeOfAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, - condition: Condition, - _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, + mangledName: TokenSyntax, + _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, + ordinal: TokenSyntax, + _ unexpectedAfterOrdinal: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeCondition?.raw, - condition.raw, - unexpectedBetweenConditionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeMangledName?.raw, + mangledName.raw, + unexpectedBetweenMangledNameAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndOrdinal?.raw, + ordinal.raw, + unexpectedAfterOrdinal?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conditionElement, from: layout, arena: arena, + kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCondition: 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 = withUnexpectedBeforeCondition(value) + self = withUnexpectedBeforeMangledName(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 `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 ConditionElementSyntax(newData) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var condition: Condition { + /// The mangled name of a declaration. + public var mangledName: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return Condition(childData!) + return TokenSyntax(childData!) } set(value) { - self = withCondition(value) + self = withMangledName(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 `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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.stringLiteral(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenMangledNameAndComma: 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 = withUnexpectedBetweenMangledNameAndComma(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 `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: 2, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var trailingComma: 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 = 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?) -> ConditionElementSyntax { + /// 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 { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.comma, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndOrdinal: 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 = withUnexpectedBetweenCommaAndOrdinal(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 `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: 4, with: raw, arena: arena) - return ConditionElementSyntax(newData) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + } + + /// The ordinal corresponding to the 'some' keyword that introduced this opaque type. + public var ordinal: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withOrdinal(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 { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.integerLiteral(""), arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) + } + + public var unexpectedAfterOrdinal: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterOrdinal(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 { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return OpaqueReturnTypeOfAttributeArgumentsSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeCondition, - \Self.condition, - \Self.unexpectedBetweenConditionAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeMangledName, + \Self.mangledName, + \Self.unexpectedBetweenMangledNameAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndOrdinal, + \Self.ordinal, + \Self.unexpectedAfterOrdinal, ]) } @@ -18977,290 +18649,332 @@ 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 OpaqueReturnTypeOfAttributeArgumentsSyntax: 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, + "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, ]) } } -// MARK: - AvailabilityConditionSyntax +// MARK: - ConventionAttributeArgumentsSyntax -public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the '@convention(...)'. +/// +public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityCondition else { return nil } + guard node.raw.kind == .conventionAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AvailabilityConditionSyntax` 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 == .availabilityCondition) + assert(data.raw.kind == .conventionAttributeArguments) self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundAvailableKeyword: UnexpectedNodesSyntax? = nil, - poundAvailableKeyword: TokenSyntax = .poundAvailableKeyword(), - _ unexpectedBetweenPoundAvailableKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, - availabilitySpec: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + } + + 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, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePoundAvailableKeyword?.raw, - poundAvailableKeyword.raw, - unexpectedBetweenPoundAvailableKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, - availabilitySpec.raw, - unexpectedBetweenAvailabilitySpecAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeConventionLabel?.raw, + conventionLabel.raw, + unexpectedBetweenConventionLabelAndComma?.raw, + comma?.raw, + unexpectedBetweenCommaAndCTypeLabel?.raw, + cTypeLabel?.raw, + unexpectedBetweenCTypeLabelAndColon?.raw, + colon?.raw, + unexpectedBetweenColonAndCTypeString?.raw, + cTypeString?.raw, + unexpectedAfterCTypeString?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityCondition, from: layout, arena: arena, + kind: SyntaxKind.conventionAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePoundAvailableKeyword: UnexpectedNodesSyntax? { + 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 = withUnexpectedBeforePoundAvailableKeyword(value) + self = withUnexpectedBeforeConventionLabel(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundAvailableKeyword` replaced. - /// - param newChild: The new `unexpectedBeforePoundAvailableKeyword` to replace the node's - /// current `unexpectedBeforePoundAvailableKeyword`, if present. - public func withUnexpectedBeforePoundAvailableKeyword(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + /// 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 AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var poundAvailableKeyword: TokenSyntax { + /// The convention label. + public var conventionLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withPoundAvailableKeyword(value) + self = withConventionLabel(value) } } - /// Returns a copy of the receiver with its `poundAvailableKeyword` replaced. - /// - param newChild: The new `poundAvailableKeyword` to replace the node's - /// current `poundAvailableKeyword`, if present. - public func withPoundAvailableKeyword(_ newChild: TokenSyntax?) -> AvailabilityConditionSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.poundAvailableKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenPoundAvailableKeywordAndLeftParen: UnexpectedNodesSyntax? { + 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 = withUnexpectedBetweenPoundAvailableKeywordAndLeftParen(value) + self = withUnexpectedBetweenConventionLabelAndComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPoundAvailableKeywordAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenPoundAvailableKeywordAndLeftParen` to replace the node's - /// current `unexpectedBetweenPoundAvailableKeywordAndLeftParen`, if present. - public func withUnexpectedBetweenPoundAvailableKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { + /// 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 AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var leftParen: 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 = withLeftParen(value) + self = withComma(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndCTypeLabel: 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 = withUnexpectedBetweenCommaAndCTypeLabel(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 `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: 4, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var availabilitySpec: AvailabilitySpecListSyntax { + public var cTypeLabel: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return AvailabilitySpecListSyntax(childData!) + if childData == nil { return nil } + 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 = withCTypeLabel(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 `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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilitySpecList, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenCTypeLabelAndColon: 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 = withUnexpectedBetweenCTypeLabelAndColon(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 `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: 6, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var rightParen: TokenSyntax { + public var colon: 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 = withColon(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 `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon(_ newChild: TokenSyntax?) -> ConventionAttributeArgumentsSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + return ConventionAttributeArgumentsSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndCTypeString: 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 = withUnexpectedBetweenColonAndCTypeString(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 `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: 8, with: raw, arena: arena) - return AvailabilityConditionSyntax(newData) + 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) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundAvailableKeyword, - \Self.poundAvailableKeyword, - \Self.unexpectedBetweenPoundAvailableKeywordAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, - \Self.availabilitySpec, - \Self.unexpectedBetweenAvailabilitySpecAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeConventionLabel, + \Self.conventionLabel, + \Self.unexpectedBetweenConventionLabelAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndCTypeLabel, + \Self.cTypeLabel, + \Self.unexpectedBetweenCTypeLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndCTypeString, + \Self.cTypeString, + \Self.unexpectedAfterCTypeString, ]) } @@ -19284,276 +18998,429 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { return nil case 8: return nil + case 9: + return nil + case 10: + return nil default: fatalError("Invalid index") } } } -extension AvailabilityConditionSyntax: CustomReflectable { +extension ConventionAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundAvailableKeyword": unexpectedBeforePoundAvailableKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundAvailableKeyword": Syntax(poundAvailableKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPoundAvailableKeywordAndLeftParen": unexpectedBetweenPoundAvailableKeywordAndLeftParen.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, + "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: - MatchingPatternConditionSyntax +// MARK: - ConventionWitnessMethodAttributeArgumentsSyntax -public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the '@convention(witness_method: ...)'. +/// +public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .matchingPatternCondition else { return nil } + guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `MatchingPatternConditionSyntax` 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 == .matchingPatternCondition) + assert(data.raw.kind == .conventionWitnessMethodAttributeArguments) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .caseKeyword(), - _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax, - _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, + witnessMethodLabel: TokenSyntax, + _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, + protocolName: TokenSyntax, + _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer.raw, - unexpectedAfterInitializer?.raw, + unexpectedBeforeWitnessMethodLabel?.raw, + witnessMethodLabel.raw, + unexpectedBetweenWitnessMethodLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndProtocolName?.raw, + protocolName.raw, + unexpectedAfterProtocolName?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.matchingPatternCondition, from: layout, arena: arena, + kind: SyntaxKind.conventionWitnessMethodAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCaseKeyword: 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 = withUnexpectedBeforeCaseKeyword(value) + self = withUnexpectedBeforeWitnessMethodLabel(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 `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 MatchingPatternConditionSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } - public var caseKeyword: TokenSyntax { + public var witnessMethodLabel: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withCaseKeyword(value) + self = withWitnessMethodLabel(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.caseKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) } - public var unexpectedBetweenCaseKeywordAndPattern: 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 = withUnexpectedBetweenCaseKeywordAndPattern(value) + self = withUnexpectedBetweenWitnessMethodLabelAndColon(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 { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return ConventionWitnessMethodAttributeArgumentsSyntax(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?) -> ConventionWitnessMethodAttributeArgumentsSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + } + + 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 = withUnexpectedBetweenColonAndProtocolName(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 { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + } + + public var protocolName: TokenSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withProtocolName(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 { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + } + + 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 = withUnexpectedAfterProtocolName(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 { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return ConventionWitnessMethodAttributeArgumentsSyntax(newData) + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeWitnessMethodLabel, + \Self.witnessMethodLabel, + \Self.unexpectedBetweenWitnessMethodLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndProtocolName, + \Self.protocolName, + \Self.unexpectedAfterProtocolName, + ]) + } + + 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 ConventionWitnessMethodAttributeArgumentsSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeWitnessMethodLabel": unexpectedBeforeWitnessMethodLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "witnessMethodLabel": Syntax(witnessMethodLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenWitnessMethodLabelAndColon": unexpectedBetweenWitnessMethodLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndProtocolName": unexpectedBetweenColonAndProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "protocolName": Syntax(protocolName).asProtocol(SyntaxProtocol.self), + "unexpectedAfterProtocolName": unexpectedAfterProtocolName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) } +} + +// MARK: - WhereClauseSyntax + +public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax - /// 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 MatchingPatternConditionSyntax(newData) + public init?(_ node: S) { + guard node.raw.kind == .whereClause else { return nil } + self._syntaxNode = node._syntaxNode } - public var pattern: PatternSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return PatternSyntax(childData!) - } - set(value) { - self = withPattern(value) - } + /// 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 == .whereClause) + self._syntaxNode = Syntax(data) } - /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, + whereKeyword: TokenSyntax = .whereKeyword(), + _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, + guardResult: G, + _ unexpectedAfterGuardResult: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeWhereKeyword?.raw, + whereKeyword.raw, + unexpectedBetweenWhereKeywordAndGuardResult?.raw, + guardResult.raw, + unexpectedAfterGuardResult?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.whereClause, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + public var unexpectedBeforeWhereKeyword: 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 = withUnexpectedBetweenPatternAndTypeAnnotation(value) + self = withUnexpectedBeforeWhereKeyword(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 `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: 4, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return WhereClauseSyntax(newData) } - public var typeAnnotation: TypeAnnotationSyntax? { + public var whereKeyword: TokenSyntax { get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TypeAnnotationSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + return TokenSyntax(childData!) } set(value) { - self = withTypeAnnotation(value) + self = withWhereKeyword(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 { + /// 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: 5, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.whereKeyword, arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return WhereClauseSyntax(newData) } - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + public var unexpectedBetweenWhereKeywordAndGuardResult: 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 = withUnexpectedBetweenTypeAnnotationAndInitializer(value) + self = withUnexpectedBetweenWhereKeywordAndGuardResult(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 { + /// 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: 6, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return WhereClauseSyntax(newData) } - public var initializer: InitializerClauseSyntax { + public var guardResult: ExprSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) - return InitializerClauseSyntax(childData!) + let childData = data.child(at: 3, parent: Syntax(self)) + return ExprSyntax(childData!) } set(value) { - self = withInitializer(value) + self = withGuardResult(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 { + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.initializerClause, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return WhereClauseSyntax(newData) } - public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { + public var unexpectedAfterGuardResult: 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 = withUnexpectedAfterInitializer(value) + self = withUnexpectedAfterGuardResult(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 { + /// 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: 8, with: raw, arena: arena) - return MatchingPatternConditionSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + 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, ]) } @@ -19569,285 +19436,243 @@ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.letKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) 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() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.yieldExprList, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) 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, ]) } @@ -19867,298 +19692,256 @@ 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 `unavailability`(UnavailabilityConditionSyntax) + 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 .unavailability(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: UnavailabilityConditionSyntax) { + self = .unavailability(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(UnavailabilityConditionSyntax.self) { + self = .unavailability(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(UnavailabilityConditionSyntax.self), + .node(MatchingPatternConditionSyntax.self), + .node(OptionalBindingConditionSyntax.self), + .node(HasSymbolConditionSyntax.self), + ]) + } } -} -// MARK: - UnavailabilityConditionSyntax - -public struct UnavailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unavailabilityCondition else { return nil } + guard node.raw.kind == .conditionElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `UnavailabilityConditionSyntax` 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 == .unavailabilityCondition) + assert(data.raw.kind == .conditionElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundUnavailableKeyword: UnexpectedNodesSyntax? = nil, - poundUnavailableKeyword: TokenSyntax = .poundUnavailableKeyword(), - _ unexpectedBetweenPoundUnavailableKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, - availabilitySpec: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: 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 ) { let layout: [RawSyntax?] = [ - unexpectedBeforePoundUnavailableKeyword?.raw, - poundUnavailableKeyword.raw, - unexpectedBetweenPoundUnavailableKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, - availabilitySpec.raw, - unexpectedBetweenAvailabilitySpecAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeCondition?.raw, + condition.raw, + unexpectedBetweenConditionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unavailabilityCondition, from: layout, arena: arena, + kind: SyntaxKind.conditionElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePoundUnavailableKeyword: 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 = withUnexpectedBeforePoundUnavailableKeyword(value) + self = withUnexpectedBeforeCondition(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundUnavailableKeyword` replaced. - /// - param newChild: The new `unexpectedBeforePoundUnavailableKeyword` to replace the node's - /// current `unexpectedBeforePoundUnavailableKeyword`, if present. - public func withUnexpectedBeforePoundUnavailableKeyword(_ newChild: UnexpectedNodesSyntax?) -> UnavailabilityConditionSyntax { + /// 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 UnavailabilityConditionSyntax(newData) + return ConditionElementSyntax(newData) } - public var poundUnavailableKeyword: TokenSyntax { + public var condition: Condition { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return Condition(childData!) } set(value) { - self = withPoundUnavailableKeyword(value) + self = withCondition(value) } } - /// Returns a copy of the receiver with its `poundUnavailableKeyword` replaced. - /// - param newChild: The new `poundUnavailableKeyword` to replace the node's - /// current `poundUnavailableKeyword`, if present. - public func withPoundUnavailableKeyword(_ newChild: TokenSyntax?) -> UnavailabilityConditionSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.poundUnavailableKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return UnavailabilityConditionSyntax(newData) + return ConditionElementSyntax(newData) } - public var unexpectedBetweenPoundUnavailableKeywordAndLeftParen: 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 = withUnexpectedBetweenPoundUnavailableKeywordAndLeftParen(value) + self = withUnexpectedBetweenConditionAndTrailingComma(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPoundUnavailableKeywordAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenPoundUnavailableKeywordAndLeftParen` to replace the node's - /// current `unexpectedBetweenPoundUnavailableKeywordAndLeftParen`, if present. - public func withUnexpectedBetweenPoundUnavailableKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> UnavailabilityConditionSyntax { + /// 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 UnavailabilityConditionSyntax(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?) -> UnavailabilityConditionSyntax { + /// 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return UnavailabilityConditionSyntax(newData) + return ConditionElementSyntax(newData) } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: 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 = withUnexpectedBetweenLeftParenAndAvailabilitySpec(value) + self = withUnexpectedAfterTrailingComma(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?) -> UnavailabilityConditionSyntax { + /// 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 UnavailabilityConditionSyntax(newData) - } - - public var availabilitySpec: AvailabilitySpecListSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return AvailabilitySpecListSyntax(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) -> UnavailabilityConditionSyntax { - 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 UnavailabilityConditionSyntax(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?) -> UnavailabilityConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilitySpecList, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return UnavailabilityConditionSyntax(newData) - } - - 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 = withUnexpectedBetweenAvailabilitySpecAndRightParen(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?) -> UnavailabilityConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return UnavailabilityConditionSyntax(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?) -> UnavailabilityConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return UnavailabilityConditionSyntax(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?) -> UnavailabilityConditionSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return UnavailabilityConditionSyntax(newData) + return ConditionElementSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundUnavailableKeyword, - \Self.poundUnavailableKeyword, - \Self.unexpectedBetweenPoundUnavailableKeywordAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, - \Self.availabilitySpec, - \Self.unexpectedBetweenAvailabilitySpecAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeCondition, + \Self.condition, + \Self.unexpectedBetweenConditionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -20174,147 +19957,135 @@ public struct UnavailabilityConditionSyntax: 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 UnavailabilityConditionSyntax: CustomReflectable { +extension ConditionElementSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundUnavailableKeyword": unexpectedBeforePoundUnavailableKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundUnavailableKeyword": Syntax(poundUnavailableKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPoundUnavailableKeywordAndLeftParen": unexpectedBetweenPoundUnavailableKeywordAndLeftParen.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, + "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: - HasSymbolConditionSyntax +// MARK: - AvailabilityConditionSyntax -public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { +public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .hasSymbolCondition else { return nil } + guard node.raw.kind == .availabilityCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `HasSymbolConditionSyntax` 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 == .hasSymbolCondition) + assert(data.raw.kind == .availabilityCondition) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeHasSymbolKeyword: UnexpectedNodesSyntax? = nil, - hasSymbolKeyword: TokenSyntax, - _ unexpectedBetweenHasSymbolKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePoundAvailableKeyword: UnexpectedNodesSyntax? = nil, + poundAvailableKeyword: TokenSyntax = .poundAvailableKeyword(), + _ unexpectedBetweenPoundAvailableKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, + availabilitySpec: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax = .rightParenToken(), _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeHasSymbolKeyword?.raw, - hasSymbolKeyword.raw, - unexpectedBetweenHasSymbolKeywordAndLeftParen?.raw, + unexpectedBeforePoundAvailableKeyword?.raw, + poundAvailableKeyword.raw, + unexpectedBetweenPoundAvailableKeywordAndLeftParen?.raw, leftParen.raw, - unexpectedBetweenLeftParenAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndRightParen?.raw, + unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, + availabilitySpec.raw, + unexpectedBetweenAvailabilitySpecAndRightParen?.raw, rightParen.raw, unexpectedAfterRightParen?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.hasSymbolCondition, from: layout, arena: arena, + kind: SyntaxKind.availabilityCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeHasSymbolKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforePoundAvailableKeyword: 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 = withUnexpectedBeforePoundAvailableKeyword(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 `unexpectedBeforePoundAvailableKeyword` replaced. + /// - param newChild: The new `unexpectedBeforePoundAvailableKeyword` to replace the node's + /// current `unexpectedBeforePoundAvailableKeyword`, if present. + public func withUnexpectedBeforePoundAvailableKeyword(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var hasSymbolKeyword: TokenSyntax { + public var poundAvailableKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withHasSymbolKeyword(value) + self = withPoundAvailableKeyword(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 `poundAvailableKeyword` replaced. + /// - param newChild: The new `poundAvailableKeyword` to replace the node's + /// current `poundAvailableKeyword`, if present. + public func withPoundAvailableKeyword(_ newChild: TokenSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundAvailableKeyword, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var unexpectedBetweenHasSymbolKeywordAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenPoundAvailableKeywordAndLeftParen: 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 = withUnexpectedBetweenPoundAvailableKeywordAndLeftParen(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 `unexpectedBetweenPoundAvailableKeywordAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenPoundAvailableKeywordAndLeftParen` to replace the node's + /// current `unexpectedBetweenPoundAvailableKeywordAndLeftParen`, if present. + public func withUnexpectedBetweenPoundAvailableKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } public var leftParen: TokenSyntax { @@ -20330,73 +20101,92 @@ public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { /// 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 { + public func withLeftParen(_ newChild: TokenSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var unexpectedBetweenLeftParenAndExpression: 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 = withUnexpectedBetweenLeftParenAndExpression(value) + self = withUnexpectedBetweenLeftParenAndAvailabilitySpec(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 `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 HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var expression: ExprSyntax { + public var availabilitySpec: AvailabilitySpecListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return ExprSyntax(childData!) + return AvailabilitySpecListSyntax(childData!) } set(value) { - self = withExpression(value) + self = withAvailabilitySpec(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 { + /// 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() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + 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 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 { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilitySpecList, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } - public var unexpectedBetweenExpressionAndRightParen: 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 = withUnexpectedBetweenExpressionAndRightParen(value) + self = withUnexpectedBetweenAvailabilitySpecAndRightParen(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 { + /// 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 HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } public var rightParen: TokenSyntax { @@ -20412,11 +20202,11 @@ public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { /// 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 { + public func withRightParen(_ newChild: TokenSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { @@ -20433,22 +20223,22 @@ public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { /// 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 { + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> AvailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return HasSymbolConditionSyntax(newData) + return AvailabilityConditionSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeHasSymbolKeyword, - \Self.hasSymbolKeyword, - \Self.unexpectedBetweenHasSymbolKeywordAndLeftParen, + \Self.unexpectedBeforePoundAvailableKeyword, + \Self.poundAvailableKeyword, + \Self.unexpectedBetweenPoundAvailableKeywordAndLeftParen, \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndRightParen, + \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, + \Self.availabilitySpec, + \Self.unexpectedBetweenAvailabilitySpecAndRightParen, \Self.rightParen, \Self.unexpectedAfterRightParen, ]) @@ -20474,284 +20264,276 @@ public struct HasSymbolConditionSyntax: SyntaxProtocol, SyntaxHashable { return nil case 8: return nil - default: - fatalError("Invalid index") - } - } -} - -extension HasSymbolConditionSyntax: 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, - ]) - } -} - -// 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), - ]) + default: + fatalError("Invalid index") } } +} + +extension AvailabilityConditionSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforePoundAvailableKeyword": unexpectedBeforePoundAvailableKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "poundAvailableKeyword": Syntax(poundAvailableKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPoundAvailableKeywordAndLeftParen": unexpectedBetweenPoundAvailableKeywordAndLeftParen.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: - MatchingPatternConditionSyntax +public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchCase else { return nil } + guard node.raw.kind == .matchingPatternCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchCaseSyntax` 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 == .switchCase) + assert(data.raw.kind == .matchingPatternCondition) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, - unknownAttr: AttributeSyntax? = nil, - _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, - label: Label, - _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .caseKeyword(), + _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax, + _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeUnknownAttr?.raw, - unknownAttr?.raw, - unexpectedBetweenUnknownAttrAndLabel?.raw, - label.raw, - unexpectedBetweenLabelAndStatements?.raw, - statements.raw, - unexpectedAfterStatements?.raw, + unexpectedBeforeCaseKeyword?.raw, + caseKeyword.raw, + unexpectedBetweenCaseKeywordAndPattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer.raw, + unexpectedAfterInitializer?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchCase, from: layout, arena: arena, + kind: SyntaxKind.matchingPatternCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeUnknownAttr: 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 = withUnexpectedBeforeUnknownAttr(value) + self = withUnexpectedBeforeCaseKeyword(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 `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 SwitchCaseSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var unknownAttr: AttributeSyntax? { + public var caseKeyword: 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 = withCaseKeyword(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 `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 raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.caseKeyword, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var unexpectedBetweenUnknownAttrAndLabel: 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 = withUnexpectedBetweenUnknownAttrAndLabel(value) + self = withUnexpectedBetweenCaseKeywordAndPattern(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 `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 SwitchCaseSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var label: Label { + public var pattern: PatternSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return Label(childData!) + return PatternSyntax(childData!) } set(value) { - self = withLabel(value) + self = withPattern(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 `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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var unexpectedBetweenLabelAndStatements: 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 = withUnexpectedBetweenLabelAndStatements(value) + self = withUnexpectedBetweenPatternAndTypeAnnotation(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 `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 SwitchCaseSyntax(newData) + return MatchingPatternConditionSyntax(newData) } - public var statements: CodeBlockItemListSyntax { + public var typeAnnotation: TypeAnnotationSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return CodeBlockItemListSyntax(childData!) + if childData == nil { return nil } + return TypeAnnotationSyntax(childData!) } set(value) { - self = withStatements(value) + self = withTypeAnnotation(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) -> SwitchCaseSyntax { - var collection: RawSyntax + /// 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() - 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 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) } - 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 { + /// 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return MatchingPatternConditionSyntax(newData) } - public var unexpectedAfterStatements: UnexpectedNodesSyntax? { + public var initializer: InitializerClauseSyntax { get { - let childData = data.child(at: 6, parent: Syntax(self)) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.initializerClause, arena: arena) + 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 = withUnexpectedAfterStatements(value) + self = withUnexpectedAfterInitializer(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 `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: 6, with: raw, arena: arena) - return SwitchCaseSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return MatchingPatternConditionSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeUnknownAttr, - \Self.unknownAttr, - \Self.unexpectedBetweenUnknownAttrAndLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndStatements, - \Self.statements, - \Self.unexpectedAfterStatements, + \Self.unexpectedBeforeCaseKeyword, + \Self.caseKeyword, + \Self.unexpectedBetweenCaseKeywordAndPattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedAfterInitializer, ]) } @@ -20764,186 +20546,288 @@ 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 MatchingPatternConditionSyntax: 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, + "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: - SwitchDefaultLabelSyntax +// MARK: - OptionalBindingConditionSyntax -public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { +public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchDefaultLabel else { return nil } + guard node.raw.kind == .optionalBindingCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchDefaultLabelSyntax` 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 == .switchDefaultLabel) + assert(data.raw.kind == .optionalBindingCondition) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, - defaultKeyword: TokenSyntax = .defaultKeyword(), - _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = 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, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeDefaultKeyword?.raw, - defaultKeyword.raw, - unexpectedBetweenDefaultKeywordAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, + unexpectedBeforeLetOrVarKeyword?.raw, + letOrVarKeyword.raw, + unexpectedBetweenLetOrVarKeywordAndPattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer?.raw, + unexpectedAfterInitializer?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchDefaultLabel, from: layout, arena: arena, + kind: SyntaxKind.optionalBindingCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDefaultKeyword: 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 = withUnexpectedBeforeDefaultKeyword(value) + self = withUnexpectedBeforeLetOrVarKeyword(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 `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 SwitchDefaultLabelSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var defaultKeyword: TokenSyntax { + public var letOrVarKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withDefaultKeyword(value) + self = withLetOrVarKeyword(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 `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 ?? RawSyntax.makeMissingToken(kind: TokenKind.defaultKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.letKeyword, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return OptionalBindingConditionSyntax(newData) } - public var unexpectedBetweenDefaultKeywordAndColon: 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 = withUnexpectedBetweenDefaultKeywordAndColon(value) + self = withUnexpectedBetweenLetOrVarKeywordAndPattern(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 `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 SwitchDefaultLabelSyntax(newData) + return OptionalBindingConditionSyntax(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?) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return OptionalBindingConditionSyntax(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?) -> OptionalBindingConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SwitchDefaultLabelSyntax(newData) + return OptionalBindingConditionSyntax(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?) -> OptionalBindingConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return OptionalBindingConditionSyntax(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?) -> OptionalBindingConditionSyntax { + 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) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDefaultKeyword, - \Self.defaultKeyword, - \Self.unexpectedBetweenDefaultKeywordAndColon, - \Self.colon, - \Self.unexpectedAfterColon, + \Self.unexpectedBeforeLetOrVarKeyword, + \Self.letOrVarKeyword, + \Self.unexpectedBetweenLetOrVarKeywordAndPattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedAfterInitializer, ]) } @@ -20959,226 +20843,302 @@ 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 OptionalBindingConditionSyntax: 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, + "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, ]) } } -// MARK: - CaseItemSyntax +// MARK: - UnavailabilityConditionSyntax -public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { +public struct UnavailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .caseItem else { return nil } + guard node.raw.kind == .unavailabilityCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `CaseItemSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnavailabilityConditionSyntax` 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 == .unavailabilityCondition) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePoundUnavailableKeyword: UnexpectedNodesSyntax? = nil, + poundUnavailableKeyword: TokenSyntax = .poundUnavailableKeyword(), + _ unexpectedBetweenPoundUnavailableKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, + availabilitySpec: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforePoundUnavailableKeyword?.raw, + poundUnavailableKeyword.raw, + unexpectedBetweenPoundUnavailableKeywordAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, + availabilitySpec.raw, + unexpectedBetweenAvailabilitySpecAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in let raw = RawSyntax.makeLayout( - kind: SyntaxKind.caseItem, from: layout, arena: arena, + kind: SyntaxKind.unavailabilityCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePattern: UnexpectedNodesSyntax? { + public var unexpectedBeforePoundUnavailableKeyword: 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 = withUnexpectedBeforePoundUnavailableKeyword(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 `unexpectedBeforePoundUnavailableKeyword` replaced. + /// - param newChild: The new `unexpectedBeforePoundUnavailableKeyword` to replace the node's + /// current `unexpectedBeforePoundUnavailableKeyword`, if present. + public func withUnexpectedBeforePoundUnavailableKeyword(_ newChild: UnexpectedNodesSyntax?) -> UnavailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return CaseItemSyntax(newData) + return UnavailabilityConditionSyntax(newData) } - public var pattern: PatternSyntax { + public var poundUnavailableKeyword: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return PatternSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withPattern(value) + self = withPoundUnavailableKeyword(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 `poundUnavailableKeyword` replaced. + /// - param newChild: The new `poundUnavailableKeyword` to replace the node's + /// current `poundUnavailableKeyword`, if present. + public func withPoundUnavailableKeyword(_ newChild: TokenSyntax?) -> UnavailabilityConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundUnavailableKeyword, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return CaseItemSyntax(newData) + return UnavailabilityConditionSyntax(newData) } - public var unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenPoundUnavailableKeywordAndLeftParen: 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 = withUnexpectedBetweenPoundUnavailableKeywordAndLeftParen(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 `unexpectedBetweenPoundUnavailableKeywordAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenPoundUnavailableKeywordAndLeftParen` to replace the node's + /// current `unexpectedBetweenPoundUnavailableKeywordAndLeftParen`, if present. + public func withUnexpectedBetweenPoundUnavailableKeywordAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> UnavailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return CaseItemSyntax(newData) + return UnavailabilityConditionSyntax(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?) -> CaseItemSyntax { + /// 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?) -> UnavailabilityConditionSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return CaseItemSyntax(newData) + return UnavailabilityConditionSyntax(newData) } - public var unexpectedBetweenWhereClauseAndTrailingComma: 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 = withUnexpectedBetweenWhereClauseAndTrailingComma(value) + self = withUnexpectedBetweenLeftParenAndAvailabilitySpec(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 `unexpectedBetweenLeftParenAndAvailabilitySpec` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndAvailabilitySpec` to replace the node's + /// current `unexpectedBetweenLeftParenAndAvailabilitySpec`, if present. + public func withUnexpectedBetweenLeftParenAndAvailabilitySpec(_ newChild: UnexpectedNodesSyntax?) -> UnavailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return CaseItemSyntax(newData) + return UnavailabilityConditionSyntax(newData) } - public var trailingComma: TokenSyntax? { + public var availabilitySpec: AvailabilitySpecListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return AvailabilitySpecListSyntax(childData!) } set(value) { - self = withTrailingComma(value) + self = withAvailabilitySpec(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 { + /// 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) -> UnavailabilityConditionSyntax { + 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.availabilitySpecList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return UnavailabilityConditionSyntax(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?) -> UnavailabilityConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.availabilitySpecList, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return CaseItemSyntax(newData) + return UnavailabilityConditionSyntax(newData) } - public var unexpectedAfterTrailingComma: 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 = withUnexpectedAfterTrailingComma(value) + self = withUnexpectedBetweenAvailabilitySpecAndRightParen(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 `unexpectedBetweenAvailabilitySpecAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenAvailabilitySpecAndRightParen` to replace the node's + /// current `unexpectedBetweenAvailabilitySpecAndRightParen`, if present. + public func withUnexpectedBetweenAvailabilitySpecAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> UnavailabilityConditionSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return CaseItemSyntax(newData) + return UnavailabilityConditionSyntax(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?) -> UnavailabilityConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return UnavailabilityConditionSyntax(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?) -> UnavailabilityConditionSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return UnavailabilityConditionSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePattern, - \Self.pattern, - \Self.unexpectedBetweenPatternAndWhereClause, - \Self.whereClause, - \Self.unexpectedBetweenWhereClauseAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforePoundUnavailableKeyword, + \Self.poundUnavailableKeyword, + \Self.unexpectedBetweenPoundUnavailableKeywordAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, + \Self.availabilitySpec, + \Self.unexpectedBetweenAvailabilitySpecAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -21198,263 +21158,279 @@ 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 UnavailabilityConditionSyntax: 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, + "unexpectedBeforePoundUnavailableKeyword": unexpectedBeforePoundUnavailableKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "poundUnavailableKeyword": Syntax(poundUnavailableKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPoundUnavailableKeywordAndLeftParen": unexpectedBetweenPoundUnavailableKeywordAndLeftParen.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: - 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + 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, ]) } @@ -21472,7 +21448,11 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { return nil case 5: return nil - case 6: + case 6: + return nil + case 7: + return nil + case 8: return nil default: fatalError("Invalid index") @@ -21480,239 +21460,259 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { } } -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 = .caseKeyword(), - _ 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 ) { 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.caseKeyword, arena: arena) + 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 ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.caseItemList, arena: arena) + 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 ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + 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, ]) } @@ -21738,16 +21738,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 41e3cf04c32..ecd8bb132d2 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift @@ -2280,370 +2280,6 @@ extension ForInStmtSyntax: CustomReflectable { } } -// MARK: - SwitchStmtSyntax - -public struct SwitchStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .switchStmt else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `SwitchStmtSyntax` 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) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, - switchKeyword: TokenSyntax = .switchKeyword(), - _ 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 - ) { - 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchStmt, 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?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SwitchStmtSyntax(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?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.switchKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SwitchStmtSyntax(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?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SwitchStmtSyntax(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?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SwitchStmtSyntax(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?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SwitchStmtSyntax(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?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) - 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!) - } - 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) -> SwitchStmtSyntax { - 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 SwitchStmtSyntax(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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.switchCaseList, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return SwitchStmtSyntax(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?) -> SwitchStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return SwitchStmtSyntax(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 ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) - 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 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 SwitchStmtSyntax: 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: - DoStmtSyntax public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { @@ -3981,408 +3617,6 @@ extension ThrowStmtSyntax: CustomReflectable { } } -// 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), - ]) - } - } - - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .ifStmt else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `IfStmtSyntax` 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) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, - ifKeyword: TokenSyntax = .ifKeyword(), - _ 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 - ) { - 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 data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifStmt, 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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.ifKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return IfStmtSyntax(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) -> 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) - } - 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 { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.conditionElementList, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlock, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return IfStmtSyntax(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?) -> IfStmtSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return IfStmtSyntax(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 IfStmtSyntax: 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: - PoundAssertStmtSyntax public struct PoundAssertStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index 99f4ef9b7cc..90a3b960c1d 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -703,7 +703,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 @@ -1148,7 +1148,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 0c13eb7b5f7..ed414339a89 100644 --- a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift +++ b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift @@ -217,7 +217,7 @@ extension IdentifierPatternSyntax: SyntaxExpressibleByStringInterpolation { extension IfConfigDeclSyntax: SyntaxExpressibleByStringInterpolation { } -extension IfStmtSyntax: SyntaxExpressibleByStringInterpolation { +extension IfExprSyntax: SyntaxExpressibleByStringInterpolation { } extension ImplicitlyUnwrappedOptionalTypeSyntax: SyntaxExpressibleByStringInterpolation { @@ -425,7 +425,7 @@ extension SwitchCaseSyntax: SyntaxExpressibleByStringInterpolation { } } -extension SwitchStmtSyntax: SyntaxExpressibleByStringInterpolation { +extension SwitchExprSyntax: SyntaxExpressibleByStringInterpolation { } extension SymbolicReferenceExprSyntax: SyntaxExpressibleByStringInterpolation { diff --git a/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift b/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift index c4a17b7c162..3e1a1f18c56 100644 --- a/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift +++ b/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift @@ -267,7 +267,7 @@ public typealias IfConfigClause = IfConfigClauseSyntax public typealias IfConfigDecl = IfConfigDeclSyntax -public typealias IfStmt = IfStmtSyntax +public typealias IfExpr = IfExprSyntax public typealias ImplementsAttributeArguments = ImplementsAttributeArgumentsSyntax @@ -465,7 +465,7 @@ public typealias SwitchCase = SwitchCaseSyntax public typealias SwitchDefaultLabel = SwitchDefaultLabelSyntax -public typealias SwitchStmt = SwitchStmtSyntax +public typealias SwitchExpr = SwitchExprSyntax public typealias SymbolicReferenceExpr = SymbolicReferenceExprSyntax From b0f8805963fc7b868b68fd23d6ea8f0f89a47ba1 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Wed, 1 Feb 2023 19:17:21 +0000 Subject: [PATCH 9/9] Address review feedback Clean up some code, allow `if` and `switch` to count as the start of an expression, and add some substructure test assertions. --- Sources/SwiftParser/Expressions.swift | 16 +- Sources/SwiftParser/RawTokenKindSubset.swift | 16 +- Sources/SwiftParser/TopLevel.swift | 7 +- Tests/SwiftParserTest/ExpressionTests.swift | 312 ++++++++++++++++-- .../MigrateToNewIfLetSyntax.swift | 29 +- 5 files changed, 328 insertions(+), 52 deletions(-) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 4a0e2ab2f32..f509153783e 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -505,19 +505,21 @@ extension Parser { // First check to see if we have the start of a regex literal `/.../`. // tryLexRegexLiteral(/*forUnappliedOperator*/ false) + switch self.currentToken.tokenKind { // 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)) { + case .switchKeyword: return RawExprSyntax( - parseSwitchExpression(switchHandle: .constant(.keyword(.switch))) + parseSwitchExpression(switchHandle: .constant(.switchKeyword)) ) - } - if self.at(.keyword(.if)) { + case .ifKeyword: return RawExprSyntax( - parseIfExpression(ifHandle: .constant(.keyword(.if))) + parseIfExpression(ifHandle: .constant(.ifKeyword)) ) + default: + break } switch self.at(anyIn: ExpressionPrefixOperator.self) { @@ -2495,8 +2497,8 @@ extension Parser.Lookahead { } // If this is the start of a switch body, this isn't a trailing closure. - if self.peek().rawTokenKind == .keyword(.case) { - return false; + if self.peek().tokenKind == .caseKeyword { + return false } // If this is a normal expression (not an expr-basic) then trailing closures diff --git a/Sources/SwiftParser/RawTokenKindSubset.swift b/Sources/SwiftParser/RawTokenKindSubset.swift index 9115dfbd1ba..08578ee2f93 100644 --- a/Sources/SwiftParser/RawTokenKindSubset.swift +++ b/Sources/SwiftParser/RawTokenKindSubset.swift @@ -616,17 +616,17 @@ enum IfOrSwitch: RawTokenKindSubset { case switchKeyword init?(lexeme: Lexer.Lexeme) { - switch lexeme { - case RawTokenKindMatch(.keyword(.if)): self = .ifKeyword - case RawTokenKindMatch(.keyword(.switch)): self = .switchKeyword + switch lexeme.tokenKind { + case .ifKeyword: self = .ifKeyword + case .switchKeyword: self = .switchKeyword default: return nil } } var rawTokenKind: RawTokenKind { switch self { - case .ifKeyword: return .keyword(.if) - case .switchKeyword: return .keyword(.switch) + case .ifKeyword: return .ifKeyword + case .switchKeyword: return .switchKeyword } } } @@ -795,6 +795,7 @@ enum ExpressionStart: RawTokenKindSubset { case expressionPrefixOperator(ExpressionPrefixOperator) case matchingPatternStart(MatchingPatternStart) case primaryExpressionStart(PrimaryExpressionStart) + case ifOrSwitch(IfOrSwitch) init?(lexeme: Lexer.Lexeme) { if let subset = AwaitTryMove(lexeme: lexeme) { @@ -805,6 +806,8 @@ enum ExpressionStart: RawTokenKindSubset { self = .matchingPatternStart(subset) } else if let subset = PrimaryExpressionStart(lexeme: lexeme) { self = .primaryExpressionStart(subset) + } else if let subset = IfOrSwitch(lexeme: lexeme) { + self = .ifOrSwitch(subset) } else { return nil } @@ -815,6 +818,7 @@ enum ExpressionStart: RawTokenKindSubset { + ExpressionPrefixOperator.allCases.map(Self.expressionPrefixOperator) + MatchingPatternStart.allCases.map(Self.matchingPatternStart) + PrimaryExpressionStart.allCases.map(Self.primaryExpressionStart) + + IfOrSwitch.allCases.map(Self.ifOrSwitch) } var rawTokenKind: RawTokenKind { @@ -823,6 +827,7 @@ enum ExpressionStart: RawTokenKindSubset { case .expressionPrefixOperator(let underlyingKind): return underlyingKind.rawTokenKind case .matchingPatternStart(let underlyingKind): return underlyingKind.rawTokenKind case .primaryExpressionStart(let underlyingKind): return underlyingKind.rawTokenKind + case .ifOrSwitch(let underlyingKind): return underlyingKind.rawTokenKind } } @@ -832,6 +837,7 @@ enum ExpressionStart: RawTokenKindSubset { case .expressionPrefixOperator(let underlyingKind): return underlyingKind.contextualKeyword case .matchingPatternStart(let underlyingKind): return underlyingKind.contextualKeyword case .primaryExpressionStart(let underlyingKind): return underlyingKind.contextualKeyword + case .ifOrSwitch(let underlyingKind): return underlyingKind.contextualKeyword } } } diff --git a/Sources/SwiftParser/TopLevel.swift b/Sources/SwiftParser/TopLevel.swift index 23f62aac936..25dc3d421c7 100644 --- a/Sources/SwiftParser/TopLevel.swift +++ b/Sources/SwiftParser/TopLevel.swift @@ -202,11 +202,12 @@ extension Parser { // 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 at(.asKeyword), + let expr = stmt.as(RawExpressionStmtSyntax.self)?.expression + { if expr.is(RawIfExprSyntax.self) || expr.is(RawSwitchExprSyntax.self) { let (op, rhs) = parseUnresolvedAsExpr( - handle: .init(tokenKind: .keyword(.as)) + handle: .init(tokenKind: .asKeyword) ) let sequence = RawExprSyntax( RawSequenceExprSyntax( diff --git a/Tests/SwiftParserTest/ExpressionTests.swift b/Tests/SwiftParserTest/ExpressionTests.swift index 0253fa84bb7..126eb1f4f95 100644 --- a/Tests/SwiftParserTest/ExpressionTests.swift +++ b/Tests/SwiftParserTest/ExpressionTests.swift @@ -805,22 +805,110 @@ final class ExpressionTests: XCTestCase { } final class StatementExpressionTests: XCTestCase { + private func ifZeroElseOne() -> ExprSyntax { + .init( + IfExprSyntax( + conditions: [ + .init( + condition: .expression( + .init( + FunctionCallExprSyntax(callee: MemberAccessExprSyntax(dot: .prefixPeriod, name: "random")) + ) + ) + ) + ], + body: .init(statements: [ + .init(item: .expr(.init(IntegerLiteralExprSyntax(0)))) + ]), + elseKeyword: .elseKeyword(), + elseBody: .init( + .codeBlock( + .init(statements: [ + .init(item: .expr(.init(IntegerLiteralExprSyntax(1)))) + ]) + ) + ) + ) + ) + } + private func switchRandomZeroOne() -> ExprSyntax { + .init( + SwitchExprSyntax( + expression: FunctionCallExprSyntax( + callee: MemberAccessExprSyntax( + base: ExprSyntax(IdentifierExprSyntax(identifier: .identifier("Bool"))), + name: "random" + ) + ), + cases: [ + .switchCase( + .init( + label: .case( + .init(caseItems: [ + .init(pattern: ExpressionPatternSyntax(expression: BooleanLiteralExprSyntax(true))) + ]) + ), + statements: [ + .init(item: .expr(.init(IntegerLiteralExprSyntax(0)))) + ] + ) + ), + .switchCase( + .init( + label: .case( + .init(caseItems: [ + .init(pattern: ExpressionPatternSyntax(expression: BooleanLiteralExprSyntax(false))) + ]) + ), + statements: [ + .init(item: .expr(.init(IntegerLiteralExprSyntax(1)))) + ] + ) + ), + ] + ) + ) + } func testIfExprInCoercion() { AssertParse( """ func foo() { if .random() { 0 } else { 1 } as Int } - """ + """, + substructure: Syntax( + SequenceExprSyntax( + elements: ExprListSyntax([ + ifZeroElseOne(), + ExprSyntax( + UnresolvedAsExprSyntax() + ), + ExprSyntax( + TypeExprSyntax(type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("Int")))) + ), + ]) + ) + ) ) } func testSwitchExprInCoercion() { AssertParse( """ - func foo() { - switch Bool.random() { case true: 0 case false: 1 } as Int - } - """ + switch Bool.random() { case true: 0 case false: 1 } as Int + """, + substructure: Syntax( + SequenceExprSyntax( + elements: ExprListSyntax([ + switchRandomZeroOne(), + ExprSyntax( + UnresolvedAsExprSyntax() + ), + ExprSyntax( + TypeExprSyntax(type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("Int")))) + ), + ]) + ) + ) ) } func testIfExprInReturn() { @@ -829,7 +917,10 @@ final class StatementExpressionTests: XCTestCase { func foo() { return if .random() { 0 } else { 1 } } - """ + """, + substructure: Syntax( + ReturnStmtSyntax(expression: ifZeroElseOne()) + ) ) } func testSwitchExprInReturn() { @@ -838,7 +929,10 @@ final class StatementExpressionTests: XCTestCase { func foo() { return switch Bool.random() { case true: 0 case false: 1 } } - """ + """, + substructure: Syntax( + ReturnStmtSyntax(expression: switchRandomZeroOne()) + ) ) } func testTryIf1() { @@ -847,7 +941,10 @@ final class StatementExpressionTests: XCTestCase { func foo() -> Int { try if .random() { 0 } else { 1 } } - """ + """, + substructure: Syntax( + TryExprSyntax(expression: ifZeroElseOne()) + ) ) } func testTryIf2() { @@ -856,7 +953,10 @@ final class StatementExpressionTests: XCTestCase { func foo() -> Int { return try if .random() { 0 } else { 1 } } - """ + """, + substructure: Syntax( + ReturnStmtSyntax(expression: TryExprSyntax(expression: ifZeroElseOne())) + ) ) } func testTryIf3() { @@ -866,7 +966,10 @@ final class StatementExpressionTests: XCTestCase { let x = try if .random() { 0 } else { 1 } return x } - """ + """, + substructure: Syntax( + TryExprSyntax(expression: ifZeroElseOne()) + ) ) } func testAwaitIf1() { @@ -875,7 +978,10 @@ final class StatementExpressionTests: XCTestCase { func foo() async -> Int { await if .random() { 0 } else { 1 } } - """ + """, + substructure: Syntax( + AwaitExprSyntax(expression: ifZeroElseOne()) + ) ) } func testAwaitIf2() { @@ -884,7 +990,10 @@ final class StatementExpressionTests: XCTestCase { func foo() async -> Int { return await if .random() { 0 } else { 1 } } - """ + """, + substructure: Syntax( + ReturnStmtSyntax(expression: AwaitExprSyntax(expression: ifZeroElseOne())) + ) ) } func testAwaitIf3() { @@ -894,16 +1003,20 @@ final class StatementExpressionTests: XCTestCase { let x = await if .random() { 0 } else { 1 } return x } - """ + """, + substructure: Syntax( + AwaitExprSyntax(expression: ifZeroElseOne()) + ) ) } func testTrySwitch1() { AssertParse( """ - func foo() -> Int { - try switch Bool.random() { case true: 0 case false: 1 } - } - """ + try switch Bool.random() { case true: 0 case false: 1 } + """, + substructure: Syntax( + TryExprSyntax(expression: switchRandomZeroOne()) + ) ) } func testTrySwitch2() { @@ -912,7 +1025,10 @@ final class StatementExpressionTests: XCTestCase { func foo() -> Int { return try switch Bool.random() { case true: 0 case false: 1 } } - """ + """, + substructure: Syntax( + ReturnStmtSyntax(expression: TryExprSyntax(expression: switchRandomZeroOne())) + ) ) } func testTrySwitch3() { @@ -922,16 +1038,20 @@ final class StatementExpressionTests: XCTestCase { let x = try switch Bool.random() { case true: 0 case false: 1 } return x } - """ + """, + substructure: Syntax( + TryExprSyntax(expression: switchRandomZeroOne()) + ) ) } func testAwaitSwitch1() { AssertParse( """ - func foo() async -> Int { - await switch Bool.random() { case true: 0 case false: 1 } - } - """ + await switch Bool.random() { case true: 0 case false: 1 } + """, + substructure: Syntax( + AwaitExprSyntax(expression: switchRandomZeroOne()) + ) ) } func testAwaitSwitch2() { @@ -940,7 +1060,10 @@ final class StatementExpressionTests: XCTestCase { func foo() async -> Int { return await switch Bool.random() { case true: 0 case false: 1 } } - """ + """, + substructure: Syntax( + ReturnStmtSyntax(expression: AwaitExprSyntax(expression: switchRandomZeroOne())) + ) ) } func testAwaitSwitch3() { @@ -950,7 +1073,148 @@ final class StatementExpressionTests: XCTestCase { let x = await switch Bool.random() { case true: 0 case false: 1 } return x } + """, + substructure: Syntax( + AwaitExprSyntax(expression: switchRandomZeroOne()) + ) + ) + } + func testIfExprMultipleCoerce() { + // We only allow coercions as a narrow case in the parser, so attempting to + // double them up is invalid. + AssertParse( """ + func foo() { + if .random() { 0 } else { 1 } as Int 1️⃣as Int + } + """, + diagnostics: [ + DiagnosticSpec(message: "unexpected code 'as Int' in function") + ] + ) + } + func testIfExprIs() { + // We don't parse 'is Int'. + AssertParse( + """ + func foo() -> Bool { + if .random() { 0 } else { 1 } 1️⃣is Int + } + """, + diagnostics: [ + DiagnosticSpec(message: "unexpected code 'is Int' in function") + ] + ) + } + func testIfExprCondCast() { + // We parse 'as? Int', but it will be a semantic error. + AssertParse( + """ + if .random() { 0 } else { 1 } as? Int + """, + substructure: Syntax( + SequenceExprSyntax( + elements: ExprListSyntax([ + ifZeroElseOne(), + ExprSyntax( + UnresolvedAsExprSyntax(questionOrExclamationMark: .postfixQuestionMarkToken()) + ), + ExprSyntax( + TypeExprSyntax(type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("Int")))) + ), + ]) + ) + ) + ) + } + func testIfExprForceCast() { + // We parse 'as! Int', but it will be a semantic error. + AssertParse( + """ + if .random() { 0 } else { 1 } as! Int + """, + substructure: Syntax( + SequenceExprSyntax( + elements: ExprListSyntax([ + ifZeroElseOne(), + ExprSyntax( + UnresolvedAsExprSyntax(questionOrExclamationMark: .exclamationMarkToken()) + ), + ExprSyntax( + TypeExprSyntax(type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("Int")))) + ), + ]) + ) + ) + ) + } + func testSwitchExprMultipleCoerce() { + // We only allow coercions as a narrow case in the parser, so attempting to + // double them up is invalid. + AssertParse( + """ + func foo() { + switch Bool.random() { case true: 0 case false: 1 } as Int 1️⃣as Int + } + """, + diagnostics: [ + DiagnosticSpec(message: "unexpected code 'as Int' in function") + ] + ) + } + func testSwitchExprIs() { + // We don't parse 'is Int'. + AssertParse( + """ + func foo() -> Bool { + switch Bool.random() { case true: 0 case false: 1 } 1️⃣is Int + } + """, + diagnostics: [ + DiagnosticSpec(message: "unexpected code 'is Int' in function") + ] + ) + } + func testSwitchExprCondCast() { + // We parse 'as? Int', but it will be a semantic error. + AssertParse( + """ + switch Bool.random() { case true: 0 case false: 1 } as? Int + """, + substructure: Syntax( + SequenceExprSyntax( + elements: ExprListSyntax([ + switchRandomZeroOne(), + ExprSyntax( + UnresolvedAsExprSyntax(questionOrExclamationMark: .postfixQuestionMarkToken()) + ), + ExprSyntax( + TypeExprSyntax(type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("Int")))) + ), + ]) + ) + ) + ) + } + func testSwitchExprForceCast() { + // We parse 'as! Int', but it will be a semantic error. + AssertParse( + """ + switch Bool.random() { case true: 0 case false: 1 } as! Int + """, + substructure: Syntax( + SequenceExprSyntax( + elements: ExprListSyntax([ + switchRandomZeroOne(), + ExprSyntax( + UnresolvedAsExprSyntax(questionOrExclamationMark: .exclamationMarkToken()) + ), + ExprSyntax( + TypeExprSyntax(type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("Int")))) + ), + ]) + ) + ) ) } } diff --git a/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift b/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift index 5d381d764b6..3f284c3b452 100644 --- a/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift +++ b/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift @@ -17,13 +17,12 @@ import SwiftSyntaxBuilder import XCTest import _SwiftSyntaxTestSupport -@discardableResult -func testRefactorIfLet( +func AssertRefactorIfLet( _ syntax: ExprSyntax, expected: ExprSyntax, file: StaticString = #file, line: UInt = #line -) throws -> ExprSyntax { +) throws { let ifExpr = try XCTUnwrap( syntax.as(IfExprSyntax.self), file: file, @@ -36,8 +35,12 @@ func testRefactorIfLet( line: line ) - AssertStringsEqualWithDiff(expected.description, refactored.description) - return ExprSyntax(refactored) + AssertStringsEqualWithDiff( + expected.description, + refactored.description, + file: file, + line: line + ) } final class MigrateToNewIfLetSyntaxTest: XCTestCase { @@ -50,7 +53,7 @@ final class MigrateToNewIfLetSyntaxTest: XCTestCase { if let x {} """ - try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try AssertRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testIdempotence() throws { @@ -62,8 +65,8 @@ final class MigrateToNewIfLetSyntaxTest: XCTestCase { if let x {} """ - let refactored = try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) - try testRefactorIfLet(refactored, expected: expectedSyntax) + try AssertRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try AssertRefactorIfLet(expectedSyntax, expected: expectedSyntax) } func testMultiBinding() throws { @@ -75,7 +78,7 @@ final class MigrateToNewIfLetSyntaxTest: XCTestCase { if let x, var y, let z {} """ - try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try AssertRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testMixedBinding() throws { @@ -87,7 +90,7 @@ final class MigrateToNewIfLetSyntaxTest: XCTestCase { if let x, var y = x, let z = y.w {} """ - try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try AssertRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testConditions() throws { @@ -99,7 +102,7 @@ final class MigrateToNewIfLetSyntaxTest: XCTestCase { if let x = x + 1, x == x, !x {} """ - try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try AssertRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testWhitespaceNormalization() throws { @@ -111,7 +114,7 @@ final class MigrateToNewIfLetSyntaxTest: XCTestCase { if let x, let y {} """ - try testRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try AssertRefactorIfLet(baselineSyntax, expected: expectedSyntax) } func testIfStmt() throws { @@ -124,6 +127,6 @@ final class MigrateToNewIfLetSyntaxTest: XCTestCase { """ let exprStmt = try XCTUnwrap(baselineSyntax.as(ExpressionStmtSyntax.self)) - try testRefactorIfLet(exprStmt.expression, expected: expectedSyntax) + try AssertRefactorIfLet(exprStmt.expression, expected: expectedSyntax) } }