diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift index 83ac47352a8..8a252dc90d8 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift @@ -362,6 +362,122 @@ public let EXPR_NODES: [Node] = [ kind: .token(choices: [.keyword(text: "true"), .keyword(text: "false")])) ]), + Node(name: "IfExpr", + nameForDiagnostics: "'if' statement", + kind: "Expr", + traits: [ + "WithCodeBlock" + ], + children: [ + Child(name: "IfKeyword", + kind: .token(choices: [.keyword(text: "if")])), + Child(name: "Conditions", + kind: .collection(kind: "ConditionElementList", collectionElementName: "Condition")), + Child(name: "Body", + kind: .node(kind: "CodeBlock")), + Child(name: "ElseKeyword", + kind: .node(kind: "ElseToken"), + isOptional: true), + Child(name: "ElseBody", + kind: .nodeChoices(choices: [ + Child(name: "IfExpr", + kind: .node(kind: "IfExpr")), + Child(name: "CodeBlock", + kind: .node(kind: "CodeBlock")) + ]), + isOptional: true) + ]), + + Node(name: "SwitchExpr", + nameForDiagnostics: "'switch' statement", + kind: "Expr", + traits: [ + "Braced" + ], + children: [ + Child(name: "SwitchKeyword", + kind: .token(choices: [.keyword(text: "switch")])), + Child(name: "Expression", + kind: .node(kind: "Expr")), + Child(name: "LeftBrace", + kind: .token(choices: [.token(tokenKind: "LeftBraceToken")])), + Child(name: "Cases", + kind: .collection(kind: "SwitchCaseList", collectionElementName: "Case")), + Child(name: "RightBrace", + kind: .token(choices: [.token(tokenKind: "RightBraceToken")]), + 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: .node(kind: "Attribute"), + isOptional: true), + Child(name: "Label", + kind: .nodeChoices(choices: [ + Child(name: "Default", + kind: .node(kind: "SwitchDefaultLabel")), + Child(name: "Case", + kind: .node(kind: "SwitchCaseLabel")) + ])), + Child(name: "Statements", + kind: .collection(kind: "CodeBlockItemList", collectionElementName: "Statement"), + isIndented: true) + ]), + + Node(name: "SwitchCaseLabel", + nameForDiagnostics: nil, + kind: "Syntax", + children: [ + Child(name: "CaseKeyword", + kind: .token(choices: [.keyword(text: "case")])), + Child(name: "CaseItems", + kind: .collection(kind: "CaseItemList", collectionElementName: "CaseItem")), + Child(name: "Colon", + kind: .token(choices: [.token(tokenKind: "ColonToken")])) + ]), + + Node(name: "SwitchDefaultLabel", + nameForDiagnostics: nil, + kind: "Syntax", + children: [ + Child(name: "DefaultKeyword", + kind: .token(choices: [.keyword(text: "default")])), + Child(name: "Colon", + kind: .token(choices: [.token(tokenKind: "ColonToken")])) + ]), + + Node(name: "CaseItem", + nameForDiagnostics: nil, + kind: "Syntax", + traits: [ + "WithTrailingComma" + ], + children: [ + Child(name: "Pattern", + kind: .node(kind: "Pattern")), + Child(name: "WhereClause", + kind: .node(kind: "WhereClause"), + isOptional: true), + Child(name: "TrailingComma", + kind: .token(choices: [.token(tokenKind: "CommaToken")]), + isOptional: true) + ]), + Node(name: "UnresolvedTernaryExpr", nameForDiagnostics: "ternary operator", kind: "Expr", diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift index c772aff8aaf..bda4fb5193b 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift @@ -25,6 +25,14 @@ public let STMT_NODES: [Node] = [ kind: .node(kind: "Stmt")) ]), + Node(name: "ExpressionStmt", + nameForDiagnostics: "expression", + kind: "Stmt", + children: [ + Child(name: "Expression", + kind: .node(kind: "Expr")) + ]), + Node(name: "ContinueStmt", nameForDiagnostics: "'continue' statement", kind: "Stmt", @@ -64,14 +72,6 @@ public let STMT_NODES: [Node] = [ kind: .node(kind: "CodeBlock")) ]), - Node(name: "SwitchCaseList", - nameForDiagnostics: nil, - kind: "SyntaxCollection", - element: "Syntax", - elementName: "SwitchCase", - elementChoices: ["SwitchCase", "IfConfigDecl"], - elementsSeparatedByNewline: true), - Node(name: "RepeatWhileStmt", nameForDiagnostics: "'repeat' statement", kind: "Stmt", @@ -151,26 +151,6 @@ public let STMT_NODES: [Node] = [ kind: .node(kind: "CodeBlock")) ]), - Node(name: "SwitchStmt", - nameForDiagnostics: "'switch' statement", - kind: "Stmt", - traits: [ - "Braced" - ], - children: [ - Child(name: "SwitchKeyword", - kind: .token(choices: [.keyword(text: "switch")])), - Child(name: "Expression", - kind: .node(kind: "Expr")), - Child(name: "LeftBrace", - kind: .token(choices: [.token(tokenKind: "LeftBraceToken")])), - Child(name: "Cases", - kind: .collection(kind: "SwitchCaseList", collectionElementName: "Case")), - Child(name: "RightBrace", - kind: .token(choices: [.token(tokenKind: "RightBraceToken")]), - requiresLeadingNewline: true) - ]), - Node(name: "CatchClauseList", nameForDiagnostics: "'catch' clause", kind: "SyntaxCollection", @@ -342,82 +322,6 @@ public let STMT_NODES: [Node] = [ kind: .node(kind: "Expr")) ]), - Node(name: "IfStmt", - nameForDiagnostics: "'if' statement", - kind: "Stmt", - traits: [ - "WithCodeBlock" - ], - children: [ - Child(name: "IfKeyword", - kind: .token(choices: [.keyword(text: "if")])), - Child(name: "Conditions", - kind: .collection(kind: "ConditionElementList", collectionElementName: "Condition")), - Child(name: "Body", - kind: .node(kind: "CodeBlock")), - Child(name: "ElseKeyword", - kind: .node(kind: "ElseToken"), - isOptional: true), - Child(name: "ElseBody", - kind: .nodeChoices(choices: [ - Child(name: "IfStmt", - kind: .node(kind: "IfStmt")), - Child(name: "CodeBlock", - kind: .node(kind: "CodeBlock")) - ]), - isOptional: true) - ]), - - Node(name: "SwitchCase", - nameForDiagnostics: "switch case", - kind: "Syntax", - traits: [ - "WithStatements" - ], - parserFunction: "parseSwitchCase", - children: [ - Child(name: "UnknownAttr", - kind: .node(kind: "Attribute"), - isOptional: true), - Child(name: "Label", - kind: .nodeChoices(choices: [ - Child(name: "Default", - kind: .node(kind: "SwitchDefaultLabel")), - Child(name: "Case", - kind: .node(kind: "SwitchCaseLabel")) - ])), - Child(name: "Statements", - kind: .collection(kind: "CodeBlockItemList", collectionElementName: "Statement"), - isIndented: true) - ]), - - Node(name: "SwitchDefaultLabel", - nameForDiagnostics: nil, - kind: "Syntax", - children: [ - Child(name: "DefaultKeyword", - kind: .token(choices: [.keyword(text: "default")])), - Child(name: "Colon", - kind: .token(choices: [.token(tokenKind: "ColonToken")])) - ]), - - Node(name: "CaseItem", - nameForDiagnostics: nil, - kind: "Syntax", - traits: [ - "WithTrailingComma" - ], - children: [ - Child(name: "Pattern", - kind: .node(kind: "Pattern")), - Child(name: "WhereClause", - kind: .node(kind: "WhereClause"), - isOptional: true), - Child(name: "TrailingComma", - kind: .token(choices: [.token(tokenKind: "CommaToken")]), - isOptional: true) - ]), - Node(name: "CatchItem", nameForDiagnostics: nil, kind: "Syntax", @@ -436,18 +340,6 @@ public let STMT_NODES: [Node] = [ isOptional: true) ]), - Node(name: "SwitchCaseLabel", - nameForDiagnostics: nil, - kind: "Syntax", - children: [ - Child(name: "CaseKeyword", - kind: .token(choices: [.keyword(text: "case")])), - Child(name: "CaseItems", - kind: .collection(kind: "CaseItemList", collectionElementName: "CaseItem")), - Child(name: "Colon", - kind: .token(choices: [.token(tokenKind: "ColonToken")])) - ]), - Node(name: "CatchClause", nameForDiagnostics: "'catch' clause", kind: "Syntax", diff --git a/Sources/SwiftBasicFormat/generated/BasicFormat.swift b/Sources/SwiftBasicFormat/generated/BasicFormat.swift index a836cc6168c..4b43a8ea803 100644 --- a/Sources/SwiftBasicFormat/generated/BasicFormat.swift +++ b/Sources/SwiftBasicFormat/generated/BasicFormat.swift @@ -114,7 +114,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/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 10b637c2b55..aedabcc5374 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -18,6 +18,11 @@ extension TokenConsumer { case (.awaitTryMove, let handle)?: var backtrack = self.lookahead() backtrack.eat(handle) + + // These can be parsed as expressions with try/await. + if backtrack.at(anyIn: IfOrSwitch.self) != nil { + return true + } if backtrack.atStartOfDeclaration() || backtrack.atStartOfStatement() { // If after the 'try' we are at a declaration or statement, it can't be a valid expression. // Decide how we want to consume the 'try': @@ -202,6 +207,30 @@ extension Parser { ) } + /// Parse an unresolved 'as' expression. + /// + /// type-casting-operator → 'as' type + /// type-casting-operator → 'as' '?' type + /// type-casting-operator → 'as' '!' type + /// + mutating func parseUnresolvedAsExpr( + handle: TokenConsumptionHandle + ) -> (operator: RawExprSyntax, rhs: RawExprSyntax) { + let asKeyword = self.eat(handle) + let failable = self.consume(ifAny: [.postfixQuestionMark, .exclamationMark]) + let op = RawUnresolvedAsExprSyntax( + asTok: asKeyword, + questionOrExclamationMark: failable, + arena: self.arena + ) + + // Parse the right type expression operand as part of the 'as' production. + let type = self.parseType() + let rhs = RawTypeExprSyntax(type: type, arena: self.arena) + + return (RawExprSyntax(op), RawExprSyntax(rhs)) + } + /// Parse an expression sequence operators. /// /// Returns `nil` if the current token is not at an operator. @@ -324,19 +353,7 @@ extension Parser { return (RawExprSyntax(op), RawExprSyntax(rhs)) case (.asKeyword, let handle)?: - let asKeyword = self.eat(handle) - let failable = self.consume(ifAny: [.postfixQuestionMark, .exclamationMark]) - let op = RawUnresolvedAsExprSyntax( - asTok: asKeyword, - questionOrExclamationMark: failable, - arena: self.arena - ) - - // Parse the right type expression operand as part of the 'as' production. - let type = self.parseType() - let rhs = RawTypeExprSyntax(type: type, arena: self.arena) - - return (RawExprSyntax(op), RawExprSyntax(rhs)) + return parseUnresolvedAsExpr(handle: handle) case (.async, _)?: if self.peek().rawTokenKind == .arrow || self.peek().rawTokenKind == .keyword(.throws) { @@ -477,11 +494,25 @@ extension Parser { // First check to see if we have the start of a regex literal `/.../`. // tryLexRegexLiteral(/*forUnappliedOperator*/ false) - // 'repeat' is the start of a pack expansion expression. - if (self.at(.keyword(.repeat))) { + switch self.currentToken.rawTokenKind { + case .keyword(.repeat): + // 'repeat' is the start of a pack expansion expression. + return RawExprSyntax(parsePackExpansionExpr(flavor, pattern: pattern)) + + // 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. + case .keyword(.switch): + return RawExprSyntax( + parseSwitchExpression(switchHandle: .constant(.keyword(.switch))) + ) + case .keyword(.if): return RawExprSyntax( - parsePackExpansionExpr(flavor, pattern: pattern) + parseIfExpression(ifHandle: .constant(.keyword(.if))) ) + default: + break } switch self.at(anyIn: ExpressionPrefixOperator.self) { @@ -2038,6 +2069,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: @@ -2099,6 +2135,335 @@ extension Parser.Lookahead { } } +// MARK: Conditional Expressions + +extension Parser { + /// Parse an if statement/expression. + /// + /// Grammar + /// ======= + /// + /// if-expression → 'if' condition-list code-block else-clause? + /// else-clause → 'else' code-block | else if-statement + @_spi(RawSyntax) + public mutating func parseIfExpression( + ifHandle: RecoveryConsumptionHandle + ) -> RawIfExprSyntax { + let (unexpectedBeforeIfKeyword, ifKeyword) = self.eat(ifHandle) + // A scope encloses the condition and true branch for any variables bound + // by a conditional binding. The else branch does *not* see these variables. + let conditions = self.parseConditionList() + let body = self.parseCodeBlock(introducer: ifKeyword) + + // The else branch, if any, is outside of the scope of the condition. + let elseKeyword = self.consume(if: .keyword(.else)) + let elseBody: RawIfExprSyntax.ElseBody? + if elseKeyword != nil { + if self.at(.keyword(.if)) { + elseBody = .ifExpr( + self.parseIfExpression(ifHandle: .constant(.keyword(.if))) + ) + } else { + elseBody = .codeBlock(self.parseCodeBlock(introducer: ifKeyword)) + } + } else { + elseBody = nil + } + + return RawIfExprSyntax( + unexpectedBeforeIfKeyword, + ifKeyword: ifKeyword, + conditions: conditions, + body: body, + elseKeyword: elseKeyword, + elseBody: elseBody, + arena: self.arena + ) + } +} + +// MARK: Switch Statements/Expressions + +extension Parser { + /// Parse a switch statement/expression. + /// + /// Grammar + /// ======= + /// + /// switch-expression → 'switch' expression '{' switch-cases? '}' + /// switch-cases → switch-case switch-cases? + @_spi(RawSyntax) + public mutating func parseSwitchExpression( + switchHandle: RecoveryConsumptionHandle + ) -> RawSwitchExprSyntax { + let (unexpectedBeforeSwitchKeyword, switchKeyword) = self.eat(switchHandle) + + let subject = self.parseExpression(.basic) + let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace) + + let cases = self.parseSwitchCases(allowStandaloneStmtRecovery: !lbrace.isMissing) + + let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: switchKeyword) + return RawSwitchExprSyntax( + unexpectedBeforeSwitchKeyword, + switchKeyword: switchKeyword, + expression: subject, + unexpectedBeforeLBrace, + leftBrace: lbrace, + cases: cases, + unexpectedBeforeRBrace, + rightBrace: rbrace, + arena: self.arena + ) + } + + /// Parse a list of switch case clauses. + /// + /// Grammar + /// ======= + /// + /// switch-cases → switch-case switch-cases? + /// + /// If `allowStandaloneStmtRecovery` is `true` and we discover a statement that + /// isn't covered by a case, we assume that the developer forgot to wrote the + /// `case` and synthesize it. If `allowStandaloneStmtOrDeclRecovery` is `false`, + /// this recovery is disabled. + @_spi(RawSyntax) + public mutating func parseSwitchCases(allowStandaloneStmtRecovery: Bool) -> RawSwitchCaseListSyntax { + var elements = [RawSwitchCaseListSyntax.Element]() + var elementsProgress = LoopProgressCondition() + while !self.at(any: [.eof, .rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword]) + && elementsProgress.evaluate(currentToken) + { + if self.withLookahead({ $0.isAtStartOfSwitchCase(allowRecovery: false) }) { + elements.append(.switchCase(self.parseSwitchCase())) + } else if self.canRecoverTo(.poundIfKeyword) != nil { + // '#if' in 'case' position can enclose zero or more 'case' or 'default' + // clauses. + elements.append( + .ifConfigDecl( + self.parsePoundIfDirective( + { $0.parseSwitchCases(allowStandaloneStmtRecovery: allowStandaloneStmtRecovery) }, + syntax: { parser, cases in + guard cases.count == 1, let firstCase = cases.first else { + assert(cases.isEmpty) + return .switchCases(RawSwitchCaseListSyntax(elements: [], arena: parser.arena)) + } + return .switchCases(firstCase) + } + ) + ) + ) + } else if allowStandaloneStmtRecovery && (self.atStartOfExpression() || self.atStartOfStatement() || self.atStartOfDeclaration()) { + // Synthesize a label for the stamenent or declaration that isn't coverd by a case right now. + let statements = parseSwitchCaseBody() + elements.append( + .switchCase( + RawSwitchCaseSyntax( + unknownAttr: nil, + label: .case( + RawSwitchCaseLabelSyntax( + caseKeyword: missingToken(.keyword(.case), text: nil), + caseItems: RawCaseItemListSyntax( + elements: [ + RawCaseItemSyntax( + pattern: RawPatternSyntax( + RawIdentifierPatternSyntax( + identifier: missingToken(.identifier, text: nil), + arena: self.arena + ) + ), + whereClause: nil, + trailingComma: nil, + arena: self.arena + ) + ], + arena: self.arena + ), + colon: missingToken(.colon, text: nil), + arena: self.arena + ) + ), + statements: statements, + arena: self.arena + ) + ) + ) + } else if self.withLookahead({ $0.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.withLookahead({ $0.isStartOfConditionalSwitchCases() }), + let newItem = self.parseCodeBlockItem(), + loopProgress.evaluate(currentToken) + { + items.append(newItem) + } + return RawCodeBlockItemListSyntax(elements: items, arena: self.arena) + } + + /// Parse a single switch case clause. + /// + /// Grammar + /// ======= + /// + /// switch-case → case-label statements + /// switch-case → default-label statements + /// switch-case → conditional-switch-case + @_spi(RawSyntax) + public mutating func parseSwitchCase() -> RawSwitchCaseSyntax { + var unknownAttr: RawAttributeSyntax? + if let at = self.consume(if: .atSign) { + let (unexpectedBeforeIdent, ident) = self.expectIdentifier() + + unknownAttr = RawAttributeSyntax( + atSignToken: at, + unexpectedBeforeIdent, + attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: ident, genericArgumentClause: nil, arena: self.arena)), + leftParen: nil, + argument: nil, + rightParen: nil, + arena: self.arena + ) + } else { + unknownAttr = nil + } + + let label: RawSwitchCaseSyntax.Label + switch self.canRecoverTo(anyIn: SwitchCaseStart.self) { + case (.caseKeyword, let handle)?: + label = .case(self.parseSwitchCaseLabel(handle)) + case (.defaultKeyword, let handle)?: + label = .default(self.parseSwitchDefaultLabel(handle)) + case nil: + label = .case( + RawSwitchCaseLabelSyntax( + caseKeyword: missingToken(.keyword(.case)), + caseItems: RawCaseItemListSyntax( + elements: [ + RawCaseItemSyntax( + pattern: RawPatternSyntax(RawIdentifierPatternSyntax(identifier: missingToken(.identifier), arena: self.arena)), + whereClause: nil, + trailingComma: nil, + arena: self.arena + ) + ], + arena: self.arena + ), + colon: missingToken(.colon), + arena: self.arena + ) + ) + } + + // Parse the body. + let statements = parseSwitchCaseBody() + + return RawSwitchCaseSyntax( + unknownAttr: unknownAttr, + label: label, + statements: statements, + arena: self.arena + ) + } + + /// Parse a switch case with a 'case' label. + /// + /// Grammar + /// ======= + /// + /// case-label → attributes? case case-item-list ':' + /// case-item-list → pattern where-clause? | pattern where-clause? ',' case-item-list + @_spi(RawSyntax) + public mutating func parseSwitchCaseLabel( + _ handle: RecoveryConsumptionHandle + ) -> RawSwitchCaseLabelSyntax { + let (unexpectedBeforeCaseKeyword, caseKeyword) = self.eat(handle) + var caseItems = [RawCaseItemSyntax]() + do { + var keepGoing: RawTokenSyntax? = nil + var loopProgress = LoopProgressCondition() + repeat { + let (pattern, whereClause) = self.parseGuardedCasePattern() + keepGoing = self.consume(if: .comma) + caseItems.append( + RawCaseItemSyntax( + pattern: pattern, + whereClause: whereClause, + trailingComma: keepGoing, + arena: self.arena + ) + ) + } while keepGoing != nil && loopProgress.evaluate(currentToken) + } + let (unexpectedBeforeColon, colon) = self.expect(.colon) + return RawSwitchCaseLabelSyntax( + unexpectedBeforeCaseKeyword, + caseKeyword: caseKeyword, + caseItems: RawCaseItemListSyntax(elements: caseItems, arena: self.arena), + unexpectedBeforeColon, + colon: colon, + arena: self.arena + ) + } + + /// Parse a switch case with a 'default' label. + /// + /// Grammar + /// ======= + /// + /// default-label → attributes? 'default' ':' + @_spi(RawSyntax) + public mutating func parseSwitchDefaultLabel( + _ handle: RecoveryConsumptionHandle + ) -> RawSwitchDefaultLabelSyntax { + let (unexpectedBeforeDefaultKeyword, defaultKeyword) = self.eat(handle) + let (unexpectedBeforeColon, colon) = self.expect(.colon) + return RawSwitchDefaultLabelSyntax( + unexpectedBeforeDefaultKeyword, + defaultKeyword: defaultKeyword, + unexpectedBeforeColon, + colon: colon, + arena: self.arena + ) + } + + /// Parse a pattern-matching clause for a case statement, + /// including the guard expression. + /// + /// Grammar + /// ======= + /// + /// case-item → pattern where-clause? + mutating func parseGuardedCasePattern() -> (RawPatternSyntax, RawWhereClauseSyntax?) { + let pattern = self.parseMatchingPattern(context: .matching) + + // Parse the optional 'where' guard, with this particular pattern's bound + // vars in scope. + let whereClause: RawWhereClauseSyntax? + if let whereKeyword = self.consume(if: .keyword(.where)) { + let guardExpr = self.parseExpression(.trailingClosure) + whereClause = RawWhereClauseSyntax( + whereKeyword: whereKeyword, + guardResult: guardExpr, + arena: self.arena + ) + } else { + whereClause = nil + } + return (pattern, whereClause) + } +} + // MARK: Lookahead extension Parser.Lookahead { diff --git a/Sources/SwiftParser/RawTokenKindSubset.swift b/Sources/SwiftParser/RawTokenKindSubset.swift index 43600da901f..c0de58f19a4 100644 --- a/Sources/SwiftParser/RawTokenKindSubset.swift +++ b/Sources/SwiftParser/RawTokenKindSubset.swift @@ -581,6 +581,26 @@ enum AwaitTryMove: RawTokenKindSubset { } } +enum IfOrSwitch: RawTokenKindSubset { + case ifKeyword + case switchKeyword + + init?(lexeme: Lexer.Lexeme) { + switch lexeme { + case RawTokenKindMatch(.if): self = .ifKeyword + case RawTokenKindMatch(.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 @@ -746,6 +766,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) { @@ -756,6 +777,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 } @@ -766,6 +789,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 { @@ -774,6 +798,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 } } } diff --git a/Sources/SwiftParser/Statements.swift b/Sources/SwiftParser/Statements.swift index 0c5f84693b6..8c6b4fb7a0c 100644 --- a/Sources/SwiftParser/Statements.swift +++ b/Sources/SwiftParser/Statements.swift @@ -102,11 +102,21 @@ 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)?: - 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)?: @@ -132,47 +142,6 @@ extension Parser { // MARK: Conditional Statements -extension Parser { - /// Parse an if statement. - /// - /// Grammar - /// ======= - /// - /// if-statement → 'if' condition-list code-block else-clause? - /// else-clause → 'else' code-block | else if-statement - @_spi(RawSyntax) - public mutating func parseIfStatement(ifHandle: RecoveryConsumptionHandle) -> RawIfStmtSyntax { - let (unexpectedBeforeIfKeyword, ifKeyword) = self.eat(ifHandle) - // A scope encloses the condition and true branch for any variables bound - // by a conditional binding. The else branch does *not* see these variables. - let conditions = self.parseConditionList() - let body = self.parseCodeBlock(introducer: ifKeyword) - - // The else branch, if any, is outside of the scope of the condition. - let elseKeyword = self.consume(if: .keyword(.else)) - let elseBody: RawIfStmtSyntax.ElseBody? - if elseKeyword != nil { - if self.at(.keyword(.if)) { - elseBody = .ifStmt(self.parseIfStatement(ifHandle: .constant(.keyword(.if)))) - } else { - elseBody = .codeBlock(self.parseCodeBlock(introducer: ifKeyword)) - } - } else { - elseBody = nil - } - - return RawIfStmtSyntax( - unexpectedBeforeIfKeyword, - ifKeyword: ifKeyword, - conditions: conditions, - body: body, - elseKeyword: elseKeyword, - elseBody: elseBody, - arena: self.arena - ) - } -} - extension Parser { /// Parse a guard statement. /// @@ -656,289 +625,27 @@ extension Parser { } } -// MARK: Switch Statements +// MARK: Control Transfer 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.withLookahead({ $0.isAtStartOfSwitchCase(allowRecovery: false) }) { - elements.append(.switchCase(self.parseSwitchCase())) - } else if self.canRecoverTo(.poundIfKeyword) != nil { - // '#if' in 'case' position can enclose zero or more 'case' or 'default' - // clauses. - elements.append( - .ifConfigDecl( - self.parsePoundIfDirective( - { $0.parseSwitchCases(allowStandaloneStmtRecovery: allowStandaloneStmtRecovery) }, - syntax: { parser, cases in - guard cases.count == 1, let firstCase = cases.first else { - assert(cases.isEmpty) - return .switchCases(RawSwitchCaseListSyntax(elements: [], arena: parser.arena)) - } - return .switchCases(firstCase) - } - ) - ) - ) - } else if allowStandaloneStmtRecovery && (self.atStartOfExpression() || self.atStartOfStatement() || self.atStartOfDeclaration()) { - // Synthesize a label for the stamenent or declaration that isn't coverd by a case right now. - let statements = parseSwitchCaseBody() - elements.append( - .switchCase( - RawSwitchCaseSyntax( - unknownAttr: nil, - label: .case( - RawSwitchCaseLabelSyntax( - caseKeyword: missingToken(.keyword(.case), text: nil), - caseItems: RawCaseItemListSyntax( - elements: [ - RawCaseItemSyntax( - pattern: RawPatternSyntax( - RawIdentifierPatternSyntax( - identifier: missingToken(.identifier, text: nil), - arena: self.arena - ) - ), - whereClause: nil, - trailingComma: nil, - arena: self.arena - ) - ], - arena: self.arena - ), - colon: missingToken(.colon, text: nil), - arena: self.arena - ) - ), - statements: statements, - arena: self.arena - ) - ) - ) - } else if self.withLookahead({ $0.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.withLookahead({ $0.isStartOfConditionalSwitchCases() }), - let newItem = self.parseCodeBlockItem(), - loopProgress.evaluate(currentToken) - { - items.append(newItem) - } - return RawCodeBlockItemListSyntax(elements: items, arena: self.arena) - } - - /// Parse a single switch case clause. - /// - /// Grammar - /// ======= - /// - /// switch-case → case-label statements - /// switch-case → default-label statements - /// switch-case → conditional-switch-case - @_spi(RawSyntax) - public mutating func parseSwitchCase() -> RawSwitchCaseSyntax { - var unknownAttr: RawAttributeSyntax? - if let at = self.consume(if: .atSign) { - let (unexpectedBeforeIdent, ident) = self.expectIdentifier() - - unknownAttr = RawAttributeSyntax( - atSignToken: at, - unexpectedBeforeIdent, - attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: ident, genericArgumentClause: nil, arena: self.arena)), - leftParen: nil, - argument: nil, - rightParen: nil, - arena: self.arena - ) - } else { - unknownAttr = nil - } - - let label: RawSwitchCaseSyntax.Label - switch self.canRecoverTo(anyIn: SwitchCaseStart.self) { - case (.caseKeyword, let handle)?: - label = .case(self.parseSwitchCaseLabel(handle)) - case (.defaultKeyword, let handle)?: - label = .default(self.parseSwitchDefaultLabel(handle)) - case nil: - label = .case( - RawSwitchCaseLabelSyntax( - caseKeyword: missingToken(.keyword(.case)), - caseItems: RawCaseItemListSyntax( - elements: [ - RawCaseItemSyntax( - pattern: RawPatternSyntax(RawIdentifierPatternSyntax(identifier: missingToken(.identifier), arena: self.arena)), - whereClause: nil, - trailingComma: nil, - arena: self.arena - ) - ], - arena: self.arena - ), - colon: missingToken(.colon), - arena: self.arena - ) - ) + private mutating func isStartOfReturnExpr() -> Bool { + if self.at(any: [ + .rightBrace, .keyword(.case), .keyword(.default), .semicolon, .eof, + .poundIfKeyword, .poundEndifKeyword, .poundElseKeyword, + .poundElseifKeyword, + ]) { + return false } - - // 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) + // Allowed for if/switch expressions. + if self.at(anyIn: IfOrSwitch.self) != nil { + return true } - let (unexpectedBeforeColon, colon) = self.expect(.colon) - return RawSwitchCaseLabelSyntax( - unexpectedBeforeCaseKeyword, - caseKeyword: caseKeyword, - caseItems: RawCaseItemListSyntax(elements: caseItems, arena: self.arena), - unexpectedBeforeColon, - colon: colon, - arena: self.arena - ) - } - - /// Parse a switch case with a 'default' label. - /// - /// Grammar - /// ======= - /// - /// default-label → attributes? 'default' ':' - @_spi(RawSyntax) - public mutating func parseSwitchDefaultLabel( - _ handle: RecoveryConsumptionHandle - ) -> RawSwitchDefaultLabelSyntax { - let (unexpectedBeforeDefaultKeyword, defaultKeyword) = self.eat(handle) - let (unexpectedBeforeColon, colon) = self.expect(.colon) - return RawSwitchDefaultLabelSyntax( - unexpectedBeforeDefaultKeyword, - defaultKeyword: defaultKeyword, - unexpectedBeforeColon, - colon: colon, - arena: self.arena - ) - } - - /// Parse a pattern-matching clause for a case statement, - /// including the guard expression. - /// - /// Grammar - /// ======= - /// - /// case-item → pattern where-clause? - mutating func parseGuardedCasePattern() -> (RawPatternSyntax, RawWhereClauseSyntax?) { - let pattern = self.parseMatchingPattern(context: .matching) - - // Parse the optional 'where' guard, with this particular pattern's bound - // vars in scope. - let whereClause: RawWhereClauseSyntax? - if let whereKeyword = self.consume(if: .keyword(.where)) { - let guardExpr = self.parseExpression(.trailingClosure) - whereClause = RawWhereClauseSyntax( - whereKeyword: whereKeyword, - guardResult: guardExpr, - arena: self.arena - ) - } else { - whereClause = nil + if self.atStartOfStatement() || self.atStartOfDeclaration() { + return false } - return (pattern, whereClause) + return true } -} - -// MARK: Control Transfer Statements -extension Parser { /// Parse a return statement /// /// Grammar @@ -954,13 +661,7 @@ extension Parser { // enclosing stmt-brace to get it by eagerly eating it unless the return is // followed by a '}', '', statement or decl start keyword sequence. let expr: RawExprSyntax? - if !self.at(any: [ - .rightBrace, .keyword(.case), .keyword(.default), .semicolon, .eof, - .poundIfKeyword, .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 48dc1961a07..833cc066161 100644 --- a/Sources/SwiftParser/TopLevel.swift +++ b/Sources/SwiftParser/TopLevel.swift @@ -189,6 +189,36 @@ 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 expr = stmt.as(RawExpressionStmtSyntax.self)?.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. @@ -222,13 +252,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/Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift b/Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift index 7419d987d51..7c3dfe93925 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.with(\.conditions, ConditionElementListSyntax(newConditions))) + return node.with(\.conditions, ConditionElementListSyntax(newConditions)) } } diff --git a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md index 9fb552ec00a..0035fd39ce8 100644 --- a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md @@ -84,20 +84,19 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- - - - - - - -- - - - - - - -- ### Expressions @@ -126,6 +125,8 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- - - - @@ -282,6 +283,11 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - +- +- +- +- +- - - - @@ -369,7 +375,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- - - - @@ -380,11 +385,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 b31eaea7f7a..4cde8800fea 100644 --- a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift +++ b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift @@ -65,7 +65,7 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .missingExpr, .inOutExpr, .tryExpr, .awaitExpr, .moveExpr, .borrowExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packExpansionExpr, .packElementExpr, .sequenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true + case .missingExpr, .inOutExpr, .tryExpr, .awaitExpr, .moveExpr, .borrowExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packExpansionExpr, .packElementExpr, .sequenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ifExpr, .switchExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true default: return false } } @@ -96,7 +96,7 @@ public struct RawStmtSyntax: RawStmtSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .missingStmt, .labeledStmt, .continueStmt, .whileStmt, .deferStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .throwStmt, .ifStmt: return true + case .missingStmt, .labeledStmt, .expressionStmt, .continueStmt, .whileStmt, .deferStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .throwStmt: return true default: return false } } @@ -2830,7 +2830,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 { @@ -2838,7 +2867,7 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedTernaryExpr + return raw.kind == .ifExpr } public var raw: RawSyntax @@ -2853,56 +2882,75 @@ 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 ) { - assert(questionMark.tokenKind.base == .infixQuestionMark, "Received \(questionMark.tokenKind)") - assert(colonMark.tokenKind.base == .colon, "Received \(colonMark.tokenKind)") + assert(ifKeyword.tokenKind == .keyword(.if), "Received \(ifKeyword.tokenKind)") 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 { @@ -2910,7 +2958,7 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ternaryExpr + return raw.kind == .switchExpr } public var raw: RawSyntax @@ -2925,76 +2973,106 @@ 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 ) { - assert(questionMark.tokenKind.base == .infixQuestionMark, "Received \(questionMark.tokenKind)") - assert(colonMark.tokenKind.base == .colon, "Received \(colonMark.tokenKind)") + assert(switchKeyword.tokenKind == .keyword(.switch), "Received \(switchKeyword.tokenKind)") + assert(leftBrace.tokenKind.base == .leftBrace, "Received \(leftBrace.tokenKind)") + assert(rightBrace.tokenKind.base == .rightBrace, "Received \(rightBrace.tokenKind)") 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 { @@ -3002,7 +3080,7 @@ public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .memberAccessExpr + return raw.kind == .switchCaseList } public var raw: RawSyntax @@ -3016,66 +3094,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 - ) { - assert(dot.tokenKind.base == .period, "Received \(dot.tokenKind)") + 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 { @@ -3083,7 +3149,7 @@ public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedIsExpr + return raw.kind == .switchCase } public var raw: RawSyntax @@ -3098,35 +3164,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 ) { - assert(isTok.tokenKind == .keyword(.is), "Received \(isTok.tokenKind)") 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 { @@ -3134,7 +3219,7 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .isExpr + return raw.kind == .switchCaseLabel } public var raw: RawSyntax @@ -3149,55 +3234,56 @@ 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 ) { - assert(isTok.tokenKind == .keyword(.is), "Received \(isTok.tokenKind)") + assert(caseKeyword.tokenKind == .keyword(.case), "Received \(caseKeyword.tokenKind)") + assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") 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 { @@ -3205,7 +3291,7 @@ public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedAsExpr + return raw.kind == .switchDefaultLabel } public var raw: RawSyntax @@ -3220,46 +3306,46 @@ 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 ) { - assert(asTok.tokenKind == .keyword(.as), "Received \(asTok.tokenKind)") - assert(questionOrExclamationMark == nil || questionOrExclamationMark?.tokenKind.base == .postfixQuestionMark || questionOrExclamationMark?.tokenKind.base == .exclamationMark, "Received \(String(describing: questionOrExclamationMark?.tokenKind))") + assert(defaultKeyword.tokenKind == .keyword(.default), "Received \(defaultKeyword.tokenKind)") + assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") 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 { @@ -3267,7 +3353,7 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .asExpr + return raw.kind == .caseItem } public var raw: RawSyntax @@ -3282,66 +3368,55 @@ 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 ) { - assert(asTok.tokenKind == .keyword(.as), "Received \(asTok.tokenKind)") - assert(questionOrExclamationMark == nil || questionOrExclamationMark?.tokenKind.base == .postfixQuestionMark || questionOrExclamationMark?.tokenKind.base == .exclamationMark, "Received \(String(describing: questionOrExclamationMark?.tokenKind))") + assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") 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 { @@ -3349,7 +3424,7 @@ public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typeExpr + return raw.kind == .unresolvedTernaryExpr } public var raw: RawSyntax @@ -3364,34 +3439,56 @@ 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 ) { + assert(questionMark.tokenKind.base == .infixQuestionMark, "Received \(questionMark.tokenKind)") + assert(colonMark.tokenKind.base == .colon, "Received \(colonMark.tokenKind)") 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 RawClosureCaptureItemSpecifierSyntax: RawSyntaxNodeProtocol { +public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3399,7 +3496,7 @@ public struct RawClosureCaptureItemSpecifierSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureCaptureItemSpecifier + return raw.kind == .ternaryExpr } public var raw: RawSyntax @@ -3414,68 +3511,76 @@ public struct RawClosureCaptureItemSpecifierSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, - specifier: RawTokenSyntax, - _ unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax?, - _ unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? = nil, - detail: RawTokenSyntax?, - _ unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax?, - _ unexpectedAfterRightParen: 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 ) { - assert(specifier.tokenKind == .keyword(.weak) || specifier.tokenKind == .keyword(.unowned), "Received \(specifier.tokenKind)") - assert(leftParen == nil || leftParen?.tokenKind.base == .leftParen, "Received \(String(describing: leftParen?.tokenKind))") - assert(detail == nil || detail?.tokenKind == .keyword(.safe) || detail?.tokenKind == .keyword(.unsafe), "Received \(String(describing: detail?.tokenKind))") - assert(rightParen == nil || rightParen?.tokenKind.base == .rightParen, "Received \(String(describing: rightParen?.tokenKind))") + assert(questionMark.tokenKind.base == .infixQuestionMark, "Received \(questionMark.tokenKind)") + assert(colonMark.tokenKind.base == .colon, "Received \(colonMark.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .closureCaptureItemSpecifier, uninitializedCount: 9, 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] = unexpectedBetweenSpecifierAndLeftParen?.raw - layout[3] = leftParen?.raw - layout[4] = unexpectedBetweenLeftParenAndDetail?.raw - layout[5] = detail?.raw - layout[6] = unexpectedBetweenDetailAndRightParen?.raw - layout[7] = rightParen?.raw - layout[8] = unexpectedAfterRightParen?.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: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var conditionExpression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenConditionExpressionAndQuestionMark: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var questionMark: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var detail: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) + public var firstChoice: RawExprSyntax { + layoutView.children[5].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightParen: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) + public var colonMark: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenColonMarkAndSecondChoice: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var secondChoice: RawExprSyntax { + layoutView.children[9].map(RawExprSyntax.init(raw:))! + } + public var unexpectedAfterSecondChoice: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { +public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3483,7 +3588,7 @@ public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureCaptureItem + return raw.kind == .memberAccessExpr } public var raw: RawSyntax @@ -3498,77 +3603,65 @@ public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, - specifier: RawClosureCaptureItemSpecifierSyntax?, - _ unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax?, - _ unexpectedBetweenNameAndAssignToken: RawUnexpectedNodesSyntax? = nil, - assignToken: RawTokenSyntax?, - _ unexpectedBetweenAssignTokenAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: 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 ) { - assert(name == nil || name?.tokenKind.base == .identifier, "Received \(String(describing: name?.tokenKind))") - assert(assignToken == nil || assignToken?.tokenKind.base == .equal, "Received \(String(describing: assignToken?.tokenKind))") - assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") + assert(dot.tokenKind.base == .period, "Received \(dot.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .closureCaptureItem, uninitializedCount: 11, arena: arena) { layout in + kind: .memberAccessExpr, uninitializedCount: 9, 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] = 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 unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeBase: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var specifier: RawClosureCaptureItemSpecifierSyntax? { - layoutView.children[1].map(RawClosureCaptureItemSpecifierSyntax.init(raw:)) + public var base: RawExprSyntax? { + layoutView.children[1].map(RawExprSyntax.init(raw:)) } - public var unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenBaseAndDot: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var name: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var dot: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenNameAndAssignToken: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenDotAndName: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var assignToken: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) + public var name: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAssignTokenAndExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndDeclNameArguments: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[7].map(RawExprSyntax.init(raw:))! + public var declNameArguments: RawDeclNameArgumentsSyntax? { + layoutView.children[7].map(RawDeclNameArgumentsSyntax.init(raw:)) } - public var unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterDeclNameArguments: 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 RawClosureCaptureItemListSyntax: RawSyntaxNodeProtocol { +public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3576,7 +3669,7 @@ public struct RawClosureCaptureItemListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureCaptureItemList + return raw.kind == .unresolvedIsExpr } public var raw: RawSyntax @@ -3590,25 +3683,36 @@ public struct RawClosureCaptureItemListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawClosureCaptureItemSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? = nil, + isTok: RawTokenSyntax, + _ unexpectedAfterIsTok: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + assert(isTok.tokenKind == .keyword(.is), "Received \(isTok.tokenKind)") 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 - } + kind: .unresolvedIsExpr, uninitializedCount: 3, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeIsTok?.raw + layout[1] = isTok.raw + layout[2] = unexpectedAfterIsTok?.raw } self.init(raw: raw) } - public var elements: [RawClosureCaptureItemSyntax] { - layoutView.children.map { RawClosureCaptureItemSyntax(raw: $0!) } + public var unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var isTok: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterIsTok: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { +public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3616,7 +3720,7 @@ public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureCaptureSignature + return raw.kind == .isExpr } public var raw: RawSyntax @@ -3631,56 +3735,55 @@ public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? = nil, - leftSquare: RawTokenSyntax, - _ unexpectedBetweenLeftSquareAndItems: RawUnexpectedNodesSyntax? = nil, - items: RawClosureCaptureItemListSyntax?, - _ unexpectedBetweenItemsAndRightSquare: RawUnexpectedNodesSyntax? = nil, - rightSquare: RawTokenSyntax, - _ unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? = nil, + isTok: RawTokenSyntax, + _ unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? = nil, + typeName: RawTypeSyntax, + _ unexpectedAfterTypeName: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(leftSquare.tokenKind.base == .leftSquareBracket, "Received \(leftSquare.tokenKind)") - assert(rightSquare.tokenKind.base == .rightSquareBracket, "Received \(rightSquare.tokenKind)") + assert(isTok.tokenKind == .keyword(.is), "Received \(isTok.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .closureCaptureSignature, uninitializedCount: 7, arena: arena) { layout in + kind: .isExpr, uninitializedCount: 7, 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] = 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 unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftSquare: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenLeftSquareAndItems: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var items: RawClosureCaptureItemListSyntax? { - layoutView.children[3].map(RawClosureCaptureItemListSyntax.init(raw:)) + public var isTok: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenItemsAndRightSquare: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightSquare: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var typeName: RawTypeSyntax { + layoutView.children[5].map(RawTypeSyntax.init(raw:))! } - public var unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? { + public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { +public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3688,7 +3791,7 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureParam + return raw.kind == .unresolvedAsExpr } public var raw: RawSyntax @@ -3703,115 +3806,46 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAsTok: RawUnexpectedNodesSyntax? = nil, + asTok: RawTokenSyntax, + _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + questionOrExclamationMark: RawTokenSyntax?, + _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(name.tokenKind.base == .identifier || name.tokenKind.base == .wildcard, "Received \(name.tokenKind)") - assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") + assert(asTok.tokenKind == .keyword(.as), "Received \(asTok.tokenKind)") + assert(questionOrExclamationMark == nil || questionOrExclamationMark?.tokenKind.base == .postfixQuestionMark || questionOrExclamationMark?.tokenKind.base == .exclamationMark, "Received \(String(describing: questionOrExclamationMark?.tokenKind))") let raw = RawSyntax.makeLayout( - kind: .closureParam, uninitializedCount: 5, arena: arena) { layout in + kind: .unresolvedAsExpr, uninitializedCount: 5, 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] = unexpectedBeforeAsTok?.raw + layout[1] = asTok.raw + layout[2] = unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw + layout[3] = questionOrExclamationMark?.raw + layout[4] = unexpectedAfterQuestionOrExclamationMark?.raw } self.init(raw: raw) } - public var unexpectedBeforeName: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAsTok: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var name: RawTokenSyntax { + public var asTok: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenNameAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var trailingComma: RawTokenSyntax? { + public var questionOrExclamationMark: RawTokenSyntax? { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawClosureParamListSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureParamList - } - - 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: [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 - } - } - self.init(raw: raw) - } - - public var elements: [RawClosureParamSyntax] { - layoutView.children.map { RawClosureParamSyntax(raw: $0!) } - } -} - -@_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 RawAsExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3819,7 +3853,7 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureSignature + return raw.kind == .asExpr } public var raw: RawSyntax @@ -3834,85 +3868,66 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, - attributes: RawAttributeListSyntax?, - _ unexpectedBetweenAttributesAndCapture: RawUnexpectedNodesSyntax? = nil, - capture: RawClosureCaptureSignatureSyntax?, - _ unexpectedBetweenCaptureAndInput: RawUnexpectedNodesSyntax? = nil, - input: Input?, - _ unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? = nil, - effectSpecifiers: RawTypeEffectSpecifiersSyntax?, - _ unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? = nil, - output: RawReturnClauseSyntax?, - _ unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? = nil, - inTok: RawTokenSyntax, - _ unexpectedAfterInTok: 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 ) { - assert(inTok.tokenKind == .keyword(.in), "Received \(inTok.tokenKind)") + assert(asTok.tokenKind == .keyword(.as), "Received \(asTok.tokenKind)") + assert(questionOrExclamationMark == nil || questionOrExclamationMark?.tokenKind.base == .postfixQuestionMark || questionOrExclamationMark?.tokenKind.base == .exclamationMark, "Received \(String(describing: questionOrExclamationMark?.tokenKind))") let raw = RawSyntax.makeLayout( - kind: .closureSignature, uninitializedCount: 13, arena: arena) { layout in + kind: .asExpr, uninitializedCount: 9, 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] = unexpectedBetweenInputAndEffectSpecifiers?.raw - layout[7] = effectSpecifiers?.raw - layout[8] = unexpectedBetweenEffectSpecifiersAndOutput?.raw - layout[9] = output?.raw - layout[10] = unexpectedBetweenOutputAndInTok?.raw - layout[11] = inTok.raw - layout[12] = unexpectedAfterInTok?.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 unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndCapture: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var capture: RawClosureCaptureSignatureSyntax? { - layoutView.children[3].map(RawClosureCaptureSignatureSyntax.init(raw:)) + public var asTok: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenCaptureAndInput: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var input: RawSyntax? { - layoutView.children[5] + public var questionOrExclamationMark: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var effectSpecifiers: RawTypeEffectSpecifiersSyntax? { - layoutView.children[7].map(RawTypeEffectSpecifiersSyntax.init(raw:)) + public var typeName: RawTypeSyntax { + layoutView.children[7].map(RawTypeSyntax.init(raw:))! } - public var unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? { + public var unexpectedAfterTypeName: RawUnexpectedNodesSyntax? { layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var output: RawReturnClauseSyntax? { - layoutView.children[9].map(RawReturnClauseSyntax.init(raw:)) - } - public var unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var inTok: RawTokenSyntax { - layoutView.children[11].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterInTok: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -3920,7 +3935,7 @@ public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .closureExpr + return raw.kind == .typeExpr } public var raw: RawSyntax @@ -3935,66 +3950,34 @@ 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, + _ unexpectedBeforeType: RawUnexpectedNodesSyntax? = nil, + type: RawTypeSyntax, + _ unexpectedAfterType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(leftBrace.tokenKind.base == .leftBrace, "Received \(leftBrace.tokenKind)") - assert(rightBrace.tokenKind.base == .rightBrace, "Received \(rightBrace.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .closureExpr, uninitializedCount: 9, arena: arena) { layout in + kind: .typeExpr, uninitializedCount: 3, 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] = unexpectedBeforeType?.raw + layout[1] = type.raw + layout[2] = unexpectedAfterType?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftBrace: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeType: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftBrace: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var type: RawTypeSyntax { + layoutView.children[1].map(RawTypeSyntax.init(raw:))! } - public var unexpectedBetweenLeftBraceAndSignature: RawUnexpectedNodesSyntax? { + public var unexpectedAfterType: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var signature: RawClosureSignatureSyntax? { - layoutView.children[3].map(RawClosureSignatureSyntax.init(raw:)) - } - 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 RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawClosureCaptureItemSpecifierSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4002,7 +3985,7 @@ public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .unresolvedPatternExpr + return raw.kind == .closureCaptureItemSpecifier } public var raw: RawSyntax @@ -4017,34 +4000,68 @@ public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePattern: RawUnexpectedNodesSyntax? = nil, - pattern: RawPatternSyntax, - _ unexpectedAfterPattern: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, + specifier: RawTokenSyntax, + _ unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax?, + _ unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? = nil, + detail: RawTokenSyntax?, + _ unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax?, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { + assert(specifier.tokenKind == .keyword(.weak) || specifier.tokenKind == .keyword(.unowned), "Received \(specifier.tokenKind)") + assert(leftParen == nil || leftParen?.tokenKind.base == .leftParen, "Received \(String(describing: leftParen?.tokenKind))") + assert(detail == nil || detail?.tokenKind == .keyword(.safe) || detail?.tokenKind == .keyword(.unsafe), "Received \(String(describing: detail?.tokenKind))") + assert(rightParen == nil || rightParen?.tokenKind.base == .rightParen, "Received \(String(describing: rightParen?.tokenKind))") let raw = RawSyntax.makeLayout( - kind: .unresolvedPatternExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .closureCaptureItemSpecifier, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePattern?.raw - layout[1] = pattern.raw - layout[2] = unexpectedAfterPattern?.raw + layout[0] = unexpectedBeforeSpecifier?.raw + layout[1] = specifier.raw + layout[2] = unexpectedBetweenSpecifierAndLeftParen?.raw + layout[3] = leftParen?.raw + layout[4] = unexpectedBetweenLeftParenAndDetail?.raw + layout[5] = detail?.raw + layout[6] = unexpectedBetweenDetailAndRightParen?.raw + layout[7] = rightParen?.raw + layout[8] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var pattern: RawPatternSyntax { - layoutView.children[1].map(RawPatternSyntax.init(raw:))! + public var specifier: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterPattern: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenSpecifierAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var leftParen: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var detail: RawTokenSyntax? { + layoutView.children[5].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenDetailAndRightParen: 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 RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { +public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4052,7 +4069,7 @@ public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .multipleTrailingClosureElement + return raw.kind == .closureCaptureItem } public var raw: RawSyntax @@ -4067,56 +4084,77 @@ 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: RawClosureCaptureItemSpecifierSyntax?, + _ 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 ) { - assert(label.tokenKind.base == .identifier || label.tokenKind.base == .wildcard, "Received \(label.tokenKind)") - assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") + assert(name == nil || name?.tokenKind.base == .identifier, "Received \(String(describing: name?.tokenKind))") + assert(assignToken == nil || assignToken?.tokenKind.base == .equal, "Received \(String(describing: assignToken?.tokenKind))") + assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") 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: RawClosureCaptureItemSpecifierSyntax? { + layoutView.children[1].map(RawClosureCaptureItemSpecifierSyntax.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 { @@ -4124,7 +4162,7 @@ public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .multipleTrailingClosureElementList + return raw.kind == .closureCaptureItemList } public var raw: RawSyntax @@ -4138,9 +4176,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) @@ -4150,13 +4188,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 { @@ -4164,7 +4202,7 @@ public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .functionCallExpr + return raw.kind == .closureCaptureSignature } public var raw: RawSyntax @@ -4179,86 +4217,56 @@ 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 ) { - assert(leftParen == nil || leftParen?.tokenKind.base == .leftParen, "Received \(String(describing: leftParen?.tokenKind))") - assert(rightParen == nil || rightParen?.tokenKind.base == .rightParen, "Received \(String(describing: rightParen?.tokenKind))") + assert(leftSquare.tokenKind.base == .leftSquareBracket, "Received \(leftSquare.tokenKind)") + assert(rightSquare.tokenKind.base == .rightSquareBracket, "Received \(rightSquare.tokenKind)") 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 unexpectedBetweenCalledExpressionAndLeftParen: RawUnexpectedNodesSyntax? { + public var leftSquare: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + 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 { @@ -4266,7 +4274,7 @@ public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .subscriptExpr + return raw.kind == .closureParam } public var raw: RawSyntax @@ -4281,86 +4289,46 @@ 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 ) { - assert(leftBracket.tokenKind.base == .leftSquareBracket, "Received \(leftBracket.tokenKind)") - assert(rightBracket.tokenKind.base == .rightSquareBracket, "Received \(rightBracket.tokenKind)") + assert(name.tokenKind.base == .identifier || name.tokenKind.base == .wildcard, "Received \(name.tokenKind)") + assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") 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 { @@ -4368,7 +4336,7 @@ public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .optionalChainingExpr + return raw.kind == .closureParamList } public var raw: RawSyntax @@ -4382,46 +4350,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 - ) { - assert(questionMark.tokenKind.base == .postfixQuestionMark, "Received \(questionMark.tokenKind)") + 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 { @@ -4429,7 +4405,7 @@ public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .forcedValueExpr + return raw.kind == .closureSignature } public var raw: RawSyntax @@ -4444,53 +4420,93 @@ 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?, + _ unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? = nil, + effectSpecifiers: RawTypeEffectSpecifiersSyntax?, + _ unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? = nil, + output: RawReturnClauseSyntax?, + _ unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? = nil, + inTok: RawTokenSyntax, + _ unexpectedAfterInTok: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(exclamationMark.tokenKind.base == .exclamationMark, "Received \(exclamationMark.tokenKind)") + assert(inTok.tokenKind == .keyword(.in), "Received \(inTok.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .forcedValueExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .closureSignature, uninitializedCount: 13, 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] = unexpectedBetweenInputAndEffectSpecifiers?.raw + layout[7] = effectSpecifiers?.raw + layout[8] = unexpectedBetweenEffectSpecifiersAndOutput?.raw + layout[9] = output?.raw + layout[10] = unexpectedBetweenOutputAndInTok?.raw + layout[11] = inTok.raw + layout[12] = 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:)) } -} - -@_spi(RawSyntax) -public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { + public var input: RawSyntax? { + layoutView.children[5] + } + public var unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var effectSpecifiers: RawTypeEffectSpecifiersSyntax? { + layoutView.children[7].map(RawTypeEffectSpecifiersSyntax.init(raw:)) + } + public var unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var output: RawReturnClauseSyntax? { + layoutView.children[9].map(RawReturnClauseSyntax.init(raw:)) + } + public var unexpectedBetweenOutputAndInTok: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var inTok: RawTokenSyntax { + layoutView.children[11].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterInTok: RawUnexpectedNodesSyntax? { + layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .postfixUnaryExpr + return raw.kind == .closureExpr } public var raw: RawSyntax @@ -4505,45 +4521,66 @@ 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 ) { - assert(operatorToken.tokenKind.base == .postfixOperator, "Received \(operatorToken.tokenKind)") + assert(leftBrace.tokenKind.base == .leftBrace, "Received \(leftBrace.tokenKind)") + assert(rightBrace.tokenKind.base == .rightBrace, "Received \(rightBrace.tokenKind)") 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 { @@ -4551,7 +4588,7 @@ public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .specializeExpr + return raw.kind == .unresolvedPatternExpr } public var raw: RawSyntax @@ -4566,44 +4603,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 { @@ -4611,7 +4638,7 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .stringSegment + return raw.kind == .multipleTrailingClosureElement } public var raw: RawSyntax @@ -4626,35 +4653,56 @@ 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 ) { - assert(content.tokenKind.base == .stringSegment, "Received \(content.tokenKind)") + assert(label.tokenKind.base == .identifier || label.tokenKind.base == .wildcard, "Received \(label.tokenKind)") + assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") 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 { @@ -4662,7 +4710,7 @@ public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .expressionSegment + return raw.kind == .multipleTrailingClosureElementList } public var raw: RawSyntax @@ -4676,79 +4724,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 - ) { - assert(backslash.tokenKind.base == .backslash, "Received \(backslash.tokenKind)") - assert(delimiter == nil || delimiter?.tokenKind.base == .rawStringDelimiter, "Received \(String(describing: delimiter?.tokenKind))") - assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") - assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") + 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 { @@ -4756,7 +4750,7 @@ public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .stringLiteralExpr + return raw.kind == .functionCallExpr } public var raw: RawSyntax @@ -4771,78 +4765,86 @@ 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 ) { - assert(openDelimiter == nil || openDelimiter?.tokenKind.base == .rawStringDelimiter, "Received \(String(describing: openDelimiter?.tokenKind))") - assert(openQuote.tokenKind.base == .stringQuote || openQuote.tokenKind.base == .multilineStringQuote || openQuote.tokenKind.base == .singleQuote, "Received \(openQuote.tokenKind)") - assert(closeQuote.tokenKind.base == .stringQuote || closeQuote.tokenKind.base == .multilineStringQuote || closeQuote.tokenKind.base == .singleQuote, "Received \(closeQuote.tokenKind)") - assert(closeDelimiter == nil || closeDelimiter?.tokenKind.base == .rawStringDelimiter, "Received \(String(describing: closeDelimiter?.tokenKind))") + assert(leftParen == nil || leftParen?.tokenKind.base == .leftParen, "Received \(String(describing: leftParen?.tokenKind))") + assert(rightParen == nil || rightParen?.tokenKind.base == .rightParen, "Received \(String(describing: rightParen?.tokenKind))") 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 { @@ -4850,7 +4852,7 @@ public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .regexLiteralExpr + return raw.kind == .subscriptExpr } public var raw: RawSyntax @@ -4865,35 +4867,86 @@ 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 ) { - assert(regex.tokenKind.base == .regexLiteral, "Received \(regex.tokenKind)") + assert(leftBracket.tokenKind.base == .leftSquareBracket, "Received \(leftBracket.tokenKind)") + assert(rightBracket.tokenKind.base == .rightSquareBracket, "Received \(rightBracket.tokenKind)") 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:)) } + 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 RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -4901,7 +4954,7 @@ public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathExpr + return raw.kind == .optionalChainingExpr } public var raw: RawSyntax @@ -4916,55 +4969,45 @@ 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 ) { - assert(backslash.tokenKind.base == .backslash, "Received \(backslash.tokenKind)") + assert(questionMark.tokenKind.base == .postfixQuestionMark, "Received \(questionMark.tokenKind)") 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 { @@ -4972,7 +5015,7 @@ public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathComponentList + return raw.kind == .forcedValueExpr } public var raw: RawSyntax @@ -4986,60 +5029,46 @@ 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 + ) { + assert(exclamationMark.tokenKind.base == .exclamationMark, "Received \(exclamationMark.tokenKind)") 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:)) } -} - -@_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 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 RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5047,7 +5076,7 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathComponent + return raw.kind == .postfixUnaryExpr } public var raw: RawSyntax @@ -5062,45 +5091,45 @@ 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 ) { - assert(period == nil || period?.tokenKind.base == .period, "Received \(String(describing: period?.tokenKind))") + assert(operatorToken.tokenKind.base == .postfixOperator, "Received \(operatorToken.tokenKind)") 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 { @@ -5108,7 +5137,7 @@ public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathPropertyComponent + return raw.kind == .specializeExpr } public var raw: RawSyntax @@ -5123,55 +5152,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 ) { - assert(identifier.tokenKind.base == .identifier || identifier.tokenKind.base == .keyword || identifier.tokenKind.base == .dollarIdentifier || identifier.tokenKind.base == .binaryOperator || identifier.tokenKind.base == .integerLiteral, "Received \(identifier.tokenKind)") 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 { @@ -5179,7 +5197,7 @@ public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathSubscriptComponent + return raw.kind == .stringSegment } public var raw: RawSyntax @@ -5194,56 +5212,35 @@ 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 ) { - assert(leftBracket.tokenKind.base == .leftSquareBracket, "Received \(leftBracket.tokenKind)") - assert(rightBracket.tokenKind.base == .rightSquareBracket, "Received \(rightBracket.tokenKind)") + assert(content.tokenKind.base == .stringSegment, "Received \(content.tokenKind)") 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 { @@ -5251,7 +5248,7 @@ public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathOptionalComponent + return raw.kind == .expressionSegment } public var raw: RawSyntax @@ -5266,159 +5263,172 @@ 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 ) { - assert(questionOrExclamationMark.tokenKind.base == .postfixQuestionMark || questionOrExclamationMark.tokenKind.base == .exclamationMark, "Received \(questionOrExclamationMark.tokenKind)") + assert(backslash.tokenKind.base == .backslash, "Received \(backslash.tokenKind)") + assert(delimiter == nil || delimiter?.tokenKind.base == .rawStringDelimiter, "Received \(String(describing: delimiter?.tokenKind))") + assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") + assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") 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:)) } -} - -@_spi(RawSyntax) -public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! + public var delimiter: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .macroExpansionExpr + public var unexpectedBetweenDelimiterAndLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw + public var leftParen: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } + 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 RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .stringLiteralExpr + } + + 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( - _ 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 ) { - assert(poundToken.tokenKind.base == .pound, "Received \(poundToken.tokenKind)") - assert(macro.tokenKind.base == .identifier, "Received \(macro.tokenKind)") - assert(leftParen == nil || leftParen?.tokenKind.base == .leftParen, "Received \(String(describing: leftParen?.tokenKind))") - assert(rightParen == nil || rightParen?.tokenKind.base == .rightParen, "Received \(String(describing: rightParen?.tokenKind))") + assert(openDelimiter == nil || openDelimiter?.tokenKind.base == .rawStringDelimiter, "Received \(String(describing: openDelimiter?.tokenKind))") + assert(openQuote.tokenKind.base == .stringQuote || openQuote.tokenKind.base == .multilineStringQuote || openQuote.tokenKind.base == .singleQuote, "Received \(openQuote.tokenKind)") + assert(closeQuote.tokenKind.base == .stringQuote || closeQuote.tokenKind.base == .multilineStringQuote || closeQuote.tokenKind.base == .singleQuote, "Received \(closeQuote.tokenKind)") + assert(closeDelimiter == nil || closeDelimiter?.tokenKind.base == .rawStringDelimiter, "Received \(String(describing: closeDelimiter?.tokenKind))") 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 { @@ -5426,7 +5436,7 @@ public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .postfixIfConfigExpr + return raw.kind == .regexLiteralExpr } public var raw: RawSyntax @@ -5441,44 +5451,35 @@ 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 ) { + assert(regex.tokenKind.base == .regexLiteral, "Received \(regex.tokenKind)") 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 { @@ -5486,7 +5487,7 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .editorPlaceholderExpr + return raw.kind == .keyPathExpr } public var raw: RawSyntax @@ -5501,35 +5502,55 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? = nil, + backslash: RawTokenSyntax, + _ unexpectedBetweenBackslashAndRoot: RawUnexpectedNodesSyntax? = nil, + root: RawTypeSyntax?, + _ unexpectedBetweenRootAndComponents: RawUnexpectedNodesSyntax? = nil, + components: RawKeyPathComponentListSyntax, + _ unexpectedAfterComponents: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(identifier.tokenKind.base == .identifier, "Received \(identifier.tokenKind)") + assert(backslash.tokenKind.base == .backslash, "Received \(backslash.tokenKind)") 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 { @@ -5537,7 +5558,7 @@ public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .yieldExprList + return raw.kind == .keyPathComponentList } public var raw: RawSyntax @@ -5551,9 +5572,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) @@ -5563,21 +5584,56 @@ 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) - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! + 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 { + return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .yieldExprListElement + return raw.kind == .keyPathComponent } public var raw: RawSyntax @@ -5592,45 +5648,45 @@ 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 ) { - assert(comma == nil || comma?.tokenKind.base == .comma, "Received \(String(describing: comma?.tokenKind))") + assert(period == nil || period?.tokenKind.base == .period, "Received \(String(describing: period?.tokenKind))") 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 { @@ -5638,7 +5694,7 @@ public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typeInitializerClause + return raw.kind == .keyPathPropertyComponent } public var raw: RawSyntax @@ -5653,45 +5709,55 @@ 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 ) { - assert(equal.tokenKind.base == .equal, "Received \(equal.tokenKind)") + assert(identifier.tokenKind.base == .identifier || identifier.tokenKind.base == .keyword || identifier.tokenKind.base == .dollarIdentifier || identifier.tokenKind.base == .binaryOperator || identifier.tokenKind.base == .integerLiteral, "Received \(identifier.tokenKind)") 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 { @@ -5699,7 +5765,7 @@ public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typealiasDecl + return raw.kind == .keyPathSubscriptComponent } public var raw: RawSyntax @@ -5714,96 +5780,56 @@ 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 ) { - assert(typealiasKeyword.tokenKind == .keyword(.typealias), "Received \(typealiasKeyword.tokenKind)") - assert(identifier.tokenKind.base == .identifier, "Received \(identifier.tokenKind)") + assert(leftBracket.tokenKind.base == .leftSquareBracket, "Received \(leftBracket.tokenKind)") + assert(rightBracket.tokenKind.base == .rightSquareBracket, "Received \(rightBracket.tokenKind)") 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:)) - } - 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 { +public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5811,7 +5837,7 @@ public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .associatedtypeDecl + return raw.kind == .keyPathOptionalComponent } public var raw: RawSyntax @@ -5826,96 +5852,35 @@ 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, + _ unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + questionOrExclamationMark: RawTokenSyntax, + _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(associatedtypeKeyword.tokenKind == .keyword(.associatedtype), "Received \(associatedtypeKeyword.tokenKind)") - assert(identifier.tokenKind.base == .identifier, "Received \(identifier.tokenKind)") + assert(questionOrExclamationMark.tokenKind.base == .postfixQuestionMark || questionOrExclamationMark.tokenKind.base == .exclamationMark, "Received \(questionOrExclamationMark.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .associatedtypeDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .keyPathOptionalComponent, uninitializedCount: 3, 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] = unexpectedBeforeQuestionOrExclamationMark?.raw + layout[1] = questionOrExclamationMark.raw + layout[2] = unexpectedAfterQuestionOrExclamationMark?.raw } self.init(raw: raw) } - public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var attributes: RawAttributeListSyntax? { - layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) + public var questionOrExclamationMark: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { + public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var modifiers: RawModifierListSyntax? { - layoutView.children[3].map(RawModifierListSyntax.init(raw:)) - } - 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 RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { +public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5923,7 +5888,7 @@ public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .functionParameterList + return raw.kind == .macroExpansionExpr } public var raw: RawSyntax @@ -5937,25 +5902,109 @@ public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawFunctionParameterSyntax], arena: __shared SyntaxArena) { + 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, + arena: __shared SyntaxArena + ) { + assert(poundToken.tokenKind.base == .pound, "Received \(poundToken.tokenKind)") + assert(macro.tokenKind.base == .identifier, "Received \(macro.tokenKind)") + assert(leftParen == nil || leftParen?.tokenKind.base == .leftParen, "Received \(String(describing: leftParen?.tokenKind))") + assert(rightParen == nil || rightParen?.tokenKind.base == .rightParen, "Received \(String(describing: rightParen?.tokenKind))") 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: .macroExpansionExpr, uninitializedCount: 17, 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 } self.init(raw: raw) } - public var elements: [RawFunctionParameterSyntax] { - layoutView.children.map { RawFunctionParameterSyntax(raw: $0!) } + public var unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var poundToken: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var macro: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var genericArguments: RawGenericArgumentClauseSyntax? { + layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:)) + } + public var unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var leftParen: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var argumentList: RawTupleExprElementListSyntax { + layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw:))! + } + public var unexpectedBetweenArgumentListAndRightParen: 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 RawParameterClauseSyntax: RawSyntaxNodeProtocol { +public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5963,7 +6012,7 @@ public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .parameterClause + return raw.kind == .postfixIfConfigExpr } public var raw: RawSyntax @@ -5978,56 +6027,44 @@ public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? = nil, - parameterList: RawFunctionParameterListSyntax, - _ unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBase: RawUnexpectedNodesSyntax? = nil, + base: RawExprSyntax?, + _ unexpectedBetweenBaseAndConfig: RawUnexpectedNodesSyntax? = nil, + config: RawIfConfigDeclSyntax, + _ unexpectedAfterConfig: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") - assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .parameterClause, uninitializedCount: 7, arena: arena) { layout in + kind: .postfixIfConfigExpr, uninitializedCount: 5, 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] = unexpectedBeforeBase?.raw + layout[1] = base?.raw + layout[2] = unexpectedBetweenBaseAndConfig?.raw + layout[3] = config.raw + layout[4] = unexpectedAfterConfig?.raw } self.init(raw: raw) } - public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeBase: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var base: RawExprSyntax? { + layoutView.children[1].map(RawExprSyntax.init(raw:)) } - public var unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenBaseAndConfig: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var parameterList: RawFunctionParameterListSyntax { - layoutView.children[3].map(RawFunctionParameterListSyntax.init(raw:))! + public var config: RawIfConfigDeclSyntax { + layoutView.children[3].map(RawIfConfigDeclSyntax.init(raw:))! } - public var unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedAfterConfig: 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 RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6035,7 +6072,7 @@ public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .returnClause + return raw.kind == .editorPlaceholderExpr } public var raw: RawSyntax @@ -6050,45 +6087,35 @@ public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeArrow: RawUnexpectedNodesSyntax? = nil, - arrow: RawTokenSyntax, - _ unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? = nil, - returnType: RawTypeSyntax, - _ unexpectedAfterReturnType: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedAfterIdentifier: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(arrow.tokenKind.base == .arrow, "Received \(arrow.tokenKind)") + assert(identifier.tokenKind.base == .identifier, "Received \(identifier.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .returnClause, uninitializedCount: 5, arena: arena) { layout in + kind: .editorPlaceholderExpr, uninitializedCount: 3, 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 + layout[0] = unexpectedBeforeIdentifier?.raw + layout[1] = identifier.raw + layout[2] = unexpectedAfterIdentifier?.raw } self.init(raw: raw) } - public var unexpectedBeforeArrow: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var arrow: RawTokenSyntax { + public var identifier: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? { + public var unexpectedAfterIdentifier: 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:)) - } } @_spi(RawSyntax) -public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { +public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6096,7 +6123,7 @@ public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .functionSignature + return raw.kind == .yieldExprList } public var raw: RawSyntax @@ -6110,102 +6137,25 @@ public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeInput: RawUnexpectedNodesSyntax? = nil, - input: RawParameterClauseSyntax, - _ unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? = nil, - effectSpecifiers: RawDeclEffectSpecifiersSyntax?, - _ unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? = nil, - output: RawReturnClauseSyntax?, - _ unexpectedAfterOutput: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { + public init(elements: [RawYieldExprListElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .functionSignature, uninitializedCount: 7, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeInput?.raw - layout[1] = input.raw - layout[2] = unexpectedBetweenInputAndEffectSpecifiers?.raw - layout[3] = effectSpecifiers?.raw - layout[4] = unexpectedBetweenEffectSpecifiersAndOutput?.raw - layout[5] = output?.raw - layout[6] = unexpectedAfterOutput?.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 unexpectedBeforeInput: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var input: RawParameterClauseSyntax { - layoutView.children[1].map(RawParameterClauseSyntax.init(raw:))! - } - public var unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var effectSpecifiers: RawDeclEffectSpecifiersSyntax? { - layoutView.children[3].map(RawDeclEffectSpecifiersSyntax.init(raw:)) - } - public var unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var output: RawReturnClauseSyntax? { - layoutView.children[5].map(RawReturnClauseSyntax.init(raw:)) - } - public var unexpectedAfterOutput: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawYieldExprListElementSyntax] { + layoutView.children.map { RawYieldExprListElementSyntax(raw: $0!) } } } @_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 RawYieldExprListElementSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6213,7 +6163,7 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifConfigClause + return raw.kind == .yieldExprListElement } public var raw: RawSyntax @@ -6228,55 +6178,45 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? = nil, - poundKeyword: RawTokenSyntax, - _ unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? = nil, - condition: RawExprSyntax?, - _ unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? = nil, - elements: Elements?, - _ unexpectedAfterElements: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedBetweenExpressionAndComma: RawUnexpectedNodesSyntax? = nil, + comma: RawTokenSyntax?, + _ unexpectedAfterComma: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(poundKeyword.tokenKind.base == .poundIfKeyword || poundKeyword.tokenKind.base == .poundElseifKeyword || poundKeyword.tokenKind.base == .poundElseKeyword, "Received \(poundKeyword.tokenKind)") + assert(comma == nil || comma?.tokenKind.base == .comma, "Received \(String(describing: comma?.tokenKind))") let raw = RawSyntax.makeLayout( - kind: .ifConfigClause, uninitializedCount: 7, arena: arena) { layout in + kind: .yieldExprListElement, 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] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedBetweenExpressionAndComma?.raw + layout[3] = comma?.raw + layout[4] = unexpectedAfterComma?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndComma: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var condition: RawExprSyntax? { - layoutView.children[3].map(RawExprSyntax.init(raw:)) + public var comma: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? { + public var unexpectedAfterComma: 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 RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6284,7 +6224,7 @@ public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifConfigClauseList + return raw.kind == .typeInitializerClause } public var raw: RawSyntax @@ -6298,25 +6238,46 @@ public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawIfConfigClauseSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforeEqual: RawUnexpectedNodesSyntax? = nil, + equal: RawTokenSyntax, + _ unexpectedBetweenEqualAndValue: RawUnexpectedNodesSyntax? = nil, + value: RawTypeSyntax, + _ unexpectedAfterValue: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + assert(equal.tokenKind.base == .equal, "Received \(equal.tokenKind)") 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: .typeInitializerClause, 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 elements: [RawIfConfigClauseSyntax] { - layoutView.children.map { RawIfConfigClauseSyntax(raw: $0!) } + 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: RawTypeSyntax { + layoutView.children[3].map(RawTypeSyntax.init(raw:))! + } + public var unexpectedAfterValue: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6324,7 +6285,7 @@ public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifConfigDecl + return raw.kind == .typealiasDecl } public var raw: RawSyntax @@ -6339,53 +6300,104 @@ 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?, + _ 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 ) { - assert(poundEndif.tokenKind.base == .poundEndifKeyword, "Received \(poundEndif.tokenKind)") + assert(typealiasKeyword.tokenKind == .keyword(.typealias), "Received \(typealiasKeyword.tokenKind)") + assert(identifier.tokenKind.base == .identifier, "Received \(identifier.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .ifConfigDecl, uninitializedCount: 5, arena: arena) { layout in + kind: .typealiasDecl, 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] = 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 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 unexpectedBetweenModifiersAndTypealiasKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } -} - -@_spi(RawSyntax) -public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } + 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 == .poundSourceLocation + return raw.kind == .associatedtypeDecl } public var raw: RawSyntax @@ -6400,67 +6412,96 @@ 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, + _ 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 ) { - assert(poundSourceLocation.tokenKind.base == .poundSourceLocationKeyword, "Received \(poundSourceLocation.tokenKind)") - assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") - assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") + assert(associatedtypeKeyword.tokenKind == .keyword(.associatedtype), "Received \(associatedtypeKeyword.tokenKind)") + assert(identifier.tokenKind.base == .identifier, "Received \(identifier.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .poundSourceLocation, uninitializedCount: 9, arena: arena) { layout in + kind: .associatedtypeDecl, uninitializedCount: 15, 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] = 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 unexpectedBeforePoundSourceLocation: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundSourceLocation: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var attributes: RawAttributeListSyntax? { + layoutView.children[1].map(RawAttributeListSyntax.init(raw:)) } - public var unexpectedBetweenPoundSourceLocationAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var modifiers: RawModifierListSyntax? { + layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedBetweenLeftParenAndArgs: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndAssociatedtypeKeyword: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var args: RawPoundSourceLocationArgsSyntax? { - layoutView.children[5].map(RawPoundSourceLocationArgsSyntax.init(raw:)) + public var associatedtypeKeyword: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenArgsAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAssociatedtypeKeywordAndIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightParen: RawTokenSyntax { + public var identifier: RawTokenSyntax { layoutView.children[7].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + 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 RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { +public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6468,7 +6509,7 @@ public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundSourceLocationArgs + return raw.kind == .functionParameterList } public var raw: RawSyntax @@ -6482,101 +6523,25 @@ public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? = nil, - fileArgLabel: RawTokenSyntax, - _ unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? = nil, - fileArgColon: RawTokenSyntax, - _ unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? = nil, - fileName: RawStringLiteralExprSyntax, - _ 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 - ) { - assert(fileArgLabel.tokenKind == .keyword(.file), "Received \(fileArgLabel.tokenKind)") - assert(fileArgColon.tokenKind.base == .colon, "Received \(fileArgColon.tokenKind)") - assert(comma.tokenKind.base == .comma, "Received \(comma.tokenKind)") - assert(lineArgLabel.tokenKind == .keyword(.line), "Received \(lineArgLabel.tokenKind)") - assert(lineArgColon.tokenKind.base == .colon, "Received \(lineArgColon.tokenKind)") - assert(lineNumber.tokenKind.base == .integerLiteral, "Received \(lineNumber.tokenKind)") + public init(elements: [RawFunctionParameterSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .poundSourceLocationArgs, uninitializedCount: 15, 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 + 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 unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var fileArgLabel: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var fileArgColon: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var fileName: RawStringLiteralExprSyntax { - layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))! - } - public var unexpectedBetweenFileNameAndComma: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var comma: RawTokenSyntax { - layoutView.children[7].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenCommaAndLineArgLabel: 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:)) + public var elements: [RawFunctionParameterSyntax] { + layoutView.children.map { RawFunctionParameterSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { +public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6584,7 +6549,7 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .declModifierDetail + return raw.kind == .parameterClause } public var raw: RawSyntax @@ -6601,24 +6566,23 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { public init( _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? = nil, - detail: RawTokenSyntax, - _ unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? = nil, + parameterList: RawFunctionParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? = nil, rightParen: RawTokenSyntax, _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") - assert(detail.tokenKind.base == .identifier || detail.tokenKind == .keyword(.set), "Received \(detail.tokenKind)") assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .declModifierDetail, uninitializedCount: 7, arena: arena) { layout in + kind: .parameterClause, 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[2] = unexpectedBetweenLeftParenAndParameterList?.raw + layout[3] = parameterList.raw + layout[4] = unexpectedBetweenParameterListAndRightParen?.raw layout[5] = rightParen.raw layout[6] = unexpectedAfterRightParen?.raw } @@ -6631,13 +6595,13 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { public var leftParen: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndParameterList: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var detail: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var parameterList: RawFunctionParameterListSyntax { + layoutView.children[3].map(RawFunctionParameterListSyntax.init(raw:))! } - public var unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenParameterListAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } public var rightParen: RawTokenSyntax { @@ -6649,7 +6613,7 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { +public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6657,7 +6621,7 @@ public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .declModifier + return raw.kind == .returnClause } public var raw: RawSyntax @@ -6672,45 +6636,45 @@ public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax, - _ unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? = nil, - detail: RawDeclModifierDetailSyntax?, - _ unexpectedAfterDetail: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeArrow: RawUnexpectedNodesSyntax? = nil, + arrow: RawTokenSyntax, + _ unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? = nil, + returnType: RawTypeSyntax, + _ unexpectedAfterReturnType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(name.tokenKind == .keyword(.class) || name.tokenKind == .keyword(.convenience) || name.tokenKind == .keyword(.dynamic) || name.tokenKind == .keyword(.final) || name.tokenKind == .keyword(.infix) || name.tokenKind == .keyword(.lazy) || name.tokenKind == .keyword(.optional) || name.tokenKind == .keyword(.override) || name.tokenKind == .keyword(.postfix) || name.tokenKind == .keyword(.prefix) || name.tokenKind == .keyword(.required) || name.tokenKind == .keyword(.static) || name.tokenKind == .keyword(.unowned) || name.tokenKind == .keyword(.weak) || name.tokenKind == .keyword(.private) || name.tokenKind == .keyword(.fileprivate) || name.tokenKind == .keyword(.internal) || name.tokenKind == .keyword(.public) || name.tokenKind == .keyword(.open) || name.tokenKind == .keyword(.mutating) || name.tokenKind == .keyword(.nonmutating) || name.tokenKind == .keyword(.indirect) || name.tokenKind == .keyword(.__consuming) || name.tokenKind == .keyword(.actor) || name.tokenKind == .keyword(.async) || name.tokenKind == .keyword(.distributed) || name.tokenKind == .keyword(.isolated) || name.tokenKind == .keyword(.nonisolated) || name.tokenKind == .keyword(._const) || name.tokenKind == .keyword(._local) || name.tokenKind == .keyword(.package), "Received \(name.tokenKind)") + assert(arrow.tokenKind.base == .arrow, "Received \(arrow.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .declModifier, uninitializedCount: 5, arena: arena) { layout in + kind: .returnClause, 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 + 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 unexpectedBeforeName: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeArrow: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var name: RawTokenSyntax { + public var arrow: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenArrowAndReturnType: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var detail: RawDeclModifierDetailSyntax? { - layoutView.children[3].map(RawDeclModifierDetailSyntax.init(raw:)) + public var returnType: RawTypeSyntax { + layoutView.children[3].map(RawTypeSyntax.init(raw:))! } - public var unexpectedAfterDetail: RawUnexpectedNodesSyntax? { + public var unexpectedAfterReturnType: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { +public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6718,7 +6682,7 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .inheritedType + return raw.kind == .functionSignature } public var raw: RawSyntax @@ -6733,45 +6697,101 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? = nil, - typeName: RawTypeSyntax, - _ unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeInput: RawUnexpectedNodesSyntax? = nil, + input: RawParameterClauseSyntax, + _ unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? = nil, + effectSpecifiers: RawDeclEffectSpecifiersSyntax?, + _ unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? = nil, + output: RawReturnClauseSyntax?, + _ unexpectedAfterOutput: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") let raw = RawSyntax.makeLayout( - kind: .inheritedType, uninitializedCount: 5, arena: arena) { layout in + kind: .functionSignature, uninitializedCount: 7, 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] = unexpectedBeforeInput?.raw + layout[1] = input.raw + layout[2] = unexpectedBetweenInputAndEffectSpecifiers?.raw + layout[3] = effectSpecifiers?.raw + layout[4] = unexpectedBetweenEffectSpecifiersAndOutput?.raw + layout[5] = output?.raw + layout[6] = unexpectedAfterOutput?.raw } self.init(raw: raw) } - public var unexpectedBeforeTypeName: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeInput: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var typeName: RawTypeSyntax { - layoutView.children[1].map(RawTypeSyntax.init(raw:))! + public var input: RawParameterClauseSyntax { + layoutView.children[1].map(RawParameterClauseSyntax.init(raw:))! } - public var unexpectedBetweenTypeNameAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenInputAndEffectSpecifiers: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var trailingComma: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var effectSpecifiers: RawDeclEffectSpecifiersSyntax? { + layoutView.children[3].map(RawDeclEffectSpecifiersSyntax.init(raw:)) } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenEffectSpecifiersAndOutput: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var output: RawReturnClauseSyntax? { + layoutView.children[5].map(RawReturnClauseSyntax.init(raw:)) + } + public var unexpectedAfterOutput: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawInheritedTypeListSyntax: 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 { @@ -6779,7 +6799,7 @@ public struct RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .inheritedTypeList + return raw.kind == .ifConfigClause } public var raw: RawSyntax @@ -6793,25 +6813,56 @@ public struct RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawInheritedTypeSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? = nil, + poundKeyword: RawTokenSyntax, + _ unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? = nil, + condition: RawExprSyntax?, + _ unexpectedBetweenConditionAndElements: RawUnexpectedNodesSyntax? = nil, + elements: Elements?, + _ unexpectedAfterElements: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + assert(poundKeyword.tokenKind.base == .poundIfKeyword || poundKeyword.tokenKind.base == .poundElseifKeyword || poundKeyword.tokenKind.base == .poundElseKeyword, "Received \(poundKeyword.tokenKind)") 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: .ifConfigClause, uninitializedCount: 7, 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 } self.init(raw: raw) } - public var elements: [RawInheritedTypeSyntax] { - layoutView.children.map { RawInheritedTypeSyntax(raw: $0!) } + public var unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var poundKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenPoundKeywordAndCondition: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var condition: RawExprSyntax? { + layoutView.children[3].map(RawExprSyntax.init(raw:)) + } + public var unexpectedBetweenConditionAndElements: 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 RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { +public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6819,7 +6870,7 @@ public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .typeInheritanceClause + return raw.kind == .ifConfigClauseList } public var raw: RawSyntax @@ -6833,46 +6884,25 @@ public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init( - _ unexpectedBeforeColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax, - _ unexpectedBetweenColonAndInheritedTypeCollection: RawUnexpectedNodesSyntax? = nil, - inheritedTypeCollection: RawInheritedTypeListSyntax, - _ unexpectedAfterInheritedTypeCollection: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") + public init(elements: [RawIfConfigClauseSyntax], 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 + 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 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:)) + public var elements: [RawIfConfigClauseSyntax] { + layoutView.children.map { RawIfConfigClauseSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { +public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -6880,7 +6910,7 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .classDecl + return raw.kind == .ifConfigDecl } public var raw: RawSyntax @@ -6895,17 +6925,573 @@ 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, + _ unexpectedBeforeClauses: RawUnexpectedNodesSyntax? = nil, + clauses: RawIfConfigClauseListSyntax, + _ unexpectedBetweenClausesAndPoundEndif: RawUnexpectedNodesSyntax? = nil, + poundEndif: RawTokenSyntax, + _ unexpectedAfterPoundEndif: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + assert(poundEndif.tokenKind.base == .poundEndifKeyword, "Received \(poundEndif.tokenKind)") + let raw = RawSyntax.makeLayout( + kind: .ifConfigDecl, uninitializedCount: 5, 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 + } + self.init(raw: raw) + } + + public var unexpectedBeforeClauses: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var clauses: RawIfConfigClauseListSyntax { + layoutView.children[1].map(RawIfConfigClauseListSyntax.init(raw:))! + } + public var unexpectedBetweenClausesAndPoundEndif: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var poundEndif: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterPoundEndif: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + +@_spi(RawSyntax) +public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .poundSourceLocation + } + + 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( + _ 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 + ) { + assert(poundSourceLocation.tokenKind.base == .poundSourceLocationKeyword, "Received \(poundSourceLocation.tokenKind)") + assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") + assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") + let raw = RawSyntax.makeLayout( + kind: .poundSourceLocation, uninitializedCount: 9, 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 + } + self.init(raw: raw) + } + + public var unexpectedBeforePoundSourceLocation: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var poundSourceLocation: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenPoundSourceLocationAndLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenLeftParenAndArgs: 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 { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .poundSourceLocationArgs + } + + 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( + _ unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? = nil, + fileArgLabel: RawTokenSyntax, + _ unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? = nil, + fileArgColon: RawTokenSyntax, + _ unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? = nil, + fileName: RawStringLiteralExprSyntax, + _ 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 + ) { + assert(fileArgLabel.tokenKind == .keyword(.file), "Received \(fileArgLabel.tokenKind)") + assert(fileArgColon.tokenKind.base == .colon, "Received \(fileArgColon.tokenKind)") + assert(comma.tokenKind.base == .comma, "Received \(comma.tokenKind)") + assert(lineArgLabel.tokenKind == .keyword(.line), "Received \(lineArgLabel.tokenKind)") + assert(lineArgColon.tokenKind.base == .colon, "Received \(lineArgColon.tokenKind)") + assert(lineNumber.tokenKind.base == .integerLiteral, "Received \(lineNumber.tokenKind)") + let raw = RawSyntax.makeLayout( + kind: .poundSourceLocationArgs, uninitializedCount: 15, 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 + } + self.init(raw: raw) + } + + public var unexpectedBeforeFileArgLabel: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var fileArgLabel: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenFileArgLabelAndFileArgColon: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var fileArgColon: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenFileArgColonAndFileName: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var fileName: RawStringLiteralExprSyntax { + layoutView.children[5].map(RawStringLiteralExprSyntax.init(raw:))! + } + public var unexpectedBetweenFileNameAndComma: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var comma: RawTokenSyntax { + layoutView.children[7].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenCommaAndLineArgLabel: 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 { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .declModifierDetail + } + + 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( + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? = nil, + detail: RawTokenSyntax, + _ unexpectedBetweenDetailAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") + assert(detail.tokenKind.base == .identifier || detail.tokenKind == .keyword(.set), "Received \(detail.tokenKind)") + assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") + let raw = RawSyntax.makeLayout( + kind: .declModifierDetail, 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 + } + self.init(raw: raw) + } + + public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var leftParen: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenLeftParenAndDetail: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var detail: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenDetailAndRightParen: 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 RawDeclModifierSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .declModifier + } + + 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( + _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, + name: RawTokenSyntax, + _ unexpectedBetweenNameAndDetail: RawUnexpectedNodesSyntax? = nil, + detail: RawDeclModifierDetailSyntax?, + _ unexpectedAfterDetail: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + assert(name.tokenKind == .keyword(.class) || name.tokenKind == .keyword(.convenience) || name.tokenKind == .keyword(.dynamic) || name.tokenKind == .keyword(.final) || name.tokenKind == .keyword(.infix) || name.tokenKind == .keyword(.lazy) || name.tokenKind == .keyword(.optional) || name.tokenKind == .keyword(.override) || name.tokenKind == .keyword(.postfix) || name.tokenKind == .keyword(.prefix) || name.tokenKind == .keyword(.required) || name.tokenKind == .keyword(.static) || name.tokenKind == .keyword(.unowned) || name.tokenKind == .keyword(.weak) || name.tokenKind == .keyword(.private) || name.tokenKind == .keyword(.fileprivate) || name.tokenKind == .keyword(.internal) || name.tokenKind == .keyword(.public) || name.tokenKind == .keyword(.open) || name.tokenKind == .keyword(.mutating) || name.tokenKind == .keyword(.nonmutating) || name.tokenKind == .keyword(.indirect) || name.tokenKind == .keyword(.__consuming) || name.tokenKind == .keyword(.actor) || name.tokenKind == .keyword(.async) || name.tokenKind == .keyword(.distributed) || name.tokenKind == .keyword(.isolated) || name.tokenKind == .keyword(.nonisolated) || name.tokenKind == .keyword(._const) || name.tokenKind == .keyword(._local) || name.tokenKind == .keyword(.package), "Received \(name.tokenKind)") + 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 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:)) + } +} + +@_spi(RawSyntax) +public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + 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 + ) { + assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") + 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 + ) { + assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") + 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 + 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?, + _ 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?, @@ -13054,6 +13640,56 @@ public struct RawLabeledStmtSyntax: RawStmtSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawExpressionStmtSyntax: RawStmtSyntaxNodeProtocol { + + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .expressionStmt + } + + public var raw: RawSyntax + init(raw: RawSyntax) { + assert(Self.isKindOf(raw)) + self.raw = raw + } + + public init?(_ other: Node) { + guard Self.isKindOf(other.raw) else { return nil } + self.init(raw: other.raw) + } + + public init( + _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .expressionStmt, uninitializedCount: 3, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeExpression?.raw + layout[1] = expression.raw + layout[2] = unexpectedAfterExpression?.raw + } + self.init(raw: raw) + } + + public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var expression: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! + } + public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawContinueStmtSyntax: RawStmtSyntaxNodeProtocol { @@ -13248,75 +13884,6 @@ public struct RawDeferStmtSyntax: RawStmtSyntaxNodeProtocol { } } -@_spi(RawSyntax) -public struct RawSwitchCaseListSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Element: RawSyntaxNodeProtocol { - case `switchCase`(RawSwitchCaseSyntax) - case `ifConfigDecl`(RawIfConfigDeclSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawSwitchCaseSyntax.isKindOf(raw) || RawIfConfigDeclSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .switchCase(let node): return node.raw - case .ifConfigDecl(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawSwitchCaseSyntax(other) { - self = .switchCase(node) - return - } - if let node = RawIfConfigDeclSyntax(other) { - self = .ifConfigDecl(node) - return - } - return nil - } - } - - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCaseList - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init(elements: [Element], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .switchCaseList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { return } - for elem in elements { - ptr.initialize(to: elem.raw) - ptr += 1 - } - } - self.init(raw: raw) - } - - public var elements: [RawSyntax] { - layoutView.children.map { RawSyntax(raw: $0!) } - } -} - @_spi(RawSyntax) public struct RawRepeatWhileStmtSyntax: RawStmtSyntaxNodeProtocol { @@ -13671,110 +14238,17 @@ public struct RawForInStmtSyntax: RawStmtSyntaxNodeProtocol { public var unexpectedBetweenSequenceExprAndWhereClause: RawUnexpectedNodesSyntax? { layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var whereClause: RawWhereClauseSyntax? { - layoutView.children[17].map(RawWhereClauseSyntax.init(raw:)) - } - public var unexpectedBetweenWhereClauseAndBody: RawUnexpectedNodesSyntax? { - layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var body: RawCodeBlockSyntax { - layoutView.children[19].map(RawCodeBlockSyntax.init(raw:))! - } - public var unexpectedAfterBody: RawUnexpectedNodesSyntax? { - layoutView.children[20].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawSwitchStmtSyntax: RawStmtSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchStmt - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init( - _ unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? = nil, - switchKeyword: RawTokenSyntax, - _ unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? = nil, - leftBrace: RawTokenSyntax, - _ unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? = nil, - cases: RawSwitchCaseListSyntax, - _ unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? = nil, - rightBrace: RawTokenSyntax, - _ unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - assert(switchKeyword.tokenKind == .keyword(.switch), "Received \(switchKeyword.tokenKind)") - assert(leftBrace.tokenKind.base == .leftBrace, "Received \(leftBrace.tokenKind)") - assert(rightBrace.tokenKind.base == .rightBrace, "Received \(rightBrace.tokenKind)") - let raw = RawSyntax.makeLayout( - kind: .switchStmt, uninitializedCount: 11, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeSwitchKeyword?.raw - layout[1] = switchKeyword.raw - layout[2] = unexpectedBetweenSwitchKeywordAndExpression?.raw - layout[3] = expression.raw - layout[4] = unexpectedBetweenExpressionAndLeftBrace?.raw - layout[5] = leftBrace.raw - layout[6] = unexpectedBetweenLeftBraceAndCases?.raw - layout[7] = cases.raw - layout[8] = unexpectedBetweenCasesAndRightBrace?.raw - layout[9] = rightBrace.raw - layout[10] = unexpectedAfterRightBrace?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeSwitchKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var switchKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenSwitchKeywordAndExpression: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var expression: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! - } - public var unexpectedBetweenExpressionAndLeftBrace: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftBrace: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftBraceAndCases: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var cases: RawSwitchCaseListSyntax { - layoutView.children[7].map(RawSwitchCaseListSyntax.init(raw:))! + public var whereClause: RawWhereClauseSyntax? { + layoutView.children[17].map(RawWhereClauseSyntax.init(raw:)) } - public var unexpectedBetweenCasesAndRightBrace: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedBetweenWhereClauseAndBody: RawUnexpectedNodesSyntax? { + layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightBrace: RawTokenSyntax { - layoutView.children[9].map(RawTokenSyntax.init(raw:))! + public var body: RawCodeBlockSyntax { + layoutView.children[19].map(RawCodeBlockSyntax.init(raw:))! } - public var unexpectedAfterRightBrace: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + public var unexpectedAfterBody: RawUnexpectedNodesSyntax? { + layoutView.children[20].map(RawUnexpectedNodesSyntax.init(raw:)) } } @@ -14104,250 +14578,16 @@ public struct RawYieldListSyntax: RawSyntaxNodeProtocol { public var unexpectedBetweenElementListAndRightParen: 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 RawFallthroughStmtSyntax: RawStmtSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .fallthroughStmt - } - - 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( - _ unexpectedBeforeFallthroughKeyword: RawUnexpectedNodesSyntax? = nil, - fallthroughKeyword: RawTokenSyntax, - _ unexpectedAfterFallthroughKeyword: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - assert(fallthroughKeyword.tokenKind == .keyword(.fallthrough), "Received \(fallthroughKeyword.tokenKind)") - let raw = RawSyntax.makeLayout( - kind: .fallthroughStmt, uninitializedCount: 3, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeFallthroughKeyword?.raw - layout[1] = fallthroughKeyword.raw - layout[2] = unexpectedAfterFallthroughKeyword?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeFallthroughKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var fallthroughKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterFallthroughKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawBreakStmtSyntax: RawStmtSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .breakStmt - } - - 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( - _ unexpectedBeforeBreakKeyword: RawUnexpectedNodesSyntax? = nil, - breakKeyword: RawTokenSyntax, - _ unexpectedBetweenBreakKeywordAndLabel: RawUnexpectedNodesSyntax? = nil, - label: RawTokenSyntax?, - _ unexpectedAfterLabel: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - assert(breakKeyword.tokenKind == .keyword(.break), "Received \(breakKeyword.tokenKind)") - assert(label == nil || label?.tokenKind.base == .identifier, "Received \(String(describing: label?.tokenKind))") - let raw = RawSyntax.makeLayout( - kind: .breakStmt, uninitializedCount: 5, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeBreakKeyword?.raw - layout[1] = breakKeyword.raw - layout[2] = unexpectedBetweenBreakKeywordAndLabel?.raw - layout[3] = label?.raw - layout[4] = unexpectedAfterLabel?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeBreakKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var breakKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenBreakKeywordAndLabel: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var label: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedAfterLabel: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawCaseItemListSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .caseItemList - } - - 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: [RawCaseItemSyntax], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .caseItemList, 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: [RawCaseItemSyntax] { - layoutView.children.map { RawCaseItemSyntax(raw: $0!) } - } -} - -@_spi(RawSyntax) -public struct RawCatchItemListSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .catchItemList - } - - 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: [RawCatchItemSyntax], arena: __shared SyntaxArena) { - let raw = RawSyntax.makeLayout( - kind: .catchItemList, 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: [RawCatchItemSyntax] { - layoutView.children.map { RawCatchItemSyntax(raw: $0!) } - } -} - -@_spi(RawSyntax) -public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Condition: RawSyntaxNodeProtocol { - case `expression`(RawExprSyntax) - case `availability`(RawAvailabilityConditionSyntax) - case `matchingPattern`(RawMatchingPatternConditionSyntax) - case `optionalBinding`(RawOptionalBindingConditionSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawExprSyntax.isKindOf(raw) || RawAvailabilityConditionSyntax.isKindOf(raw) || RawMatchingPatternConditionSyntax.isKindOf(raw) || RawOptionalBindingConditionSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .expression(let node): return node.raw - case .availability(let node): return node.raw - case .matchingPattern(let node): return node.raw - case .optionalBinding(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawExprSyntax(other) { - self = .expression(node) - return - } - if let node = RawAvailabilityConditionSyntax(other) { - self = .availability(node) - return - } - if let node = RawMatchingPatternConditionSyntax(other) { - self = .matchingPattern(node) - return - } - if let node = RawOptionalBindingConditionSyntax(other) { - self = .optionalBinding(node) - return - } - return nil - } + 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 RawFallthroughStmtSyntax: RawStmtSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14355,7 +14595,7 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .conditionElement + return raw.kind == .fallthroughStmt } public var raw: RawSyntax @@ -14370,45 +14610,35 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeCondition: RawUnexpectedNodesSyntax? = nil, - condition: Condition, - _ unexpectedBetweenConditionAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeFallthroughKeyword: RawUnexpectedNodesSyntax? = nil, + fallthroughKeyword: RawTokenSyntax, + _ unexpectedAfterFallthroughKeyword: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") + assert(fallthroughKeyword.tokenKind == .keyword(.fallthrough), "Received \(fallthroughKeyword.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .conditionElement, uninitializedCount: 5, arena: arena) { layout in + kind: .fallthroughStmt, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeCondition?.raw - layout[1] = condition.raw - layout[2] = unexpectedBetweenConditionAndTrailingComma?.raw - layout[3] = trailingComma?.raw - layout[4] = unexpectedAfterTrailingComma?.raw + layout[0] = unexpectedBeforeFallthroughKeyword?.raw + layout[1] = fallthroughKeyword.raw + layout[2] = unexpectedAfterFallthroughKeyword?.raw } self.init(raw: raw) } - public var unexpectedBeforeCondition: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeFallthroughKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var condition: RawSyntax { - layoutView.children[1]! + public var fallthroughKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenConditionAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterFallthroughKeyword: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var trailingComma: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) -public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { +public struct RawBreakStmtSyntax: RawStmtSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14416,7 +14646,7 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .availabilityCondition + return raw.kind == .breakStmt } public var raw: RawSyntax @@ -14431,67 +14661,46 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? = nil, - availabilityKeyword: RawTokenSyntax, - _ unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? = nil, - availabilitySpec: RawAvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBreakKeyword: RawUnexpectedNodesSyntax? = nil, + breakKeyword: RawTokenSyntax, + _ unexpectedBetweenBreakKeywordAndLabel: RawUnexpectedNodesSyntax? = nil, + label: RawTokenSyntax?, + _ unexpectedAfterLabel: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(availabilityKeyword.tokenKind.base == .poundAvailableKeyword || availabilityKeyword.tokenKind.base == .poundUnavailableKeyword, "Received \(availabilityKeyword.tokenKind)") - assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") - assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") + assert(breakKeyword.tokenKind == .keyword(.break), "Received \(breakKeyword.tokenKind)") + assert(label == nil || label?.tokenKind.base == .identifier, "Received \(String(describing: label?.tokenKind))") let raw = RawSyntax.makeLayout( - kind: .availabilityCondition, uninitializedCount: 9, arena: arena) { layout in + kind: .breakStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAvailabilityKeyword?.raw - layout[1] = availabilityKeyword.raw - layout[2] = unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndAvailabilitySpec?.raw - layout[5] = availabilitySpec.raw - layout[6] = unexpectedBetweenAvailabilitySpecAndRightParen?.raw - layout[7] = rightParen.raw - layout[8] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforeBreakKeyword?.raw + layout[1] = breakKeyword.raw + layout[2] = unexpectedBetweenBreakKeywordAndLabel?.raw + layout[3] = label?.raw + layout[4] = unexpectedAfterLabel?.raw } self.init(raw: raw) } - public var unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeBreakKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var availabilityKeyword: RawTokenSyntax { + public var breakKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenBreakKeywordAndLabel: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var label: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? { + public var unexpectedAfterLabel: 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 { +public struct RawCaseItemListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14499,7 +14708,7 @@ public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .matchingPatternCondition + return raw.kind == .caseItemList } public var raw: RawSyntax @@ -14513,66 +14722,25 @@ public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { 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 - ) { - assert(caseKeyword.tokenKind == .keyword(.case), "Received \(caseKeyword.tokenKind)") + public init(elements: [RawCaseItemSyntax], 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 + kind: .caseItemList, 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 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:)) + public var elements: [RawCaseItemSyntax] { + layoutView.children.map { RawCaseItemSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { +public struct RawCatchItemListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14580,7 +14748,7 @@ public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .optionalBindingCondition + return raw.kind == .catchItemList } public var raw: RawSyntax @@ -14594,66 +14762,66 @@ public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { 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 - ) { - assert(letOrVarKeyword.tokenKind == .keyword(.let) || letOrVarKeyword.tokenKind == .keyword(.var), "Received \(letOrVarKeyword.tokenKind)") + public init(elements: [RawCatchItemSyntax], 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 + kind: .catchItemList, 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 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 elements: [RawCatchItemSyntax] { + layoutView.children.map { RawCatchItemSyntax(raw: $0!) } } - public var unexpectedAfterInitializer: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) +} + +@_spi(RawSyntax) +public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { + @frozen // FIXME: Not actually stable, works around a miscompile + public enum Condition: RawSyntaxNodeProtocol { + case `expression`(RawExprSyntax) + case `availability`(RawAvailabilityConditionSyntax) + case `matchingPattern`(RawMatchingPatternConditionSyntax) + case `optionalBinding`(RawOptionalBindingConditionSyntax) + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return RawExprSyntax.isKindOf(raw) || RawAvailabilityConditionSyntax.isKindOf(raw) || RawMatchingPatternConditionSyntax.isKindOf(raw) || RawOptionalBindingConditionSyntax.isKindOf(raw) + } + + public var raw: RawSyntax { + switch self { + case .expression(let node): return node.raw + case .availability(let node): return node.raw + case .matchingPattern(let node): return node.raw + case .optionalBinding(let node): return node.raw + } + } + + public init?(_ other: T) where T : RawSyntaxNodeProtocol { + if let node = RawExprSyntax(other) { + self = .expression(node) + return + } + if let node = RawAvailabilityConditionSyntax(other) { + self = .availability(node) + return + } + if let node = RawMatchingPatternConditionSyntax(other) { + self = .matchingPattern(node) + return + } + if let node = RawOptionalBindingConditionSyntax(other) { + self = .optionalBinding(node) + return + } + return nil + } } -} -@_spi(RawSyntax) -public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14661,7 +14829,7 @@ public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .conditionElementList + return raw.kind == .conditionElement } public var raw: RawSyntax @@ -14675,25 +14843,46 @@ public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawConditionElementSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforeCondition: RawUnexpectedNodesSyntax? = nil, + condition: Condition, + _ unexpectedBetweenConditionAndTrailingComma: RawUnexpectedNodesSyntax? = nil, + trailingComma: RawTokenSyntax?, + _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") 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 - } + kind: .conditionElement, uninitializedCount: 5, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeCondition?.raw + layout[1] = condition.raw + layout[2] = unexpectedBetweenConditionAndTrailingComma?.raw + layout[3] = trailingComma?.raw + layout[4] = unexpectedAfterTrailingComma?.raw } self.init(raw: raw) } - public var elements: [RawConditionElementSyntax] { - layoutView.children.map { RawConditionElementSyntax(raw: $0!) } + public var unexpectedBeforeCondition: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var condition: RawSyntax { + layoutView.children[1]! + } + public var unexpectedBetweenConditionAndTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var trailingComma: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { +public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14701,7 +14890,7 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .throwStmt + return raw.kind == .availabilityCondition } public var raw: RawSyntax @@ -14716,73 +14905,67 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } public init( - _ unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? = nil, - throwKeyword: RawTokenSyntax, - _ unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, - expression: RawExprSyntax, - _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? = nil, + availabilityKeyword: RawTokenSyntax, + _ unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndAvailabilitySpec: RawUnexpectedNodesSyntax? = nil, + availabilitySpec: RawAvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { + assert(availabilityKeyword.tokenKind.base == .poundAvailableKeyword || availabilityKeyword.tokenKind.base == .poundUnavailableKeyword, "Received \(availabilityKeyword.tokenKind)") + assert(leftParen.tokenKind.base == .leftParen, "Received \(leftParen.tokenKind)") + assert(rightParen.tokenKind.base == .rightParen, "Received \(rightParen.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .throwStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .availabilityCondition, 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] = unexpectedBeforeAvailabilityKeyword?.raw + layout[1] = availabilityKeyword.raw + layout[2] = unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw + layout[3] = leftParen.raw + layout[4] = unexpectedBetweenLeftParenAndAvailabilitySpec?.raw + layout[5] = availabilitySpec.raw + layout[6] = unexpectedBetweenAvailabilitySpecAndRightParen?.raw + layout[7] = rightParen.raw + layout[8] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAvailabilityKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var throwKeyword: RawTokenSyntax { + public var availabilityKeyword: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityKeywordAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var expression: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! + public var leftParen: RawTokenSyntax { + layoutView.children[3].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? { + 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 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 RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14790,7 +14973,7 @@ public struct RawIfStmtSyntax: RawStmtSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .ifStmt + return raw.kind == .matchingPatternCondition } public var raw: RawSyntax @@ -14805,104 +14988,65 @@ 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, + _ 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 ) { - assert(ifKeyword.tokenKind == .keyword(.if), "Received \(ifKeyword.tokenKind)") + assert(caseKeyword.tokenKind == .keyword(.case), "Received \(caseKeyword.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .ifStmt, uninitializedCount: 11, arena: arena) { layout in + kind: .matchingPatternCondition, 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] = 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 unexpectedBeforeIfKeyword: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var ifKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenIfKeywordAndConditions: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var conditions: RawConditionElementListSyntax { - layoutView.children[3].map(RawConditionElementListSyntax.init(raw:))! - } - public var unexpectedBetweenConditionsAndBody: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var body: RawCodeBlockSyntax { - layoutView.children[5].map(RawCodeBlockSyntax.init(raw:))! - } - public var unexpectedBetweenBodyAndElseKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var elseKeyword: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenElseKeywordAndElseBody: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var elseBody: RawSyntax? { - layoutView.children[9] - } - public var unexpectedAfterElseBody: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { - @frozen // FIXME: Not actually stable, works around a miscompile - public enum Label: RawSyntaxNodeProtocol { - case `default`(RawSwitchDefaultLabelSyntax) - case `case`(RawSwitchCaseLabelSyntax) - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return RawSwitchDefaultLabelSyntax.isKindOf(raw) || RawSwitchCaseLabelSyntax.isKindOf(raw) - } - - public var raw: RawSyntax { - switch self { - case .default(let node): return node.raw - case .case(let node): return node.raw - } - } - - public init?(_ other: T) where T : RawSyntaxNodeProtocol { - if let node = RawSwitchDefaultLabelSyntax(other) { - self = .default(node) - return - } - if let node = RawSwitchCaseLabelSyntax(other) { - self = .case(node) - return - } - return nil - } + public 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 { @@ -14910,7 +15054,7 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCase + return raw.kind == .optionalBindingCondition } public var raw: RawSyntax @@ -14925,54 +15069,65 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? = nil, - unknownAttr: RawAttributeSyntax?, - _ unexpectedBetweenUnknownAttrAndLabel: RawUnexpectedNodesSyntax? = nil, - label: Label, - _ unexpectedBetweenLabelAndStatements: RawUnexpectedNodesSyntax? = nil, - statements: RawCodeBlockItemListSyntax, - _ unexpectedAfterStatements: 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 ) { + assert(letOrVarKeyword.tokenKind == .keyword(.let) || letOrVarKeyword.tokenKind == .keyword(.var), "Received \(letOrVarKeyword.tokenKind)") let raw = RawSyntax.makeLayout( - kind: .switchCase, uninitializedCount: 7, arena: arena) { layout in + kind: .optionalBindingCondition, 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] = 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 unexpectedBeforeUnknownAttr: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLetOrVarKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var unknownAttr: RawAttributeSyntax? { - layoutView.children[1].map(RawAttributeSyntax.init(raw:)) + public var letOrVarKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenUnknownAttrAndLabel: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLetOrVarKeywordAndPattern: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var label: RawSyntax { - layoutView.children[3]! + public var pattern: RawPatternSyntax { + layoutView.children[3].map(RawPatternSyntax.init(raw:))! } - public var unexpectedBetweenLabelAndStatements: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var statements: RawCodeBlockItemListSyntax { - layoutView.children[5].map(RawCodeBlockItemListSyntax.init(raw:))! + public var typeAnnotation: RawTypeAnnotationSyntax? { + layoutView.children[5].map(RawTypeAnnotationSyntax.init(raw:)) } - public var unexpectedAfterStatements: RawUnexpectedNodesSyntax? { + 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 RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { +public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -14980,7 +15135,7 @@ public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchDefaultLabel + return raw.kind == .conditionElementList } public var raw: RawSyntax @@ -14994,47 +15149,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 - ) { - assert(defaultKeyword.tokenKind == .keyword(.default), "Received \(defaultKeyword.tokenKind)") - assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") + public init(elements: [RawConditionElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .switchDefaultLabel, uninitializedCount: 5, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeDefaultKeyword?.raw - layout[1] = defaultKeyword.raw - layout[2] = unexpectedBetweenDefaultKeywordAndColon?.raw - layout[3] = colon.raw - layout[4] = unexpectedAfterColon?.raw + kind: .conditionElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { return } + for elem in elements { + ptr.initialize(to: elem.raw) + ptr += 1 + } } self.init(raw: raw) } - public var unexpectedBeforeDefaultKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var defaultKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenDefaultKeywordAndColon: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var colon: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + public var elements: [RawConditionElementSyntax] { + layoutView.children.map { RawConditionElementSyntax(raw: $0!) } } } @_spi(RawSyntax) -public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { +public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -15042,7 +15175,7 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .caseItem + return raw.kind == .throwStmt } public var raw: RawSyntax @@ -15057,51 +15190,40 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforePattern: RawUnexpectedNodesSyntax? = nil, - pattern: RawPatternSyntax, - _ unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? = nil, - whereClause: RawWhereClauseSyntax?, - _ unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? = nil, - trailingComma: RawTokenSyntax?, - _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? = nil, + throwKeyword: RawTokenSyntax, + _ unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? = nil, + expression: RawExprSyntax, + _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { - assert(trailingComma == nil || trailingComma?.tokenKind.base == .comma, "Received \(String(describing: trailingComma?.tokenKind))") let raw = RawSyntax.makeLayout( - kind: .caseItem, uninitializedCount: 7, arena: arena) { layout in + kind: .throwStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePattern?.raw - layout[1] = pattern.raw - layout[2] = unexpectedBetweenPatternAndWhereClause?.raw - layout[3] = whereClause?.raw - layout[4] = unexpectedBetweenWhereClauseAndTrailingComma?.raw - layout[5] = trailingComma?.raw - layout[6] = unexpectedAfterTrailingComma?.raw + layout[0] = unexpectedBeforeThrowKeyword?.raw + layout[1] = throwKeyword.raw + layout[2] = unexpectedBetweenThrowKeywordAndExpression?.raw + layout[3] = expression.raw + layout[4] = unexpectedAfterExpression?.raw } self.init(raw: raw) } - public var unexpectedBeforePattern: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeThrowKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var pattern: RawPatternSyntax { - layoutView.children[1].map(RawPatternSyntax.init(raw:))! + public var throwKeyword: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenPatternAndWhereClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowKeywordAndExpression: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var whereClause: RawWhereClauseSyntax? { - layoutView.children[3].map(RawWhereClauseSyntax.init(raw:)) + public var expression: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! } - public var unexpectedBetweenWhereClauseAndTrailingComma: RawUnexpectedNodesSyntax? { + public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var trailingComma: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) @@ -15175,78 +15297,6 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol { } } -@_spi(RawSyntax) -public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .switchCaseLabel - } - - public var raw: RawSyntax - init(raw: RawSyntax) { - assert(Self.isKindOf(raw)) - self.raw = raw - } - - public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { return nil } - self.init(raw: other.raw) - } - - public init( - _ unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? = nil, - caseKeyword: RawTokenSyntax, - _ unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? = nil, - caseItems: RawCaseItemListSyntax, - _ unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax, - _ unexpectedAfterColon: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - assert(caseKeyword.tokenKind == .keyword(.case), "Received \(caseKeyword.tokenKind)") - assert(colon.tokenKind.base == .colon, "Received \(colon.tokenKind)") - let raw = RawSyntax.makeLayout( - kind: .switchCaseLabel, uninitializedCount: 7, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeCaseKeyword?.raw - layout[1] = caseKeyword.raw - layout[2] = unexpectedBetweenCaseKeywordAndCaseItems?.raw - layout[3] = caseItems.raw - layout[4] = unexpectedBetweenCaseItemsAndColon?.raw - layout[5] = colon.raw - layout[6] = unexpectedAfterColon?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeCaseKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var caseKeyword: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenCaseKeywordAndCaseItems: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var caseItems: RawCaseItemListSyntax { - layoutView.children[3].map(RawCaseItemListSyntax.init(raw:))! - } - public var unexpectedBetweenCaseItemsAndColon: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var colon: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterColon: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - @_spi(RawSyntax) public struct RawCatchClauseSyntax: RawSyntaxNodeProtocol { diff --git a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift index a18a2efd912..d8ca67d5cad 100644 --- a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift @@ -425,6 +425,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)) @@ -1882,6 +1962,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 5, verify(layout[5], as: RawStmtSyntax.self)) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) break + case .expressionStmt: + assert(layout.count == 3) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawExprSyntax.self)) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + break case .continueStmt: assert(layout.count == 5) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1908,14 +1994,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 3, verify(layout[3], as: RawCodeBlockSyntax.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) break - case .switchCaseList: - for (index, element) in layout.enumerated() { - assertAnyHasNoError(kind, index, [ - verify(element, as: RawSwitchCaseSyntax.self), - verify(element, as: RawIfConfigDeclSyntax.self), - ]) - } - break case .repeatWhileStmt: assert(layout.count == 9) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1972,20 +2050,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)) @@ -2116,54 +2180,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)) @@ -2174,16 +2190,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 4245fb6aa10..bd264353934 100644 --- a/Sources/SwiftSyntax/generated/Misc.swift +++ b/Sources/SwiftSyntax/generated/Misc.swift @@ -117,6 +117,7 @@ extension Syntax { .node(ExprListSyntax.self), .node(ExpressionPatternSyntax.self), .node(ExpressionSegmentSyntax.self), + .node(ExpressionStmtSyntax.self), .node(ExtensionDeclSyntax.self), .node(FallthroughStmtSyntax.self), .node(FloatLiteralExprSyntax.self), @@ -143,7 +144,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), @@ -241,7 +242,7 @@ extension Syntax { .node(SwitchCaseListSyntax.self), .node(SwitchCaseSyntax.self), .node(SwitchDefaultLabelSyntax.self), - .node(SwitchStmtSyntax.self), + .node(SwitchExprSyntax.self), .node(TargetFunctionEntrySyntax.self), .node(TernaryExprSyntax.self), .node(ThrowStmtSyntax.self), @@ -482,6 +483,8 @@ extension SyntaxKind { return ExpressionPatternSyntax.self case .expressionSegment: return ExpressionSegmentSyntax.self + case .expressionStmt: + return ExpressionStmtSyntax.self case .extensionDecl: return ExtensionDeclSyntax.self case .fallthroughStmt: @@ -534,8 +537,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: @@ -730,8 +733,8 @@ extension SyntaxKind { return SwitchCaseSyntax.self case .switchDefaultLabel: return SwitchDefaultLabelSyntax.self - case .switchStmt: - return SwitchStmtSyntax.self + case .switchExpr: + return SwitchExprSyntax.self case .targetFunctionEntry: return TargetFunctionEntrySyntax.self case .ternaryExpr: @@ -1007,6 +1010,8 @@ extension SyntaxKind { return "pattern" case .expressionSegment: return nil + case .expressionStmt: + return "expression" case .extensionDecl: return "extension" case .fallthroughStmt: @@ -1059,7 +1064,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" @@ -1255,7 +1260,7 @@ extension SyntaxKind { return "switch case" case .switchDefaultLabel: return nil - case .switchStmt: + case .switchExpr: return "'switch' statement" case .targetFunctionEntry: return "attribute argument" diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index a12067b7c69..22eaf572893 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -841,6 +841,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ExpressionStmtSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ExpressionStmtSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -1049,11 +1057,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) } @@ -1833,11 +1841,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 0532b60238c..b41588d8041 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -222,7 +222,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public init?(_ node: S) { switch node.raw.kind { - case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: + case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: self._syntaxNode = node._syntaxNode default: return nil @@ -235,7 +235,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { internal init(_ data: SyntaxData) { #if DEBUG switch data.raw.kind { - case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: + case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: break default: fatalError("Unable to create ExprSyntax from \(data.raw.kind)") @@ -287,6 +287,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), @@ -309,6 +310,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { .node(StringLiteralExprSyntax.self), .node(SubscriptExprSyntax.self), .node(SuperRefExprSyntax.self), + .node(SwitchExprSyntax.self), .node(TernaryExprSyntax.self), .node(TryExprSyntax.self), .node(TupleExprSyntax.self), @@ -523,7 +525,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public init?(_ node: S) { switch node.raw.kind { - case .breakStmt, .continueStmt, .deferStmt, .doStmt, .fallthroughStmt, .forInStmt, .guardStmt, .ifStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .switchStmt, .throwStmt, .whileStmt, .yieldStmt: + case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: self._syntaxNode = node._syntaxNode default: return nil @@ -536,7 +538,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { internal init(_ data: SyntaxData) { #if DEBUG switch data.raw.kind { - case .breakStmt, .continueStmt, .deferStmt, .doStmt, .fallthroughStmt, .forInStmt, .guardStmt, .ifStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .switchStmt, .throwStmt, .whileStmt, .yieldStmt: + case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: break default: fatalError("Unable to create StmtSyntax from \(data.raw.kind)") @@ -576,15 +578,14 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { .node(ContinueStmtSyntax.self), .node(DeferStmtSyntax.self), .node(DoStmtSyntax.self), + .node(ExpressionStmtSyntax.self), .node(FallthroughStmtSyntax.self), .node(ForInStmtSyntax.self), .node(GuardStmtSyntax.self), - .node(IfStmtSyntax.self), .node(LabeledStmtSyntax.self), .node(MissingStmtSyntax.self), .node(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 a9aa6ccb3f4..b0ec652c716 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -215,6 +215,8 @@ public enum SyntaxEnum { case expressionSegment(ExpressionSegmentSyntax) + case expressionStmt(ExpressionStmtSyntax) + case extensionDecl(ExtensionDeclSyntax) case fallthroughStmt(FallthroughStmtSyntax) @@ -267,7 +269,7 @@ public enum SyntaxEnum { case ifConfigDecl(IfConfigDeclSyntax) - case ifStmt(IfStmtSyntax) + case ifExpr(IfExprSyntax) case implementsAttributeArguments(ImplementsAttributeArgumentsSyntax) @@ -463,7 +465,7 @@ public enum SyntaxEnum { case switchDefaultLabel(SwitchDefaultLabelSyntax) - case switchStmt(SwitchStmtSyntax) + case switchExpr(SwitchExprSyntax) case targetFunctionEntry(TargetFunctionEntrySyntax) @@ -740,6 +742,8 @@ public extension Syntax { return .expressionPattern(ExpressionPatternSyntax(self)!) case .expressionSegment: return .expressionSegment(ExpressionSegmentSyntax(self)!) + case .expressionStmt: + return .expressionStmt(ExpressionStmtSyntax(self)!) case .extensionDecl: return .extensionDecl(ExtensionDeclSyntax(self)!) case .fallthroughStmt: @@ -792,8 +796,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: @@ -988,8 +992,8 @@ public extension Syntax { return .switchCase(SwitchCaseSyntax(self)!) case .switchDefaultLabel: return .switchDefaultLabel(SwitchDefaultLabelSyntax(self)!) - case .switchStmt: - return .switchStmt(SwitchStmtSyntax(self)!) + case .switchExpr: + return .switchExpr(SwitchExprSyntax(self)!) case .targetFunctionEntry: return .targetFunctionEntry(TargetFunctionEntrySyntax(self)!) case .ternaryExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index a04dfa29530..a869aa889a8 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -215,6 +215,8 @@ public enum SyntaxKind { case expressionSegment + case expressionStmt + case extensionDecl case fallthroughStmt @@ -267,7 +269,7 @@ public enum SyntaxKind { case ifConfigDecl - case ifStmt + case ifExpr case implementsAttributeArguments @@ -463,7 +465,7 @@ public enum SyntaxKind { case switchDefaultLabel - case switchStmt + case switchExpr case targetFunctionEntry diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index 087ad3f454e..54dd6470554 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -713,6 +713,13 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(ExpressionSegmentSyntax.self) } + /// Visit a `ExpressionStmtSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExpressionStmtSyntax) -> StmtSyntax { + return StmtSyntax(visitChildren(node)) + } + /// Visit a `ExtensionDeclSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -895,11 +902,11 @@ open class SyntaxRewriter { return DeclSyntax(visitChildren(node)) } - /// Visit a `IfStmtSyntax`. + /// Visit a `IfExprSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node - open func visit(_ node: IfStmtSyntax) -> StmtSyntax { - return StmtSyntax(visitChildren(node)) + open func visit(_ node: IfExprSyntax) -> ExprSyntax { + return ExprSyntax(visitChildren(node)) } /// Visit a `ImplementsAttributeArgumentsSyntax`. @@ -1581,11 +1588,11 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(SwitchDefaultLabelSyntax.self) } - /// Visit a `SwitchStmtSyntax`. + /// Visit a `SwitchExprSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node - open func visit(_ node: SwitchStmtSyntax) -> StmtSyntax { - return StmtSyntax(visitChildren(node)) + open func visit(_ node: SwitchExprSyntax) -> ExprSyntax { + return ExprSyntax(visitChildren(node)) } /// Visit a `TargetFunctionEntrySyntax`. @@ -3286,6 +3293,20 @@ open class SyntaxRewriter { return Syntax(visit(node)) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplExpressionStmtSyntax(_ data: SyntaxData) -> Syntax { + let node = ExpressionStmtSyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { + visitPost(node._syntaxNode) + } + if let newNode = visitAny(node._syntaxNode) { + return newNode + } + return Syntax(visit(node)) + } + /// Implementation detail of visit(_:). Do not call directly. private func visitImplExtensionDeclSyntax(_ data: SyntaxData) -> Syntax { let node = ExtensionDeclSyntax(data) @@ -3651,8 +3672,8 @@ open class SyntaxRewriter { } /// Implementation detail of visit(_:). Do not call directly. - private func visitImplIfStmtSyntax(_ data: SyntaxData) -> Syntax { - let node = IfStmtSyntax(data) + private func visitImplIfExprSyntax(_ data: SyntaxData) -> Syntax { + let node = IfExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) defer { @@ -5023,8 +5044,8 @@ open class SyntaxRewriter { } /// Implementation detail of visit(_:). Do not call directly. - private func visitImplSwitchStmtSyntax(_ data: SyntaxData) -> Syntax { - let node = SwitchStmtSyntax(data) + private func visitImplSwitchExprSyntax(_ data: SyntaxData) -> Syntax { + let node = SwitchExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) defer { @@ -5778,6 +5799,8 @@ open class SyntaxRewriter { return visitImplExpressionPatternSyntax case .expressionSegment: return visitImplExpressionSegmentSyntax + case .expressionStmt: + return visitImplExpressionStmtSyntax case .extensionDecl: return visitImplExtensionDeclSyntax case .fallthroughStmt: @@ -5830,8 +5853,8 @@ open class SyntaxRewriter { return visitImplIfConfigClauseSyntax case .ifConfigDecl: return visitImplIfConfigDeclSyntax - case .ifStmt: - return visitImplIfStmtSyntax + case .ifExpr: + return visitImplIfExprSyntax case .implementsAttributeArguments: return visitImplImplementsAttributeArgumentsSyntax case .implicitlyUnwrappedOptionalType: @@ -6026,8 +6049,8 @@ open class SyntaxRewriter { return visitImplSwitchCaseSyntax case .switchDefaultLabel: return visitImplSwitchDefaultLabelSyntax - case .switchStmt: - return visitImplSwitchStmtSyntax + case .switchExpr: + return visitImplSwitchExprSyntax case .targetFunctionEntry: return visitImplTargetFunctionEntrySyntax case .ternaryExpr: @@ -6306,6 +6329,8 @@ open class SyntaxRewriter { return visitImplExpressionPatternSyntax(data) case .expressionSegment: return visitImplExpressionSegmentSyntax(data) + case .expressionStmt: + return visitImplExpressionStmtSyntax(data) case .extensionDecl: return visitImplExtensionDeclSyntax(data) case .fallthroughStmt: @@ -6358,8 +6383,8 @@ open class SyntaxRewriter { return visitImplIfConfigClauseSyntax(data) case .ifConfigDecl: return visitImplIfConfigDeclSyntax(data) - case .ifStmt: - return visitImplIfStmtSyntax(data) + case .ifExpr: + return visitImplIfExprSyntax(data) case .implementsAttributeArguments: return visitImplImplementsAttributeArgumentsSyntax(data) case .implicitlyUnwrappedOptionalType: @@ -6554,8 +6579,8 @@ open class SyntaxRewriter { return visitImplSwitchCaseSyntax(data) case .switchDefaultLabel: return visitImplSwitchDefaultLabelSyntax(data) - case .switchStmt: - return visitImplSwitchStmtSyntax(data) + case .switchExpr: + return visitImplSwitchExprSyntax(data) case .targetFunctionEntry: return visitImplTargetFunctionEntrySyntax(data) case .ternaryExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index b949c6a77bb..894cb8e08b0 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -552,7 +552,7 @@ extension GenericRequirementSyntax: WithTrailingCommaSyntax { extension GuardStmtSyntax: WithCodeBlockSyntax { } -extension IfStmtSyntax: WithCodeBlockSyntax { +extension IfExprSyntax: WithCodeBlockSyntax { } extension ImportDeclSyntax: AttributedSyntax { @@ -618,7 +618,7 @@ extension SubscriptDeclSyntax: AttributedSyntax { extension SwitchCaseSyntax: WithStatementsSyntax { } -extension SwitchStmtSyntax: BracedSyntax { +extension SwitchExprSyntax: BracedSyntax { } extension TargetFunctionEntrySyntax: WithTrailingCommaSyntax { diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift index 82138d5255a..e2dc0ec8330 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift @@ -511,6 +511,11 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ExpressionSegmentSyntax) -> ResultType + /// Visiting `ExpressionStmtSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: ExpressionStmtSyntax) -> ResultType + /// Visiting `ExtensionDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -641,10 +646,10 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: IfConfigDeclSyntax) -> ResultType - /// Visiting `IfStmtSyntax` specifically. + /// Visiting `IfExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: IfStmtSyntax) -> ResultType + func visit(_ node: IfExprSyntax) -> ResultType /// Visiting `ImplementsAttributeArgumentsSyntax` specifically. /// - Parameter node: the node we are visiting. @@ -1131,10 +1136,10 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: SwitchDefaultLabelSyntax) -> ResultType - /// Visiting `SwitchStmtSyntax` specifically. + /// Visiting `SwitchExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: SwitchStmtSyntax) -> ResultType + func visit(_ node: SwitchExprSyntax) -> ResultType /// Visiting `TargetFunctionEntrySyntax` specifically. /// - Parameter node: the node we are visiting. @@ -2008,6 +2013,13 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } + /// Visiting `ExpressionStmtSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: ExpressionStmtSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting `ExtensionDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2190,10 +2202,10 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } - /// Visiting `IfStmtSyntax` specifically. + /// Visiting `IfExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. - public func visit(_ node: IfStmtSyntax) -> ResultType { + public func visit(_ node: IfExprSyntax) -> ResultType { visitAny(Syntax(node)) } @@ -2876,10 +2888,10 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } - /// Visiting `SwitchStmtSyntax` specifically. + /// Visiting `SwitchExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. - public func visit(_ node: SwitchStmtSyntax) -> ResultType { + public func visit(_ node: SwitchExprSyntax) -> ResultType { visitAny(Syntax(node)) } @@ -3335,6 +3347,8 @@ extension SyntaxTransformVisitor { return visit(derived) case .expressionSegment(let derived): return visit(derived) + case .expressionStmt(let derived): + return visit(derived) case .extensionDecl(let derived): return visit(derived) case .fallthroughStmt(let derived): @@ -3387,7 +3401,7 @@ extension SyntaxTransformVisitor { return visit(derived) case .ifConfigDecl(let derived): return visit(derived) - case .ifStmt(let derived): + case .ifExpr(let derived): return visit(derived) case .implementsAttributeArguments(let derived): return visit(derived) @@ -3583,7 +3597,7 @@ extension SyntaxTransformVisitor { return visit(derived) case .switchDefaultLabel(let derived): return visit(derived) - case .switchStmt(let derived): + case .switchExpr(let derived): return visit(derived) case .targetFunctionEntry(let derived): return visit(derived) diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index cdaf5625864..a5f0179fad3 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -1204,6 +1204,18 @@ open class SyntaxVisitor { open func visitPost(_ node: ExpressionSegmentSyntax) { } + /// Visiting `ExpressionStmtSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ExpressionStmtSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `ExpressionStmtSyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ExpressionStmtSyntax) { + } + /// Visiting `ExtensionDeclSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -1516,16 +1528,16 @@ open class SyntaxVisitor { open func visitPost(_ node: IfConfigDeclSyntax) { } - /// Visiting `IfStmtSyntax` specifically. + /// Visiting `IfExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. - open func visit(_ node: IfStmtSyntax) -> SyntaxVisitorContinueKind { + open func visit(_ node: IfExprSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } - /// The function called after visiting `IfStmtSyntax` and its descendents. + /// The function called after visiting `IfExprSyntax` and its descendents. /// - node: the node we just finished visiting. - open func visitPost(_ node: IfStmtSyntax) { + open func visitPost(_ node: IfExprSyntax) { } /// Visiting `ImplementsAttributeArgumentsSyntax` specifically. @@ -2692,16 +2704,16 @@ open class SyntaxVisitor { open func visitPost(_ node: SwitchDefaultLabelSyntax) { } - /// Visiting `SwitchStmtSyntax` specifically. + /// Visiting `SwitchExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. - open func visit(_ node: SwitchStmtSyntax) -> SyntaxVisitorContinueKind { + open func visit(_ node: SwitchExprSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } - /// The function called after visiting `SwitchStmtSyntax` and its descendents. + /// The function called after visiting `SwitchExprSyntax` and its descendents. /// - node: the node we just finished visiting. - open func visitPost(_ node: SwitchStmtSyntax) { + open func visitPost(_ node: SwitchExprSyntax) { } /// Visiting `TargetFunctionEntrySyntax` specifically. @@ -4226,6 +4238,17 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplExpressionStmtSyntax(_ data: SyntaxData) { + let node = ExpressionStmtSyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && !node.raw.layoutView!.children.isEmpty { + visitChildren(node) + } + visitPost(node) + } + /// Implementation detail of doVisit(_:_:). Do not call directly. private func visitImplExtensionDeclSyntax(_ data: SyntaxData) { let node = ExtensionDeclSyntax(data) @@ -4513,8 +4536,8 @@ open class SyntaxVisitor { } /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplIfStmtSyntax(_ data: SyntaxData) { - let node = IfStmtSyntax(data) + private func visitImplIfExprSyntax(_ data: SyntaxData) { + let node = IfExprSyntax(data) let needsChildren = (visit(node) == .visitChildren) // Avoid calling into visitChildren if possible. if needsChildren && !node.raw.layoutView!.children.isEmpty { @@ -5591,8 +5614,8 @@ open class SyntaxVisitor { } /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplSwitchStmtSyntax(_ data: SyntaxData) { - let node = SwitchStmtSyntax(data) + private func visitImplSwitchExprSyntax(_ data: SyntaxData) { + let node = SwitchExprSyntax(data) let needsChildren = (visit(node) == .visitChildren) // Avoid calling into visitChildren if possible. if needsChildren && !node.raw.layoutView!.children.isEmpty { @@ -6200,6 +6223,8 @@ open class SyntaxVisitor { visitImplExpressionPatternSyntax(data) case .expressionSegment: visitImplExpressionSegmentSyntax(data) + case .expressionStmt: + visitImplExpressionStmtSyntax(data) case .extensionDecl: visitImplExtensionDeclSyntax(data) case .fallthroughStmt: @@ -6252,8 +6277,8 @@ open class SyntaxVisitor { visitImplIfConfigClauseSyntax(data) case .ifConfigDecl: visitImplIfConfigDeclSyntax(data) - case .ifStmt: - visitImplIfStmtSyntax(data) + case .ifExpr: + visitImplIfExprSyntax(data) case .implementsAttributeArguments: visitImplImplementsAttributeArgumentsSyntax(data) case .implicitlyUnwrappedOptionalType: @@ -6448,8 +6473,8 @@ open class SyntaxVisitor { visitImplSwitchCaseSyntax(data) case .switchDefaultLabel: visitImplSwitchDefaultLabelSyntax(data) - case .switchStmt: - visitImplSwitchStmtSyntax(data) + case .switchExpr: + visitImplSwitchExprSyntax(data) case .targetFunctionEntry: visitImplTargetFunctionEntrySyntax(data) case .ternaryExpr: diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift index eaba155125e..25eca57e739 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift @@ -1347,6 +1347,248 @@ public enum SyntaxFactory { return BooleanLiteralExprSyntax(data) } } + @available(*, deprecated, message: "Use initializer on IfExprSyntax") + public static func makeIfExpr(_ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, ifKeyword: TokenSyntax, _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, conditions: ConditionElementListSyntax, _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, elseKeyword: TokenSyntax?, _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, elseBody: Syntax?, _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil) -> IfExprSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeIfKeyword?.raw, + ifKeyword.raw, + unexpectedBetweenIfKeywordAndConditions?.raw, + conditions.raw, + unexpectedBetweenConditionsAndBody?.raw, + body.raw, + unexpectedBetweenBodyAndElseKeyword?.raw, + elseKeyword?.raw, + unexpectedBetweenElseKeywordAndElseBody?.raw, + elseBody?.raw, + unexpectedAfterElseBody?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.ifExpr, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return IfExprSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on IfExprSyntax") + public static func makeBlankIfExpr(presence: SourcePresence = .present) -> IfExprSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .ifExpr, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.if), arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.conditionElementList, arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlock, arena: arena), + nil, + nil, + nil, + nil, + nil, + ], arena: arena)) + return IfExprSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchExprSyntax") + public static func makeSwitchExpr(_ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, switchKeyword: TokenSyntax, _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, leftBrace: TokenSyntax, _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, cases: SwitchCaseListSyntax, _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, rightBrace: TokenSyntax, _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil) -> SwitchExprSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeSwitchKeyword?.raw, + switchKeyword.raw, + unexpectedBetweenSwitchKeywordAndExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndCases?.raw, + cases.raw, + unexpectedBetweenCasesAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchExpr, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchExprSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchExprSyntax") + public static func makeBlankSwitchExpr(presence: SourcePresence = .present) -> SwitchExprSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchExpr, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.switch), arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.switchCaseList, arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena), + nil, + ], arena: arena)) + return SwitchExprSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") + public static func makeSwitchCaseList( + _ elements: [Syntax]) -> SwitchCaseListSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + from: elements.map { $0.raw }, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchCaseListSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") + public static func makeBlankSwitchCaseList(presence: SourcePresence = .present) -> SwitchCaseListSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseList, + from: [ + ], arena: arena)) + return SwitchCaseListSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") + public static func makeSwitchCase(_ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, unknownAttr: AttributeSyntax?, _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, label: Syntax, _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, statements: CodeBlockItemListSyntax, _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil) -> SwitchCaseSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeUnknownAttr?.raw, + unknownAttr?.raw, + unexpectedBetweenUnknownAttrAndLabel?.raw, + label.raw, + unexpectedBetweenLabelAndStatements?.raw, + statements.raw, + unexpectedAfterStatements?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCase, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchCaseSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") + public static func makeBlankSwitchCase(presence: SourcePresence = .present) -> SwitchCaseSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCase, + from: [ + nil, + nil, + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena), + nil, + ], arena: arena)) + return SwitchCaseSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") + public static func makeSwitchCaseLabel(_ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, caseKeyword: TokenSyntax, _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, caseItems: CaseItemListSyntax, _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchCaseLabelSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeCaseKeyword?.raw, + caseKeyword.raw, + unexpectedBetweenCaseKeywordAndCaseItems?.raw, + caseItems.raw, + unexpectedBetweenCaseItemsAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseLabel, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchCaseLabelSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") + public static func makeBlankSwitchCaseLabel(presence: SourcePresence = .present) -> SwitchCaseLabelSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseLabel, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.case), arena: arena), + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.caseItemList, arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), + nil, + ], arena: arena)) + return SwitchCaseLabelSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") + public static func makeSwitchDefaultLabel(_ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, defaultKeyword: TokenSyntax, _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchDefaultLabelSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeDefaultKeyword?.raw, + defaultKeyword.raw, + unexpectedBetweenDefaultKeywordAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchDefaultLabel, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return SwitchDefaultLabelSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") + public static func makeBlankSwitchDefaultLabel(presence: SourcePresence = .present) -> SwitchDefaultLabelSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchDefaultLabel, + from: [ + nil, + RawSyntax.makeMissingToken(kind: TokenKind.keyword(.default), arena: arena), + nil, + RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), + nil, + ], arena: arena)) + return SwitchDefaultLabelSyntax(data) + } + } + @available(*, deprecated, message: "Use initializer on CaseItemSyntax") + public static func makeCaseItem(_ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, pattern: PatternSyntax, _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, whereClause: WhereClauseSyntax?, _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> CaseItemSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndWhereClause?.raw, + whereClause?.raw, + unexpectedBetweenWhereClauseAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.caseItem, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return CaseItemSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on CaseItemSyntax") + public static func makeBlankCaseItem(presence: SourcePresence = .present) -> CaseItemSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .caseItem, + from: [ + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena), + nil, + nil, + nil, + nil, + nil, + ], arena: arena)) + return CaseItemSyntax(data) + } + } @available(*, deprecated, message: "Use initializer on UnresolvedTernaryExprSyntax") public static func makeUnresolvedTernaryExpr(_ unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? = nil, questionMark: TokenSyntax, _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, firstChoice: ExprSyntax, _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, colonMark: TokenSyntax, _ unexpectedAfterColonMark: UnexpectedNodesSyntax? = nil) -> UnresolvedTernaryExprSyntax { let layout: [RawSyntax?] = [ @@ -6014,6 +6256,33 @@ public enum SyntaxFactory { return LabeledStmtSyntax(data) } } + @available(*, deprecated, message: "Use initializer on ExpressionStmtSyntax") + public static func makeExpressionStmt(_ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil) -> ExpressionStmtSyntax { + let layout: [RawSyntax?] = [ + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedAfterExpression?.raw, + ] + return withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.expressionStmt, + from: layout, arena: arena) + let data = SyntaxData.forRoot(raw) + return ExpressionStmtSyntax(data) + } + } + + @available(*, deprecated, message: "Use initializer on ExpressionStmtSyntax") + public static func makeBlankExpressionStmt(presence: SourcePresence = .present) -> ExpressionStmtSyntax { + return withExtendedLifetime(SyntaxArena()) { arena in + let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .expressionStmt, + from: [ + nil, + RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena), + nil, + ], arena: arena)) + return ExpressionStmtSyntax(data) + } + } @available(*, deprecated, message: "Use initializer on ContinueStmtSyntax") public static func makeContinueStmt(_ unexpectedBeforeContinueKeyword: UnexpectedNodesSyntax? = nil, continueKeyword: TokenSyntax, _ unexpectedBetweenContinueKeywordAndLabel: UnexpectedNodesSyntax? = nil, label: TokenSyntax?, _ unexpectedAfterLabel: UnexpectedNodesSyntax? = nil) -> ContinueStmtSyntax { let layout: [RawSyntax?] = [ @@ -6111,26 +6380,6 @@ public enum SyntaxFactory { return DeferStmtSyntax(data) } } - @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") - public static func makeSwitchCaseList( - _ elements: [Syntax]) -> SwitchCaseListSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, - from: elements.map { $0.raw }, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchCaseListSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchCaseListSyntax") - public static func makeBlankSwitchCaseList(presence: SourcePresence = .present) -> SwitchCaseListSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseList, - from: [ - ], arena: arena)) - return SwitchCaseListSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on RepeatWhileStmtSyntax") public static func makeRepeatWhileStmt(_ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, repeatKeyword: TokenSyntax, _ unexpectedBetweenRepeatKeywordAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedBetweenBodyAndWhileKeyword: UnexpectedNodesSyntax? = nil, whileKeyword: TokenSyntax, _ unexpectedBetweenWhileKeywordAndCondition: UnexpectedNodesSyntax? = nil, condition: ExprSyntax, _ unexpectedAfterCondition: UnexpectedNodesSyntax? = nil) -> RepeatWhileStmtSyntax { let layout: [RawSyntax?] = [ @@ -6303,49 +6552,6 @@ public enum SyntaxFactory { return ForInStmtSyntax(data) } } - @available(*, deprecated, message: "Use initializer on SwitchStmtSyntax") - public static func makeSwitchStmt(_ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, switchKeyword: TokenSyntax, _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, leftBrace: TokenSyntax, _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, cases: SwitchCaseListSyntax, _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, rightBrace: TokenSyntax, _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil) -> SwitchStmtSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeSwitchKeyword?.raw, - switchKeyword.raw, - unexpectedBetweenSwitchKeywordAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndCases?.raw, - cases.raw, - unexpectedBetweenCasesAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchStmt, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchStmtSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchStmtSyntax") - public static func makeBlankSwitchStmt(presence: SourcePresence = .present) -> SwitchStmtSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchStmt, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.switch), arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.switchCaseList, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena), - nil, - ], arena: arena)) - return SwitchStmtSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on CatchClauseListSyntax") public static func makeCatchClauseList( _ elements: [CatchClauseSyntax]) -> CatchClauseListSyntax { @@ -6795,150 +7001,6 @@ public enum SyntaxFactory { return ThrowStmtSyntax(data) } } - @available(*, deprecated, message: "Use initializer on IfStmtSyntax") - public static func makeIfStmt(_ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, ifKeyword: TokenSyntax, _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, conditions: ConditionElementListSyntax, _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, elseKeyword: TokenSyntax?, _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, elseBody: Syntax?, _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil) -> IfStmtSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeIfKeyword?.raw, - ifKeyword.raw, - unexpectedBetweenIfKeywordAndConditions?.raw, - conditions.raw, - unexpectedBetweenConditionsAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndElseKeyword?.raw, - elseKeyword?.raw, - unexpectedBetweenElseKeywordAndElseBody?.raw, - elseBody?.raw, - unexpectedAfterElseBody?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.ifStmt, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return IfStmtSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on IfStmtSyntax") - public static func makeBlankIfStmt(presence: SourcePresence = .present) -> IfStmtSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .ifStmt, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.if), arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.conditionElementList, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlock, arena: arena), - nil, - nil, - nil, - nil, - nil, - ], arena: arena)) - return IfStmtSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") - public static func makeSwitchCase(_ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, unknownAttr: AttributeSyntax?, _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, label: Syntax, _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, statements: CodeBlockItemListSyntax, _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil) -> SwitchCaseSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeUnknownAttr?.raw, - unknownAttr?.raw, - unexpectedBetweenUnknownAttrAndLabel?.raw, - label.raw, - unexpectedBetweenLabelAndStatements?.raw, - statements.raw, - unexpectedAfterStatements?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCase, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchCaseSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchCaseSyntax") - public static func makeBlankSwitchCase(presence: SourcePresence = .present) -> SwitchCaseSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCase, - from: [ - nil, - nil, - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena), - nil, - ], arena: arena)) - return SwitchCaseSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") - public static func makeSwitchDefaultLabel(_ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, defaultKeyword: TokenSyntax, _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchDefaultLabelSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeDefaultKeyword?.raw, - defaultKeyword.raw, - unexpectedBetweenDefaultKeywordAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchDefaultLabel, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchDefaultLabelSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchDefaultLabelSyntax") - public static func makeBlankSwitchDefaultLabel(presence: SourcePresence = .present) -> SwitchDefaultLabelSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchDefaultLabel, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.default), arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), - nil, - ], arena: arena)) - return SwitchDefaultLabelSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on CaseItemSyntax") - public static func makeCaseItem(_ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, pattern: PatternSyntax, _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, whereClause: WhereClauseSyntax?, _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> CaseItemSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.caseItem, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return CaseItemSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on CaseItemSyntax") - public static func makeBlankCaseItem(presence: SourcePresence = .present) -> CaseItemSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .caseItem, - from: [ - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena), - nil, - nil, - nil, - nil, - nil, - ], arena: arena)) - return CaseItemSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on CatchItemSyntax") public static func makeCatchItem(_ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, pattern: PatternSyntax?, _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, whereClause: WhereClauseSyntax?, _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> CatchItemSyntax { let layout: [RawSyntax?] = [ @@ -6974,41 +7036,6 @@ public enum SyntaxFactory { return CatchItemSyntax(data) } } - @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") - public static func makeSwitchCaseLabel(_ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, caseKeyword: TokenSyntax, _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, caseItems: CaseItemListSyntax, _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil) -> SwitchCaseLabelSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndCaseItems?.raw, - caseItems.raw, - unexpectedBetweenCaseItemsAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseLabel, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return SwitchCaseLabelSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on SwitchCaseLabelSyntax") - public static func makeBlankSwitchCaseLabel(presence: SourcePresence = .present) -> SwitchCaseLabelSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .switchCaseLabel, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.keyword(.case), arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.caseItemList, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena), - nil, - ], arena: arena)) - return SwitchCaseLabelSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on CatchClauseSyntax") public static func makeCatchClause(_ unexpectedBeforeCatchKeyword: UnexpectedNodesSyntax? = nil, catchKeyword: TokenSyntax, _ unexpectedBetweenCatchKeywordAndCatchItems: UnexpectedNodesSyntax? = nil, catchItems: CatchItemListSyntax?, _ unexpectedBetweenCatchItemsAndBody: UnexpectedNodesSyntax? = nil, body: CodeBlockSyntax, _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil) -> CatchClauseSyntax { let layout: [RawSyntax?] = [ diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift index 7f9c4da0c4a..72825798cff 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift @@ -3046,6 +3046,520 @@ extension BooleanLiteralExprSyntax: CustomReflectable { } } +// MARK: - IfExprSyntax + +public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public enum ElseBody: SyntaxChildChoices { + case `ifExpr`(IfExprSyntax) + case `codeBlock`(CodeBlockSyntax) + public var _syntaxNode: Syntax { + switch self { + case .ifExpr(let node): return node._syntaxNode + case .codeBlock(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: IfExprSyntax) { + self = .ifExpr(node) + } + public init(_ node: CodeBlockSyntax) { + self = .codeBlock(node) + } + public init?(_ node: S) { + if let node = node.as(IfExprSyntax.self) { + self = .ifExpr(node) + return + } + if let node = node.as(CodeBlockSyntax.self) { + self = .codeBlock(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(IfExprSyntax.self), + .node(CodeBlockSyntax.self), + ]) + } + } + + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .ifExpr else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `IfExprSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .ifExpr) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, + ifKeyword: TokenSyntax = .keyword(.if), + _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, + conditions: ConditionElementListSyntax, + _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, + elseKeyword: TokenSyntax? = nil, + _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, + elseBody: ElseBody? = nil, + _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIfKeyword, ifKeyword, unexpectedBetweenIfKeywordAndConditions, conditions, unexpectedBetweenConditionsAndBody, body, unexpectedBetweenBodyAndElseKeyword, elseKeyword, unexpectedBetweenElseKeywordAndElseBody, elseBody, unexpectedAfterElseBody))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeIfKeyword?.raw, + ifKeyword.raw, + unexpectedBetweenIfKeywordAndConditions?.raw, + conditions.raw, + unexpectedBetweenConditionsAndBody?.raw, + body.raw, + unexpectedBetweenBodyAndElseKeyword?.raw, + elseKeyword?.raw, + unexpectedBetweenElseKeywordAndElseBody?.raw, + elseBody?.raw, + unexpectedAfterElseBody?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.ifExpr, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var ifKeyword: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var conditions: ConditionElementListSyntax { + get { + return ConditionElementListSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + /// 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) + } + + public var unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var body: CodeBlockSyntax { + get { + return CodeBlockSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var elseKeyword: TokenSyntax? { + get { + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var elseBody: ElseBody? { + get { + return data.child(at: 9, parent: Syntax(self)).map(ElseBody.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterElseBody: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = IfExprSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeIfKeyword, + \Self.ifKeyword, + \Self.unexpectedBetweenIfKeywordAndConditions, + \Self.conditions, + \Self.unexpectedBetweenConditionsAndBody, + \Self.body, + \Self.unexpectedBetweenBodyAndElseKeyword, + \Self.elseKeyword, + \Self.unexpectedBetweenElseKeywordAndElseBody, + \Self.elseBody, + \Self.unexpectedAfterElseBody, + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + case 3: + return nil + case 4: + return nil + case 5: + return "body" + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return "else body" + case 10: + return nil + default: + fatalError("Invalid index") + } + } +} + +extension IfExprSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeIfKeyword": unexpectedBeforeIfKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "ifKeyword": Syntax(ifKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenIfKeywordAndConditions": unexpectedBetweenIfKeywordAndConditions.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "conditions": Syntax(conditions).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenConditionsAndBody": unexpectedBetweenConditionsAndBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "body": Syntax(body).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenBodyAndElseKeyword": unexpectedBetweenBodyAndElseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "elseKeyword": elseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenElseKeywordAndElseBody": unexpectedBetweenElseKeywordAndElseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "elseBody": elseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterElseBody": unexpectedAfterElseBody.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + +// MARK: - SwitchExprSyntax + +public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .switchExpr else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `SwitchExprSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .switchExpr) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, + switchKeyword: TokenSyntax = .keyword(.switch), + _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, + cases: SwitchCaseListSyntax, + _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSwitchKeyword, switchKeyword, unexpectedBetweenSwitchKeywordAndExpression, expression, unexpectedBetweenExpressionAndLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndCases, cases, unexpectedBetweenCasesAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeSwitchKeyword?.raw, + switchKeyword.raw, + unexpectedBetweenSwitchKeywordAndExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndCases?.raw, + cases.raw, + unexpectedBetweenCasesAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.switchExpr, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var switchKeyword: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var expression: ExprSyntax { + get { + return ExprSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var leftBrace: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var cases: SwitchCaseListSyntax { + get { + return SwitchCaseListSyntax(data.child(at: 7, parent: Syntax(self))!) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + /// 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) + } + + public var unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var rightBrace: TokenSyntax { + get { + return TokenSyntax(data.child(at: 9, parent: Syntax(self))!) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = SwitchExprSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + } + } + + 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 ec169244c0c..574bd9a2beb 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift @@ -1525,151 +1525,182 @@ extension DictionaryElementSyntax: CustomReflectable { } } -// MARK: - ClosureCaptureItemSpecifierSyntax +// 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 ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureItemSpecifier else { return nil } + guard node.raw.kind == .switchCase else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureCaptureItemSpecifierSyntax` 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 == .closureCaptureItemSpecifier) + assert(data.raw.kind == .switchCase) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: TokenSyntax, - _ unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, - detail: TokenSyntax? = nil, - _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, + unknownAttr: AttributeSyntax? = nil, + _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, + label: Label, + _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSpecifier, specifier, unexpectedBetweenSpecifierAndLeftParen, leftParen, unexpectedBetweenLeftParenAndDetail, detail, unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeUnknownAttr, unknownAttr, unexpectedBetweenUnknownAttrAndLabel, label, unexpectedBetweenLabelAndStatements, statements, unexpectedAfterStatements))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifier?.raw, - specifier.raw, - unexpectedBetweenSpecifierAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndDetail?.raw, - detail?.raw, - unexpectedBetweenDetailAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeUnknownAttr?.raw, + unknownAttr?.raw, + unexpectedBetweenUnknownAttrAndLabel?.raw, + label.raw, + unexpectedBetweenLabelAndStatements?.raw, + statements.raw, + unexpectedAfterStatements?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureItemSpecifier, 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 { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var specifier: TokenSyntax { + public var unknownAttr: AttributeSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(AttributeSyntax.init) } set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = SwitchCaseSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax? { + public var label: Label { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return Label(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var detail: TokenSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { + public var statements: CodeBlockItemListSyntax { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return CodeBlockItemListSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var rightParen: TokenSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + /// Adds the provided `Statement` to the node's `statements` + /// collection. + /// - param element: The new `Statement` to add to the node's + /// `statements` collection. + /// - returns: A copy of the receiver with the provided `Statement` + /// appended to its `statements` collection. + public func addStatement(_ element: CodeBlockItemSyntax) -> SwitchCaseSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return SwitchCaseSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterStatements: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeSpecifier, - \Self.specifier, - \Self.unexpectedBetweenSpecifierAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndDetail, - \Self.detail, - \Self.unexpectedBetweenDetailAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeUnknownAttr, + \Self.unknownAttr, + \Self.unexpectedBetweenUnknownAttrAndLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndStatements, + \Self.statements, + \Self.unexpectedAfterStatements, ]) } @@ -1682,208 +1713,173 @@ public struct ClosureCaptureItemSpecifierSyntax: 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 default: fatalError("Invalid index") } } } -extension ClosureCaptureItemSpecifierSyntax: CustomReflectable { +extension SwitchCaseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeSpecifier": unexpectedBeforeSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "specifier": Syntax(specifier).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenSpecifierAndLeftParen": unexpectedBetweenSpecifierAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": leftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenLeftParenAndDetail": unexpectedBetweenLeftParenAndDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "detail": detail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenDetailAndRightParen": unexpectedBetweenDetailAndRightParen.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, + "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: - ClosureCaptureItemSyntax +// MARK: - SwitchCaseLabelSyntax -public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { +public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureItem else { return nil } + guard node.raw.kind == .switchCaseLabel else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureCaptureItemSyntax` 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 == .closureCaptureItem) + assert(data.raw.kind == .switchCaseLabel) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: ClosureCaptureItemSpecifierSyntax? = 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, + _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .keyword(.case), + _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, + caseItems: CaseItemListSyntax, + _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSpecifier, specifier, unexpectedBetweenSpecifierAndName, name, unexpectedBetweenNameAndAssignToken, assignToken, unexpectedBetweenAssignTokenAndExpression, expression, unexpectedBetweenExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndCaseItems, caseItems, unexpectedBetweenCaseItemsAndColon, colon, unexpectedAfterColon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifier?.raw, - specifier?.raw, - unexpectedBetweenSpecifierAndName?.raw, - name?.raw, - unexpectedBetweenNameAndAssignToken?.raw, - assignToken?.raw, - unexpectedBetweenAssignTokenAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeCaseKeyword?.raw, + caseKeyword.raw, + unexpectedBetweenCaseKeywordAndCaseItems?.raw, + caseItems.raw, + unexpectedBetweenCaseItemsAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureItem, from: layout, arena: arena, + kind: SyntaxKind.switchCaseLabel, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseLabelSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var specifier: ClosureCaptureItemSpecifierSyntax? { + public var caseKeyword: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(ClosureCaptureItemSpecifierSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseLabelSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseLabelSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax? { - get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var assignToken: TokenSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? { + public var caseItems: CaseItemListSyntax { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return CaseItemListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseLabelSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var expression: ExprSyntax { - get { - return ExprSyntax(data.child(at: 7, parent: Syntax(self))!) - } - set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + /// 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) } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return SwitchCaseLabelSyntax(newData) } - public var unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseLabelSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseLabelSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterColon: UnexpectedNodesSyntax? { get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureItemSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = SwitchCaseLabelSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } 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, + \Self.unexpectedBeforeCaseKeyword, + \Self.caseKeyword, + \Self.unexpectedBetweenCaseKeywordAndCaseItems, + \Self.caseItems, + \Self.unexpectedBetweenCaseItemsAndColon, + \Self.colon, + \Self.unexpectedAfterColon, ]) } @@ -1903,178 +1899,123 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension ClosureCaptureItemSyntax: CustomReflectable { +extension SwitchCaseLabelSyntax: 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, + "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: - ClosureCaptureSignatureSyntax +// MARK: - SwitchDefaultLabelSyntax -public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { +public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureSignature else { return nil } + guard node.raw.kind == .switchDefaultLabel else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureCaptureSignatureSyntax` 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 == .closureCaptureSignature) + assert(data.raw.kind == .switchDefaultLabel) 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, + _ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, + defaultKeyword: TokenSyntax = .keyword(.default), + _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftSquare, leftSquare, unexpectedBetweenLeftSquareAndItems, items, unexpectedBetweenItemsAndRightSquare, rightSquare, unexpectedAfterRightSquare))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDefaultKeyword, defaultKeyword, unexpectedBetweenDefaultKeywordAndColon, colon, unexpectedAfterColon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndItems?.raw, - items?.raw, - unexpectedBetweenItemsAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw, + unexpectedBeforeDefaultKeyword?.raw, + defaultKeyword.raw, + unexpectedBetweenDefaultKeywordAndColon?.raw, + colon.raw, + unexpectedAfterColon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureSignature, from: layout, arena: arena, + kind: SyntaxKind.switchDefaultLabel, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { + public var unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = SwitchDefaultLabelSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftSquare: TokenSyntax { + public var defaultKeyword: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = SwitchDefaultLabelSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? { + public var unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = SwitchDefaultLabelSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var items: ClosureCaptureItemListSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(ClosureCaptureItemListSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) - } - } - - /// 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) + self = SwitchDefaultLabelSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return ClosureCaptureSignatureSyntax(newData) } - public var unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? { + public var unexpectedAfterColon: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var rightSquare: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = SwitchDefaultLabelSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftSquare, - \Self.leftSquare, - \Self.unexpectedBetweenLeftSquareAndItems, - \Self.items, - \Self.unexpectedBetweenItemsAndRightSquare, - \Self.rightSquare, - \Self.unexpectedAfterRightSquare, + \Self.unexpectedBeforeDefaultKeyword, + \Self.defaultKeyword, + \Self.unexpectedBetweenDefaultKeywordAndColon, + \Self.colon, + \Self.unexpectedAfterColon, ]) } @@ -2090,125 +2031,143 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension ClosureCaptureSignatureSyntax: CustomReflectable { +extension SwitchDefaultLabelSyntax: 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, + "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: - ClosureParamSyntax +// MARK: - CaseItemSyntax -public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { +public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureParam else { return nil } + guard node.raw.kind == .caseItem else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureParamSyntax` 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 == .closureParam) + assert(data.raw.kind == .caseItem) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax? = nil, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndWhereClause, whereClause, unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndWhereClause?.raw, + whereClause?.raw, + unexpectedBetweenWhereClauseAndTrailingComma?.raw, trailingComma?.raw, unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureParam, from: layout, arena: arena, + kind: SyntaxKind.caseItem, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforePattern: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureParamSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = CaseItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + public var pattern: PatternSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return PatternSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ClosureParamSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = CaseItemSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureParamSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = CaseItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var whereClause: WhereClauseSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(WhereClauseSyntax.init) + } + set(value) { + self = CaseItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = CaseItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public var trailingComma: TokenSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ClosureParamSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = CaseItemSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureParamSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = CaseItemSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndTrailingComma, + \Self.unexpectedBeforePattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndWhereClause, + \Self.whereClause, + \Self.unexpectedBetweenWhereClauseAndTrailingComma, \Self.trailingComma, \Self.unexpectedAfterTrailingComma, ]) @@ -2219,279 +2178,182 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + 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 ClosureParamSyntax: CustomReflectable { +extension CaseItemSyntax: 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, + "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, ]) } } -// 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: - ClosureCaptureItemSpecifierSyntax +public struct ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureSignature else { return nil } + guard node.raw.kind == .closureCaptureItemSpecifier else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureSignatureSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ClosureCaptureItemSpecifierSyntax` 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 == .closureCaptureItemSpecifier) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? = nil, - capture: ClosureCaptureSignatureSyntax? = nil, - _ unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? = nil, - input: Input? = nil, - _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax? = nil, - _ unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? = nil, - inTok: TokenSyntax = .keyword(.in), - _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, + specifier: TokenSyntax, + _ unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, + detail: TokenSyntax? = nil, + _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAttributes, attributes, unexpectedBetweenAttributesAndCapture, capture, unexpectedBetweenCaptureAndInput, input, unexpectedBetweenInputAndEffectSpecifiers, effectSpecifiers, unexpectedBetweenEffectSpecifiersAndOutput, output, unexpectedBetweenOutputAndInTok, inTok, unexpectedAfterInTok))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSpecifier, specifier, unexpectedBetweenSpecifierAndLeftParen, leftParen, unexpectedBetweenLeftParenAndDetail, detail, unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes?.raw, - unexpectedBetweenAttributesAndCapture?.raw, - capture?.raw, - unexpectedBetweenCaptureAndInput?.raw, - input?.raw, - unexpectedBetweenInputAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndOutput?.raw, - output?.raw, - unexpectedBetweenOutputAndInTok?.raw, - inTok.raw, - unexpectedAfterInTok?.raw, + unexpectedBeforeSpecifier?.raw, + specifier.raw, + unexpectedBetweenSpecifierAndLeftParen?.raw, + leftParen?.raw, + unexpectedBetweenLeftParenAndDetail?.raw, + detail?.raw, + unexpectedBetweenDetailAndRightParen?.raw, + rightParen?.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureSignature, from: layout, arena: arena, + kind: SyntaxKind.closureCaptureItemSpecifier, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { + public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var attributes: AttributeListSyntax? { + public var specifier: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) - } - } - - /// Adds the provided `Attribute` to the node's `attributes` - /// collection. - /// - param element: The new `Attribute` to add to the node's - /// `attributes` collection. - /// - returns: A copy of the receiver with the provided `Attribute` - /// appended to its `attributes` collection. - public func addAttribute(_ element: Syntax) -> ClosureSignatureSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[1] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 1, with: collection, arena: arena) - return ClosureSignatureSyntax(newData) } - public var unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? { + public var unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var capture: ClosureCaptureSignatureSyntax? { + public var leftParen: TokenSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(ClosureCaptureSignatureSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var input: Input? { + public var detail: TokenSyntax? { get { - return data.child(at: 5, parent: Syntax(self)).map(Input.init) + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? { + public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var effectSpecifiers: TypeEffectSpecifiersSyntax? { + public var rightParen: TokenSyntax? { get { - return data.child(at: 7, parent: Syntax(self)).map(TypeEffectSpecifiersSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } - } - - public var output: ReturnClauseSyntax? { - get { - return data.child(at: 9, parent: Syntax(self)).map(ReturnClauseSyntax.init) - } - set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) - } - } - - public var inTok: TokenSyntax { - get { - return TokenSyntax(data.child(at: 11, parent: Syntax(self))!) - } - set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 11, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterInTok: UnexpectedNodesSyntax? { - get { - return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ClosureSignatureSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSpecifierSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndCapture, - \Self.capture, - \Self.unexpectedBetweenCaptureAndInput, - \Self.input, - \Self.unexpectedBetweenInputAndEffectSpecifiers, - \Self.effectSpecifiers, - \Self.unexpectedBetweenEffectSpecifiersAndOutput, - \Self.output, - \Self.unexpectedBetweenOutputAndInTok, - \Self.inTok, - \Self.unexpectedAfterInTok, + \Self.unexpectedBeforeSpecifier, + \Self.specifier, + \Self.unexpectedBetweenSpecifierAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDetail, + \Self.detail, + \Self.unexpectedBetweenDetailAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -2500,7 +2362,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "attributes" + return nil case 2: return nil case 3: @@ -2515,161 +2377,197 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { return nil case 8: return nil - case 9: - return nil - case 10: - return nil - case 11: - return nil - case 12: - return nil default: fatalError("Invalid index") } } } -extension ClosureSignatureSyntax: CustomReflectable { +extension ClosureCaptureItemSpecifierSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAttributes": unexpectedBeforeAttributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "attributes": attributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAttributesAndCapture": unexpectedBetweenAttributesAndCapture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "capture": capture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenCaptureAndInput": unexpectedBetweenCaptureAndInput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "input": input.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenInputAndEffectSpecifiers": unexpectedBetweenInputAndEffectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "effectSpecifiers": effectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenEffectSpecifiersAndOutput": unexpectedBetweenEffectSpecifiersAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenOutputAndInTok": unexpectedBetweenOutputAndInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "inTok": Syntax(inTok).asProtocol(SyntaxProtocol.self), - "unexpectedAfterInTok": unexpectedAfterInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeSpecifier": unexpectedBeforeSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "specifier": Syntax(specifier).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenSpecifierAndLeftParen": unexpectedBetweenSpecifierAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": leftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenLeftParenAndDetail": unexpectedBetweenLeftParenAndDetail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "detail": detail.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenDetailAndRightParen": unexpectedBetweenDetailAndRightParen.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: - MultipleTrailingClosureElementSyntax +// MARK: - ClosureCaptureItemSyntax -public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashable { +public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .multipleTrailingClosureElement else { return nil } + guard node.raw.kind == .closureCaptureItem else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `MultipleTrailingClosureElementSyntax` node from the given `SyntaxData`. This assumes + /// 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 == .multipleTrailingClosureElement) + assert(data.raw.kind == .closureCaptureItem) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? = nil, - closure: ClosureExprSyntax, - _ unexpectedAfterClosure: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, + specifier: ClosureCaptureItemSpecifierSyntax? = nil, + _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax? = nil, + _ unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? = nil, + assignToken: TokenSyntax? = nil, + _ unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndClosure, closure, unexpectedAfterClosure))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSpecifier, specifier, unexpectedBetweenSpecifierAndName, name, unexpectedBetweenNameAndAssignToken, assignToken, unexpectedBetweenAssignTokenAndExpression, expression, unexpectedBetweenExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndClosure?.raw, - closure.raw, - unexpectedAfterClosure?.raw, + unexpectedBeforeSpecifier?.raw, + specifier?.raw, + unexpectedBetweenSpecifierAndName?.raw, + name?.raw, + unexpectedBetweenNameAndAssignToken?.raw, + assignToken?.raw, + unexpectedBetweenAssignTokenAndExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.multipleTrailingClosureElement, from: layout, arena: arena, + kind: SyntaxKind.closureCaptureItem, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var label: TokenSyntax { + public var specifier: ClosureCaptureItemSpecifierSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(ClosureCaptureItemSpecifierSyntax.init) } set(value) { - self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var name: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var closure: ClosureExprSyntax { + public var assignToken: TokenSyntax? { get { - return ClosureExprSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterClosure: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureItemSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var expression: ExprSyntax { + get { + return ExprSyntax(data.child(at: 7, parent: Syntax(self))!) + } + set(value) { + self = ClosureCaptureItemSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureCaptureItemSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var trailingComma: TokenSyntax? { + get { + return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = ClosureCaptureItemSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureCaptureItemSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } 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, ]) } @@ -2678,7 +2576,7 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -2689,99 +2587,178 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab return nil case 6: return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil default: fatalError("Invalid index") } } } -extension MultipleTrailingClosureElementSyntax: CustomReflectable { +extension ClosureCaptureItemSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLabel": unexpectedBeforeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "label": Syntax(label).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLabelAndColon": unexpectedBetweenLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndClosure": unexpectedBetweenColonAndClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "closure": Syntax(closure).asProtocol(SyntaxProtocol.self), - "unexpectedAfterClosure": unexpectedAfterClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeSpecifier": unexpectedBeforeSpecifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "specifier": specifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenSpecifierAndName": unexpectedBetweenSpecifierAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": name.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenNameAndAssignToken": unexpectedBetweenNameAndAssignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "assignToken": assignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenAssignTokenAndExpression": unexpectedBetweenAssignTokenAndExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndTrailingComma": unexpectedBetweenExpressionAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - StringSegmentSyntax +// MARK: - ClosureCaptureSignatureSyntax -public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { +public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .stringSegment else { return nil } + guard node.raw.kind == .closureCaptureSignature else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `StringSegmentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ClosureCaptureSignatureSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .stringSegment) + assert(data.raw.kind == .closureCaptureSignature) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeContent: UnexpectedNodesSyntax? = nil, - content: TokenSyntax, - _ unexpectedAfterContent: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? = nil, + items: ClosureCaptureItemListSyntax? = nil, + _ unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeContent, content, unexpectedAfterContent))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftSquare, leftSquare, unexpectedBetweenLeftSquareAndItems, items, unexpectedBetweenItemsAndRightSquare, rightSquare, unexpectedAfterRightSquare))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeContent?.raw, - content.raw, - unexpectedAfterContent?.raw, + unexpectedBeforeLeftSquare?.raw, + leftSquare.raw, + unexpectedBetweenLeftSquareAndItems?.raw, + items?.raw, + unexpectedBetweenItemsAndRightSquare?.raw, + rightSquare.raw, + unexpectedAfterRightSquare?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.stringSegment, from: layout, arena: arena, + kind: SyntaxKind.closureCaptureSignature, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeContent: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = StringSegmentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var content: TokenSyntax { + public var leftSquare: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = StringSegmentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterContent: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = StringSegmentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var items: ClosureCaptureItemListSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(ClosureCaptureItemListSyntax.init) + } + set(value) { + self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + /// 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) + } + + public var unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var rightSquare: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ClosureCaptureSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } 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, ]) } @@ -2793,296 +2770,190 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { return nil case 2: return nil + case 3: + return nil + case 4: + return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension StringSegmentSyntax: CustomReflectable { +extension ClosureCaptureSignatureSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeContent": unexpectedBeforeContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "content": Syntax(content).asProtocol(SyntaxProtocol.self), - "unexpectedAfterContent": unexpectedAfterContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLeftSquare": unexpectedBeforeLeftSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftSquare": Syntax(leftSquare).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftSquareAndItems": unexpectedBetweenLeftSquareAndItems.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "items": items.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenItemsAndRightSquare": unexpectedBetweenItemsAndRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightSquare": Syntax(rightSquare).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightSquare": unexpectedAfterRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ExpressionSegmentSyntax +// MARK: - ClosureParamSyntax -public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { +public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .expressionSegment else { return nil } + guard node.raw.kind == .closureParam else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ExpressionSegmentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ClosureParamSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .expressionSegment) + assert(data.raw.kind == .closureParam) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, - backslash: TokenSyntax = .backslashToken(), - _ unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? = nil, - delimiter: TokenSyntax? = nil, - _ unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? = nil, - expressions: TupleExprElementListSyntax, - _ unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBackslash, backslash, unexpectedBetweenBackslashAndDelimiter, delimiter, unexpectedBetweenDelimiterAndLeftParen, leftParen, unexpectedBetweenLeftParenAndExpressions, expressions, unexpectedBetweenExpressionsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeBackslash?.raw, - backslash.raw, - unexpectedBetweenBackslashAndDelimiter?.raw, - delimiter?.raw, - unexpectedBetweenDelimiterAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndExpressions?.raw, - expressions.raw, - unexpectedBetweenExpressionsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.expressionSegment, from: layout, arena: arena, + kind: SyntaxKind.closureParam, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ClosureParamSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var backslash: TokenSyntax { + public var name: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ClosureParamSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ClosureParamSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var delimiter: TokenSyntax? { + public var trailingComma: TokenSyntax? { get { return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ClosureParamSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ClosureParamSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, + ]) } - public var unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + 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") } } +} - public var expressions: TupleExprElementListSyntax { - get { - return TupleExprElementListSyntax(data.child(at: 7, parent: Syntax(self))!) - } - set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) - } +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, + ]) } +} - /// Adds the provided `Expression` to the node's `expressions` - /// collection. - /// - param element: The new `Expression` to add to the node's - /// `expressions` collection. - /// - returns: A copy of the receiver with the provided `Expression` - /// appended to its `expressions` collection. - public func addExpression(_ element: TupleExprElementSyntax) -> ExpressionSegmentSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[7] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 7, with: collection, arena: arena) - return ExpressionSegmentSyntax(newData) - } - - public var unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } - } - - public var rightParen: TokenSyntax { - get { - return TokenSyntax(data.child(at: 9, parent: Syntax(self))!) - } - set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ExpressionSegmentSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) - } - } - - 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, - ]) - } -} - -// MARK: - KeyPathComponentSyntax +// MARK: - ClosureSignatureSyntax -public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { - public enum Component: SyntaxChildChoices { - case `property`(KeyPathPropertyComponentSyntax) - case `subscript`(KeyPathSubscriptComponentSyntax) - case `optional`(KeyPathOptionalComponentSyntax) +public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { + public enum Input: SyntaxChildChoices { + case `simpleInput`(ClosureParamListSyntax) + case `input`(ParameterClauseSyntax) 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 + case .simpleInput(let node): return node._syntaxNode + case .input(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: ClosureParamListSyntax) { + self = .simpleInput(node) } - public init(_ node: KeyPathOptionalComponentSyntax) { - self = .optional(node) + public init(_ node: ParameterClauseSyntax) { + self = .input(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) + if let node = node.as(ClosureParamListSyntax.self) { + self = .simpleInput(node) return } - if let node = node.as(KeyPathOptionalComponentSyntax.self) { - self = .optional(node) + if let node = node.as(ParameterClauseSyntax.self) { + self = .input(node) return } return nil @@ -3090,9 +2961,8 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { public static var structure: SyntaxNodeStructure { return .choices([ - .node(KeyPathPropertyComponentSyntax.self), - .node(KeyPathSubscriptComponentSyntax.self), - .node(KeyPathOptionalComponentSyntax.self), + .node(ClosureParamListSyntax.self), + .node(ParameterClauseSyntax.self), ]) } } @@ -3100,251 +2970,212 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathComponent else { return nil } + guard node.raw.kind == .closureSignature else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `KeyPathComponentSyntax` node from the given `SyntaxData`. This assumes + /// 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 == .keyPathComponent) + assert(data.raw.kind == .closureSignature) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforePeriod: UnexpectedNodesSyntax? = nil, - period: TokenSyntax? = nil, - _ unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? = nil, - component: Component, - _ unexpectedAfterComponent: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? = nil, + capture: ClosureCaptureSignatureSyntax? = nil, + _ unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? = nil, + input: Input? = nil, + _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, + output: ReturnClauseSyntax? = nil, + _ unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? = nil, + inTok: TokenSyntax = .keyword(.in), + _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePeriod, period, unexpectedBetweenPeriodAndComponent, component, unexpectedAfterComponent))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAttributes, attributes, unexpectedBetweenAttributesAndCapture, capture, unexpectedBetweenCaptureAndInput, input, unexpectedBetweenInputAndEffectSpecifiers, effectSpecifiers, unexpectedBetweenEffectSpecifiersAndOutput, output, unexpectedBetweenOutputAndInTok, inTok, unexpectedAfterInTok))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforePeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndComponent?.raw, - component.raw, - unexpectedAfterComponent?.raw, + unexpectedBeforeAttributes?.raw, + attributes?.raw, + unexpectedBetweenAttributesAndCapture?.raw, + capture?.raw, + unexpectedBetweenCaptureAndInput?.raw, + input?.raw, + unexpectedBetweenInputAndEffectSpecifiers?.raw, + effectSpecifiers?.raw, + unexpectedBetweenEffectSpecifiersAndOutput?.raw, + output?.raw, + unexpectedBetweenOutputAndInTok?.raw, + inTok.raw, + unexpectedAfterInTok?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathComponent, from: layout, arena: arena, + kind: SyntaxKind.closureSignature, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePeriod: UnexpectedNodesSyntax? { + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var period: TokenSyntax? { + public var attributes: AttributeListSyntax? { get { - return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) } set(value) { - self = KeyPathComponentSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? { + /// Adds the provided `Attribute` to the node's `attributes` + /// collection. + /// - param element: The new `Attribute` to add to the node's + /// `attributes` collection. + /// - returns: A copy of the receiver with the provided `Attribute` + /// appended to its `attributes` collection. + public func addAttribute(_ element: Syntax) -> ClosureSignatureSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[1] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return ClosureSignatureSyntax(newData) + } + + public var unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var component: Component { + public var capture: ClosureCaptureSignatureSyntax? { get { - return Component(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(ClosureCaptureSignatureSyntax.init) } set(value) { - self = KeyPathComponentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterComponent: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforePeriod, - \Self.period, - \Self.unexpectedBetweenPeriodAndComponent, - \Self.component, - \Self.unexpectedAfterComponent, - ]) + public var input: Input? { + get { + return data.child(at: 5, parent: Syntax(self)).map(Input.init) + } + set(value) { + self = ClosureSignatureSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + } } - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - case 3: - return nil - case 4: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension KeyPathComponentSyntax: 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, - ]) - } -} - -// MARK: - KeyPathPropertyComponentSyntax - -public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .keyPathPropertyComponent else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// 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 == .keyPathPropertyComponent) - 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, - trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndDeclNameArguments, declNameArguments, unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndDeclNameArguments?.raw, - declNameArguments?.raw, - unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedAfterGenericArgumentClause?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathPropertyComponent, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? { get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var identifier: TokenSyntax { + public var effectSpecifiers: TypeEffectSpecifiersSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 7, parent: Syntax(self)).map(TypeEffectSpecifiersSyntax.init) } set(value) { - self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } - public var declNameArguments: DeclNameArgumentsSyntax? { + public var output: ReturnClauseSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) + return data.child(at: 9, parent: Syntax(self)).map(ReturnClauseSyntax.init) } set(value) { - self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } - public var genericArgumentClause: GenericArgumentClauseSyntax? { + public var inTok: TokenSyntax { get { - return data.child(at: 5, parent: Syntax(self)).map(GenericArgumentClauseSyntax.init) + return TokenSyntax(data.child(at: 11, parent: Syntax(self))!) } set(value) { - self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 11, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedAfterInTok: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ClosureSignatureSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIdentifier, - \Self.identifier, - \Self.unexpectedBetweenIdentifierAndDeclNameArguments, - \Self.declNameArguments, - \Self.unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, - \Self.genericArgumentClause, - \Self.unexpectedAfterGenericArgumentClause, + \Self.unexpectedBeforeAttributes, + \Self.attributes, + \Self.unexpectedBetweenAttributesAndCapture, + \Self.capture, + \Self.unexpectedBetweenCaptureAndInput, + \Self.input, + \Self.unexpectedBetweenInputAndEffectSpecifiers, + \Self.effectSpecifiers, + \Self.unexpectedBetweenEffectSpecifiersAndOutput, + \Self.output, + \Self.unexpectedBetweenOutputAndInTok, + \Self.inTok, + \Self.unexpectedAfterInTok, ]) } @@ -3353,7 +3184,7 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "attributes" case 2: return nil case 3: @@ -3364,166 +3195,165 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil + case 11: + return nil + case 12: + return nil default: fatalError("Invalid index") } } } -extension KeyPathPropertyComponentSyntax: CustomReflectable { +extension ClosureSignatureSyntax: 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, + "unexpectedBeforeAttributes": unexpectedBeforeAttributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "attributes": attributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenAttributesAndCapture": unexpectedBetweenAttributesAndCapture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "capture": capture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenCaptureAndInput": unexpectedBetweenCaptureAndInput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "input": input.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenInputAndEffectSpecifiers": unexpectedBetweenInputAndEffectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "effectSpecifiers": effectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenEffectSpecifiersAndOutput": unexpectedBetweenEffectSpecifiersAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenOutputAndInTok": unexpectedBetweenOutputAndInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "inTok": Syntax(inTok).asProtocol(SyntaxProtocol.self), + "unexpectedAfterInTok": unexpectedAfterInTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - KeyPathSubscriptComponentSyntax +// MARK: - MultipleTrailingClosureElementSyntax -public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { +public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathSubscriptComponent else { return nil } + guard node.raw.kind == .multipleTrailingClosureElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `KeyPathSubscriptComponentSyntax` 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 == .keyPathSubscriptComponent) + assert(data.raw.kind == .multipleTrailingClosureElement) 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, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? = nil, + closure: ClosureExprSyntax, + _ unexpectedAfterClosure: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBracket, leftBracket, unexpectedBetweenLeftBracketAndArgumentList, argumentList, unexpectedBetweenArgumentListAndRightBracket, rightBracket, unexpectedAfterRightBracket))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndClosure, closure, unexpectedAfterClosure))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBracket?.raw, - leftBracket.raw, - unexpectedBetweenLeftBracketAndArgumentList?.raw, - argumentList.raw, - unexpectedBetweenArgumentListAndRightBracket?.raw, - rightBracket.raw, - unexpectedAfterRightBracket?.raw, + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndClosure?.raw, + closure.raw, + unexpectedAfterClosure?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathSubscriptComponent, from: layout, arena: arena, + kind: SyntaxKind.multipleTrailingClosureElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftBracket: TokenSyntax { + public var label: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var argumentList: TupleExprElementListSyntax { + public var colon: TokenSyntax { get { - return TupleExprElementListSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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) + self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return KeyPathSubscriptComponentSyntax(newData) } - public var unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var rightBracket: TokenSyntax { + public var closure: ClosureExprSyntax { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return ClosureExprSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightBracket: UnexpectedNodesSyntax? { + public var unexpectedAfterClosure: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = MultipleTrailingClosureElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftBracket, - \Self.leftBracket, - \Self.unexpectedBetweenLeftBracketAndArgumentList, - \Self.argumentList, - \Self.unexpectedBetweenArgumentListAndRightBracket, - \Self.rightBracket, - \Self.unexpectedAfterRightBracket, + \Self.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndClosure, + \Self.closure, + \Self.unexpectedAfterClosure, ]) } @@ -3532,11 +3362,11 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: - return "arguments" + return nil case 4: return nil case 5: @@ -3549,93 +3379,93 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { } } -extension KeyPathSubscriptComponentSyntax: CustomReflectable { +extension MultipleTrailingClosureElementSyntax: 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, + "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: - KeyPathOptionalComponentSyntax +// MARK: - StringSegmentSyntax -public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable { +public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathOptionalComponent else { return nil } + guard node.raw.kind == .stringSegment else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `KeyPathOptionalComponentSyntax` 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 == .keyPathOptionalComponent) + assert(data.raw.kind == .stringSegment) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax, - _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeContent: UnexpectedNodesSyntax? = nil, + content: TokenSyntax, + _ unexpectedAfterContent: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeContent, content, unexpectedAfterContent))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeQuestionOrExclamationMark?.raw, - questionOrExclamationMark.raw, - unexpectedAfterQuestionOrExclamationMark?.raw, + unexpectedBeforeContent?.raw, + content.raw, + unexpectedAfterContent?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathOptionalComponent, from: layout, arena: arena, + kind: SyntaxKind.stringSegment, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedBeforeContent: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathOptionalComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = StringSegmentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var questionOrExclamationMark: TokenSyntax { + public var content: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = KeyPathOptionalComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = StringSegmentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedAfterContent: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = KeyPathOptionalComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = StringSegmentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeQuestionOrExclamationMark, - \Self.questionOrExclamationMark, - \Self.unexpectedAfterQuestionOrExclamationMark, + \Self.unexpectedBeforeContent, + \Self.content, + \Self.unexpectedAfterContent, ]) } @@ -3653,113 +3483,204 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable { } } -extension KeyPathOptionalComponentSyntax: CustomReflectable { +extension StringSegmentSyntax: 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, + "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: - YieldExprListElementSyntax +// MARK: - ExpressionSegmentSyntax -public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { +public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .yieldExprListElement else { return nil } + guard node.raw.kind == .expressionSegment else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `YieldExprListElementSyntax` 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 == .yieldExprListElement) + assert(data.raw.kind == .expressionSegment) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedAfterComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, + backslash: TokenSyntax = .backslashToken(), + _ unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? = nil, + delimiter: TokenSyntax? = nil, + _ unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? = nil, + expressions: TupleExprElementListSyntax, + _ unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedBetweenExpressionAndComma, comma, unexpectedAfterComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBackslash, backslash, unexpectedBetweenBackslashAndDelimiter, delimiter, unexpectedBetweenDelimiterAndLeftParen, leftParen, unexpectedBetweenLeftParenAndExpressions, expressions, unexpectedBetweenExpressionsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndComma?.raw, - comma?.raw, - unexpectedAfterComma?.raw, + unexpectedBeforeBackslash?.raw, + backslash.raw, + unexpectedBetweenBackslashAndDelimiter?.raw, + delimiter?.raw, + unexpectedBetweenDelimiterAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndExpressions?.raw, + expressions.raw, + unexpectedBetweenExpressionsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldExprListElement, from: layout, arena: arena, + kind: SyntaxKind.expressionSegment, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { + public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = YieldExprListElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ExpressionSegmentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var expression: ExprSyntax { + public var backslash: TokenSyntax { get { - return ExprSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = YieldExprListElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ExpressionSegmentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = YieldExprListElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ExpressionSegmentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var comma: TokenSyntax? { + public var delimiter: TokenSyntax? { get { return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = YieldExprListElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ExpressionSegmentSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = YieldExprListElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ExpressionSegmentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var leftParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = ExpressionSegmentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ExpressionSegmentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var expressions: TupleExprElementListSyntax { + get { + return TupleExprElementListSyntax(data.child(at: 7, parent: Syntax(self))!) + } + set(value) { + self = ExpressionSegmentSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `Expression` to the node's `expressions` + /// collection. + /// - param element: The new `Expression` to add to the node's + /// `expressions` collection. + /// - returns: A copy of the receiver with the provided `Expression` + /// appended to its `expressions` collection. + public func addExpression(_ element: TupleExprElementSyntax) -> ExpressionSegmentSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[7] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 7, with: collection, arena: arena) + return ExpressionSegmentSyntax(newData) + } + + public var unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ExpressionSegmentSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var rightParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 9, parent: Syntax(self))!) + } + set(value) { + self = ExpressionSegmentSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ExpressionSegmentSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } 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, ]) } @@ -3775,121 +3696,185 @@ public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - default: - fatalError("Invalid index") - } - } -} - -extension YieldExprListElementSyntax: 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, + 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, ]) } } -// MARK: - TypeInitializerClauseSyntax +// 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 static var structure: SyntaxNodeStructure { + return .choices([ + .node(KeyPathPropertyComponentSyntax.self), + .node(KeyPathSubscriptComponentSyntax.self), + .node(KeyPathOptionalComponentSyntax.self), + ]) + } + } -public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeInitializerClause else { return nil } + guard node.raw.kind == .keyPathComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `TypeInitializerClauseSyntax` node from the given `SyntaxData`. This assumes + /// 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 == .typeInitializerClause) + assert(data.raw.kind == .keyPathComponent) 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, + _ unexpectedBeforePeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax? = nil, + _ unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? = nil, + component: Component, + _ unexpectedAfterComponent: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePeriod, period, unexpectedBetweenPeriodAndComponent, component, unexpectedAfterComponent))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, + unexpectedBeforePeriod?.raw, + period?.raw, + unexpectedBetweenPeriodAndComponent?.raw, + component.raw, + unexpectedAfterComponent?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeInitializerClause, from: layout, arena: arena, + kind: SyntaxKind.keyPathComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { + public var unexpectedBeforePeriod: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TypeInitializerClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = KeyPathComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var equal: TokenSyntax { + public var period: TokenSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = TypeInitializerClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = KeyPathComponentSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TypeInitializerClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = KeyPathComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var value: TypeSyntax { + public var component: Component { get { - return TypeSyntax(data.child(at: 3, parent: Syntax(self))!) + return Component(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = TypeInitializerClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = KeyPathComponentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterValue: UnexpectedNodesSyntax? { + public var unexpectedAfterComponent: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TypeInitializerClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = KeyPathComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } 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, ]) } @@ -3902,7 +3887,7 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "type" + return nil case 4: return nil default: @@ -3911,158 +3896,139 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { } } -extension TypeInitializerClauseSyntax: CustomReflectable { +extension KeyPathComponentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeEqual": unexpectedBeforeEqual.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "equal": Syntax(equal).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenEqualAndValue": unexpectedBetweenEqualAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "value": Syntax(value).asProtocol(SyntaxProtocol.self), - "unexpectedAfterValue": unexpectedAfterValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforePeriod": unexpectedBeforePeriod.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenPeriodAndComponent": unexpectedBetweenPeriodAndComponent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "component": Syntax(component).asProtocol(SyntaxProtocol.self), + "unexpectedAfterComponent": unexpectedAfterComponent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ParameterClauseSyntax +// MARK: - KeyPathPropertyComponentSyntax -public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { +public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .parameterClause else { return nil } + guard node.raw.kind == .keyPathPropertyComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ParameterClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `KeyPathPropertyComponentSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .parameterClause) + assert(data.raw.kind == .keyPathPropertyComponent) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, - parameterList: FunctionParameterListSyntax, - _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax? = nil, + _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndParameterList, parameterList, unexpectedBetweenParameterListAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndDeclNameArguments, declNameArguments, unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndParameterList?.raw, - parameterList.raw, - unexpectedBetweenParameterListAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeIdentifier?.raw, + identifier.raw, + unexpectedBetweenIdentifierAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause?.raw, + genericArgumentClause?.raw, + unexpectedAfterGenericArgumentClause?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.parameterClause, from: layout, arena: arena, + kind: SyntaxKind.keyPathPropertyComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ParameterClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { + public var identifier: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ParameterClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ParameterClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var parameterList: FunctionParameterListSyntax { + public var declNameArguments: DeclNameArgumentsSyntax? { get { - return FunctionParameterListSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) } set(value) { - self = ParameterClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// Adds the provided `Parameter` to the node's `parameterList` - /// collection. - /// - param element: The new `Parameter` to add to the node's - /// `parameterList` collection. - /// - returns: A copy of the receiver with the provided `Parameter` - /// appended to its `parameterList` collection. - public func addParameter(_ element: 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 = KeyPathPropertyComponentSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return ParameterClauseSyntax(newData) } - public var unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ParameterClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var rightParen: TokenSyntax { + public var genericArgumentClause: GenericArgumentClauseSyntax? { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(GenericArgumentClauseSyntax.init) } set(value) { - self = ParameterClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ParameterClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = KeyPathPropertyComponentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndParameterList, - \Self.parameterList, - \Self.unexpectedBetweenParameterListAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeIdentifier, + \Self.identifier, + \Self.unexpectedBetweenIdentifierAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, + \Self.genericArgumentClause, + \Self.unexpectedAfterGenericArgumentClause, ]) } @@ -4075,7 +4041,7 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "parameters" + return nil case 4: return nil case 5: @@ -4088,117 +4054,160 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } } -extension ParameterClauseSyntax: CustomReflectable { +extension KeyPathPropertyComponentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndParameterList": unexpectedBetweenLeftParenAndParameterList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "parameterList": Syntax(parameterList).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenParameterListAndRightParen": unexpectedBetweenParameterListAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeIdentifier": unexpectedBeforeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "identifier": Syntax(identifier).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenIdentifierAndDeclNameArguments": unexpectedBetweenIdentifierAndDeclNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "declNameArguments": declNameArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause": unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "genericArgumentClause": genericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterGenericArgumentClause": unexpectedAfterGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ReturnClauseSyntax +// MARK: - KeyPathSubscriptComponentSyntax -public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { +public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .returnClause else { return nil } + guard node.raw.kind == .keyPathSubscriptComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ReturnClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `KeyPathSubscriptComponentSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .returnClause) + assert(data.raw.kind == .keyPathSubscriptComponent) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeArrow: UnexpectedNodesSyntax? = nil, - arrow: TokenSyntax = .arrowToken(), - _ unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? = nil, - returnType: R, - _ unexpectedAfterReturnType: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? = nil, + leftBracket: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, + rightBracket: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightBracket: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeArrow, arrow, unexpectedBetweenArrowAndReturnType, returnType, unexpectedAfterReturnType))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBracket, leftBracket, unexpectedBetweenLeftBracketAndArgumentList, argumentList, unexpectedBetweenArgumentListAndRightBracket, rightBracket, unexpectedAfterRightBracket))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeArrow?.raw, - arrow.raw, - unexpectedBetweenArrowAndReturnType?.raw, - returnType.raw, - unexpectedAfterReturnType?.raw, + unexpectedBeforeLeftBracket?.raw, + leftBracket.raw, + unexpectedBetweenLeftBracketAndArgumentList?.raw, + argumentList.raw, + unexpectedBetweenArgumentListAndRightBracket?.raw, + rightBracket.raw, + unexpectedAfterRightBracket?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.returnClause, from: layout, arena: arena, + kind: SyntaxKind.keyPathSubscriptComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeArrow: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ReturnClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var arrow: TokenSyntax { + public var leftBracket: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ReturnClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ReturnClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var returnType: TypeSyntax { + public var argumentList: TupleExprElementListSyntax { get { - return TypeSyntax(data.child(at: 3, parent: Syntax(self))!) + return TupleExprElementListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ReturnClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterReturnType: UnexpectedNodesSyntax? { + /// Adds the provided `Argument` to the node's `argumentList` + /// collection. + /// - param element: The new `Argument` to add to the node's + /// `argumentList` collection. + /// - returns: A copy of the receiver with the provided `Argument` + /// appended to its `argumentList` collection. + public func addArgument(_ element: TupleExprElementSyntax) -> KeyPathSubscriptComponentSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return KeyPathSubscriptComponentSyntax(newData) + } + + public var unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ReturnClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var rightBracket: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightBracket: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = KeyPathSubscriptComponentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } 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, ]) } @@ -4211,408 +4220,230 @@ 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, - _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: DeclEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax? = nil, - _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax, + _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeInput, input, unexpectedBetweenInputAndEffectSpecifiers, effectSpecifiers, unexpectedBetweenEffectSpecifiersAndOutput, output, unexpectedAfterOutput))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeInput?.raw, - input.raw, - unexpectedBetweenInputAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndOutput?.raw, - output?.raw, - unexpectedAfterOutput?.raw, + unexpectedBeforeQuestionOrExclamationMark?.raw, + questionOrExclamationMark.raw, + unexpectedAfterQuestionOrExclamationMark?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionSignature, from: layout, arena: arena, + kind: SyntaxKind.keyPathOptionalComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeInput: UnexpectedNodesSyntax? { + public var unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = KeyPathOptionalComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var input: ParameterClauseSyntax { + public var questionOrExclamationMark: TokenSyntax { get { - return ParameterClauseSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = FunctionSignatureSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = KeyPathOptionalComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? { + public var unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - public var effectSpecifiers: DeclEffectSpecifiersSyntax? { - get { - return data.child(at: 3, parent: Syntax(self)).map(DeclEffectSpecifiersSyntax.init) - } - set(value) { - self = FunctionSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = KeyPathOptionalComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = FunctionSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeQuestionOrExclamationMark, + \Self.questionOrExclamationMark, + \Self.unexpectedAfterQuestionOrExclamationMark, + ]) } - public var output: ReturnClauseSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(ReturnClauseSyntax.init) - } - set(value) { - self = FunctionSignatureSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + 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 unexpectedAfterOutput: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = FunctionSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeInput, - \Self.input, - \Self.unexpectedBetweenInputAndEffectSpecifiers, - \Self.effectSpecifiers, - \Self.unexpectedBetweenEffectSpecifiersAndOutput, - \Self.output, - \Self.unexpectedAfterOutput, - ]) - } - - 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 FunctionSignatureSyntax: CustomReflectable { +extension KeyPathOptionalComponentSyntax: 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), - "unexpectedBetweenInputAndEffectSpecifiers": unexpectedBetweenInputAndEffectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "effectSpecifiers": effectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenEffectSpecifiersAndOutput": unexpectedBetweenEffectSpecifiersAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterOutput": unexpectedAfterOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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, ]) } } -// 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: - YieldExprListElementSyntax +public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .ifConfigClause else { return nil } + guard node.raw.kind == .yieldExprListElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `IfConfigClauseSyntax` node from the given `SyntaxData`. This assumes + /// 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 == .ifConfigClause) + assert(data.raw.kind == .yieldExprListElement) 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, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedAfterComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePoundKeyword, poundKeyword, unexpectedBetweenPoundKeywordAndCondition, condition, unexpectedBetweenConditionAndElements, elements, unexpectedAfterElements))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedBetweenExpressionAndComma, comma, unexpectedAfterComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforePoundKeyword?.raw, - poundKeyword.raw, - unexpectedBetweenPoundKeywordAndCondition?.raw, - condition?.raw, - unexpectedBetweenConditionAndElements?.raw, - elements?.raw, - unexpectedAfterElements?.raw, + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndComma?.raw, + comma?.raw, + unexpectedAfterComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifConfigClause, from: layout, arena: arena, + kind: SyntaxKind.yieldExprListElement, 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 unexpectedBeforeExpression: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = IfConfigClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = YieldExprListElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var poundKeyword: TokenSyntax { + public var expression: ExprSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return ExprSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = IfConfigClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = YieldExprListElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = IfConfigClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = YieldExprListElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var condition: ExprSyntax? { + public var comma: TokenSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(ExprSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = IfConfigClauseSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = YieldExprListElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? { + public var unexpectedAfterComma: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = IfConfigClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var elements: Elements? { - get { - return data.child(at: 5, parent: Syntax(self)).map(Elements.init) - } - set(value) { - self = IfConfigClauseSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterElements: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = IfConfigClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = YieldExprListElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundKeyword, - \Self.poundKeyword, - \Self.unexpectedBetweenPoundKeywordAndCondition, - \Self.condition, - \Self.unexpectedBetweenConditionAndElements, - \Self.elements, - \Self.unexpectedAfterElements, + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndComma, + \Self.comma, + \Self.unexpectedAfterComma, ]) } @@ -4625,12 +4456,8 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "condition" - case 4: - return nil - case 5: return nil - case 6: + case 4: return nil default: fatalError("Invalid index") @@ -4638,237 +4465,288 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { } } -extension IfConfigClauseSyntax: CustomReflectable { +extension YieldExprListElementSyntax: 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, + "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: - PoundSourceLocationArgsSyntax +// MARK: - TypeInitializerClauseSyntax -public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { +public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundSourceLocationArgs else { return nil } + guard node.raw.kind == .typeInitializerClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PoundSourceLocationArgsSyntax` 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 == .poundSourceLocationArgs) + assert(data.raw.kind == .typeInitializerClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? = nil, - fileArgLabel: TokenSyntax = .keyword(.file), - _ unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? = nil, - fileArgColon: TokenSyntax = .colonToken(), - _ unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? = nil, - fileName: StringLiteralExprSyntax, - _ unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? = nil, - lineArgLabel: TokenSyntax = .keyword(.line), - _ unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? = nil, - lineArgColon: TokenSyntax = .colonToken(), - _ unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? = nil, - lineNumber: TokenSyntax, - _ unexpectedAfterLineNumber: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, + equal: TokenSyntax = .equalToken(), + _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, + value: V, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFileArgLabel, fileArgLabel, unexpectedBetweenFileArgLabelAndFileArgColon, fileArgColon, unexpectedBetweenFileArgColonAndFileName, fileName, unexpectedBetweenFileNameAndComma, comma, unexpectedBetweenCommaAndLineArgLabel, lineArgLabel, unexpectedBetweenLineArgLabelAndLineArgColon, lineArgColon, unexpectedBetweenLineArgColonAndLineNumber, lineNumber, unexpectedAfterLineNumber))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeFileArgLabel?.raw, - fileArgLabel.raw, - unexpectedBetweenFileArgLabelAndFileArgColon?.raw, - fileArgColon.raw, - unexpectedBetweenFileArgColonAndFileName?.raw, - fileName.raw, - unexpectedBetweenFileNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndLineArgLabel?.raw, - lineArgLabel.raw, - unexpectedBetweenLineArgLabelAndLineArgColon?.raw, - lineArgColon.raw, - unexpectedBetweenLineArgColonAndLineNumber?.raw, - lineNumber.raw, - unexpectedAfterLineNumber?.raw, + unexpectedBeforeEqual?.raw, + equal.raw, + unexpectedBetweenEqualAndValue?.raw, + value.raw, + unexpectedAfterValue?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.poundSourceLocationArgs, from: layout, arena: arena, + kind: SyntaxKind.typeInitializerClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = TypeInitializerClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var fileArgLabel: TokenSyntax { + public var equal: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = TypeInitializerClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = TypeInitializerClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var fileArgColon: TokenSyntax { + public var value: TypeSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return TypeSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = TypeInitializerClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? { + public var unexpectedAfterValue: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = TypeInitializerClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var fileName: StringLiteralExprSyntax { - get { - return StringLiteralExprSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeEqual, + \Self.equal, + \Self.unexpectedBetweenEqualAndValue, + \Self.value, + \Self.unexpectedAfterValue, + ]) } - public var unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + 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" + case 4: + return nil + default: + fatalError("Invalid index") } - set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } +} + +extension TypeInitializerClauseSyntax: 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, + ]) + } +} + +// MARK: - ParameterClauseSyntax + +public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .parameterClause else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// 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 == .parameterClause) + 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, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndParameterList, parameterList, unexpectedBetweenParameterListAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndParameterList?.raw, + parameterList.raw, + unexpectedBetweenParameterListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.parameterClause, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } + self.init(data) } - public var comma: TokenSyntax { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { - return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + self = ParameterClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? { + public var leftParen: TokenSyntax { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = ParameterClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var lineArgLabel: TokenSyntax { + public var unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? { get { - return TokenSyntax(data.child(at: 9, parent: Syntax(self))!) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) + self = ParameterClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? { + public var parameterList: FunctionParameterListSyntax { get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return FunctionParameterListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = ParameterClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var lineArgColon: TokenSyntax { - get { - return TokenSyntax(data.child(at: 11, parent: Syntax(self))!) - } - set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 11, with: value.raw, arena: SyntaxArena())) + /// Adds the provided `Parameter` to the node's `parameterList` + /// collection. + /// - param element: The new `Parameter` to add to the node's + /// `parameterList` collection. + /// - returns: A copy of the receiver with the provided `Parameter` + /// appended to its `parameterList` collection. + public func addParameter(_ element: FunctionParameterSyntax) -> ParameterClauseSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.functionParameterList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return ParameterClauseSyntax(newData) } - public var unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? { + public var unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + self = ParameterClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var lineNumber: TokenSyntax { + public var rightParen: TokenSyntax { get { - return TokenSyntax(data.child(at: 13, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 13, with: value.raw, arena: SyntaxArena())) + self = ParameterClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterLineNumber: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) + self = ParameterClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } 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.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndParameterList, + \Self.parameterList, + \Self.unexpectedBetweenParameterListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -4881,28 +4759,12 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "parameters" 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: + case 6: return nil default: fatalError("Invalid index") @@ -4910,149 +4772,117 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { } } -extension PoundSourceLocationArgsSyntax: CustomReflectable { +extension ParameterClauseSyntax: 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, + "unexpectedBeforeLeftParen": unexpectedBeforeLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndParameterList": unexpectedBetweenLeftParenAndParameterList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "parameterList": Syntax(parameterList).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenParameterListAndRightParen": unexpectedBetweenParameterListAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DeclModifierDetailSyntax +// MARK: - ReturnClauseSyntax -public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { +public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifierDetail else { return nil } + guard node.raw.kind == .returnClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclModifierDetailSyntax` node from the given `SyntaxData`. This assumes + /// 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 == .declModifierDetail) + assert(data.raw.kind == .returnClause) self._syntaxNode = Syntax(data) } - public init( + 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, + _ unexpectedBeforeArrow: UnexpectedNodesSyntax? = nil, + arrow: TokenSyntax = .arrowToken(), + _ unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? = nil, + returnType: R, + _ unexpectedAfterReturnType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndDetail, detail, unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeArrow, arrow, unexpectedBetweenArrowAndReturnType, returnType, unexpectedAfterReturnType))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndDetail?.raw, - detail.raw, - unexpectedBetweenDetailAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeArrow?.raw, + arrow.raw, + unexpectedBetweenArrowAndReturnType?.raw, + returnType.raw, + unexpectedAfterReturnType?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifierDetail, from: layout, arena: arena, + kind: SyntaxKind.returnClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeArrow: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ReturnClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { + public var arrow: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ReturnClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ReturnClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var detail: TokenSyntax { + public var returnType: TypeSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return TypeSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ReturnClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterReturnType: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var rightParen: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DeclModifierDetailSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ReturnClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndDetail, - \Self.detail, - \Self.unexpectedBetweenDetailAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeArrow, + \Self.arrow, + \Self.unexpectedBetweenArrowAndReturnType, + \Self.returnType, + \Self.unexpectedAfterReturnType, ]) } @@ -5065,260 +4895,408 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "return type" case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension DeclModifierDetailSyntax: CustomReflectable { +extension ReturnClauseSyntax: 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, + "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: - DeclModifierSyntax +// MARK: - FunctionSignatureSyntax -public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { +public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifier else { return nil } + guard node.raw.kind == .functionSignature else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclModifierSyntax` 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 == .declModifier) + assert(data.raw.kind == .functionSignature) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? = nil, - detail: DeclModifierDetailSyntax? = nil, - _ unexpectedAfterDetail: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeInput: UnexpectedNodesSyntax? = nil, + input: ParameterClauseSyntax, + _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: DeclEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, + output: ReturnClauseSyntax? = nil, + _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndDetail, detail, unexpectedAfterDetail))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeInput, input, unexpectedBetweenInputAndEffectSpecifiers, effectSpecifiers, unexpectedBetweenEffectSpecifiersAndOutput, output, unexpectedAfterOutput))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndDetail?.raw, - detail?.raw, - unexpectedAfterDetail?.raw, + unexpectedBeforeInput?.raw, + input.raw, + unexpectedBetweenInputAndEffectSpecifiers?.raw, + effectSpecifiers?.raw, + unexpectedBetweenEffectSpecifiersAndOutput?.raw, + output?.raw, + unexpectedAfterOutput?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifier, from: layout, arena: arena, + kind: SyntaxKind.functionSignature, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeInput: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = FunctionSignatureSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + public var input: ParameterClauseSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return ParameterClauseSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = FunctionSignatureSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = FunctionSignatureSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var detail: DeclModifierDetailSyntax? { + public var effectSpecifiers: DeclEffectSpecifiersSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(DeclModifierDetailSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(DeclEffectSpecifiersSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = FunctionSignatureSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDetail: UnexpectedNodesSyntax? { + public var unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclModifierSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = FunctionSignatureSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndDetail, - \Self.detail, - \Self.unexpectedAfterDetail, - ]) + public var output: ReturnClauseSyntax? { + get { + return data.child(at: 5, parent: Syntax(self)).map(ReturnClauseSyntax.init) + } + set(value) { + self = FunctionSignatureSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + } } - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - case 3: + public var unexpectedAfterOutput: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = FunctionSignatureSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeInput, + \Self.input, + \Self.unexpectedBetweenInputAndEffectSpecifiers, + \Self.effectSpecifiers, + \Self.unexpectedBetweenEffectSpecifiersAndOutput, + \Self.output, + \Self.unexpectedAfterOutput, + ]) + } + + 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 DeclModifierSyntax: CustomReflectable { +extension FunctionSignatureSyntax: 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, + "unexpectedBeforeInput": unexpectedBeforeInput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "input": Syntax(input).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenInputAndEffectSpecifiers": unexpectedBetweenInputAndEffectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "effectSpecifiers": effectSpecifiers.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenEffectSpecifiersAndOutput": unexpectedBetweenEffectSpecifiersAndOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterOutput": unexpectedAfterOutput.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - InheritedTypeSyntax +// 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 InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .inheritedType else { return nil } + guard node.raw.kind == .ifConfigClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `InheritedTypeSyntax` 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 == .inheritedType) + assert(data.raw.kind == .ifConfigClause) 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, + _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, + poundKeyword: TokenSyntax, + _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, + condition: C? = nil, + _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, + elements: Elements? = nil, + _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeTypeName, typeName, unexpectedBetweenTypeNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePoundKeyword, poundKeyword, unexpectedBetweenPoundKeywordAndCondition, condition, unexpectedBetweenConditionAndElements, elements, unexpectedAfterElements))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeTypeName?.raw, - typeName.raw, - unexpectedBetweenTypeNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforePoundKeyword?.raw, + poundKeyword.raw, + unexpectedBetweenPoundKeywordAndCondition?.raw, + condition?.raw, + unexpectedBetweenConditionAndElements?.raw, + elements?.raw, + unexpectedAfterElements?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.inheritedType, from: layout, arena: arena, + kind: SyntaxKind.ifConfigClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeTypeName: 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 { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = InheritedTypeSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = IfConfigClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var typeName: TypeSyntax { + public var poundKeyword: TokenSyntax { get { - return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = InheritedTypeSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = IfConfigClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = InheritedTypeSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = IfConfigClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + public var condition: ExprSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(ExprSyntax.init) } set(value) { - self = InheritedTypeSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = IfConfigClauseSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = InheritedTypeSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = IfConfigClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var elements: Elements? { + get { + return data.child(at: 5, parent: Syntax(self)).map(Elements.init) + } + set(value) { + self = IfConfigClauseSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterElements: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = IfConfigClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeTypeName, - \Self.typeName, - \Self.unexpectedBetweenTypeNameAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforePoundKeyword, + \Self.poundKeyword, + \Self.unexpectedBetweenPoundKeywordAndCondition, + \Self.condition, + \Self.unexpectedBetweenConditionAndElements, + \Self.elements, + \Self.unexpectedAfterElements, ]) } @@ -5331,316 +5309,250 @@ public struct InheritedTypeSyntax: 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 InheritedTypeSyntax: CustomReflectable { +extension IfConfigClauseSyntax: 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, - ]) + "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: - TypeInheritanceClauseSyntax +// MARK: - PoundSourceLocationArgsSyntax -public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { +public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeInheritanceClause else { return nil } + guard node.raw.kind == .poundSourceLocationArgs else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `TypeInheritanceClauseSyntax` 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 == .typeInheritanceClause) + assert(data.raw.kind == .poundSourceLocationArgs) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? = nil, - inheritedTypeCollection: InheritedTypeListSyntax, - _ unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? = nil, + fileArgLabel: TokenSyntax = .keyword(.file), + _ unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? = nil, + fileArgColon: TokenSyntax = .colonToken(), + _ unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? = nil, + fileName: StringLiteralExprSyntax, + _ unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? = nil, + lineArgLabel: TokenSyntax = .keyword(.line), + _ unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? = nil, + lineArgColon: TokenSyntax = .colonToken(), + _ unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? = nil, + lineNumber: TokenSyntax, + _ unexpectedAfterLineNumber: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndInheritedTypeCollection, inheritedTypeCollection, unexpectedAfterInheritedTypeCollection))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFileArgLabel, fileArgLabel, unexpectedBetweenFileArgLabelAndFileArgColon, fileArgColon, unexpectedBetweenFileArgColonAndFileName, fileName, unexpectedBetweenFileNameAndComma, comma, unexpectedBetweenCommaAndLineArgLabel, lineArgLabel, unexpectedBetweenLineArgLabelAndLineArgColon, lineArgColon, unexpectedBetweenLineArgColonAndLineNumber, lineNumber, unexpectedAfterLineNumber))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndInheritedTypeCollection?.raw, - inheritedTypeCollection.raw, - unexpectedAfterInheritedTypeCollection?.raw, + unexpectedBeforeFileArgLabel?.raw, + fileArgLabel.raw, + unexpectedBetweenFileArgLabelAndFileArgColon?.raw, + fileArgColon.raw, + unexpectedBetweenFileArgColonAndFileName?.raw, + fileName.raw, + unexpectedBetweenFileNameAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndLineArgLabel?.raw, + lineArgLabel.raw, + unexpectedBetweenLineArgLabelAndLineArgColon?.raw, + lineArgColon.raw, + unexpectedBetweenLineArgColonAndLineNumber?.raw, + lineNumber.raw, + unexpectedAfterLineNumber?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeInheritanceClause, from: layout, arena: arena, + kind: SyntaxKind.poundSourceLocationArgs, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeColon: UnexpectedNodesSyntax? { + public var unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TypeInheritanceClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var fileArgLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = TypeInheritanceClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? { + public var unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TypeInheritanceClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var inheritedTypeCollection: InheritedTypeListSyntax { + public var fileArgColon: TokenSyntax { get { - return InheritedTypeListSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = TypeInheritanceClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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 = PoundSourceLocationArgsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return TypeInheritanceClauseSyntax(newData) } - public var unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? { + public var unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TypeInheritanceClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeColon, - \Self.colon, - \Self.unexpectedBetweenColonAndInheritedTypeCollection, - \Self.inheritedTypeCollection, - \Self.unexpectedAfterInheritedTypeCollection, - ]) - } - - 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: StringLiteralExprSyntax { + get { + return StringLiteralExprSyntax(data.child(at: 5, parent: Syntax(self))!) } - } -} - -extension TypeInheritanceClauseSyntax: 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, - ]) - } -} - -// MARK: - MemberDeclBlockSyntax - -public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .memberDeclBlock else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// 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 == .memberDeclBlock) - 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, - trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndMembers, members, unexpectedBetweenMembersAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndMembers?.raw, - members.raw, - unexpectedBetweenMembersAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberDeclBlock, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) + set(value) { + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } - self.init(data) } - public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? { get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MemberDeclBlockSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var leftBrace: TokenSyntax { + public var comma: TokenSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) } set(value) { - self = MemberDeclBlockSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MemberDeclBlockSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } - public var members: MemberDeclListSyntax { + public var lineArgLabel: TokenSyntax { get { - return MemberDeclListSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 9, parent: Syntax(self))!) } set(value) { - self = MemberDeclBlockSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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 = PoundSourceLocationArgsSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return MemberDeclBlockSyntax(newData) } - public var unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MemberDeclBlockSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } - public var rightBrace: TokenSyntax { + public var lineArgColon: TokenSyntax { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 11, parent: Syntax(self))!) } set(value) { - self = MemberDeclBlockSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 11, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MemberDeclBlockSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) } } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeLeftBrace, - \Self.leftBrace, - \Self.unexpectedBetweenLeftBraceAndMembers, - \Self.members, - \Self.unexpectedBetweenMembersAndRightBrace, - \Self.rightBrace, - \Self.unexpectedAfterRightBrace, + public var lineNumber: TokenSyntax { + get { + return TokenSyntax(data.child(at: 13, parent: Syntax(self))!) + } + set(value) { + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 13, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterLineNumber: UnexpectedNodesSyntax? { + get { + return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PoundSourceLocationArgsSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) + } + } + + 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, ]) } @@ -5657,132 +5569,174 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return nil + 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 MemberDeclBlockSyntax: CustomReflectable { +extension PoundSourceLocationArgsSyntax: 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, + "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: - MemberDeclListItemSyntax +// MARK: - DeclModifierDetailSyntax -/// -/// A member declaration of a type consisting of a declaration and an -/// optional semicolon; -/// -public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .memberDeclListItem else { return nil } + guard node.raw.kind == .declModifierDetail else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `MemberDeclListItemSyntax` 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 == .memberDeclListItem) + assert(data.raw.kind == .declModifierDetail) 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, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, + detail: TokenSyntax, + _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDecl, decl, unexpectedBetweenDeclAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndDetail, detail, unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDecl?.raw, - decl.raw, - unexpectedBetweenDeclAndSemicolon?.raw, - semicolon?.raw, - unexpectedAfterSemicolon?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndDetail?.raw, + detail.raw, + unexpectedBetweenDetailAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberDeclListItem, from: layout, arena: arena, + kind: SyntaxKind.declModifierDetail, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDecl: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MemberDeclListItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The declaration of the type member. - public var decl: DeclSyntax { + public var leftParen: TokenSyntax { get { - return DeclSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = MemberDeclListItemSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MemberDeclListItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// An optional trailing semicolon. - public var semicolon: TokenSyntax? { + public var detail: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = MemberDeclListItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { + public var unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MemberDeclListItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierDetailSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var rightParen: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = DeclModifierDetailSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DeclModifierDetailSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDecl, - \Self.decl, - \Self.unexpectedBetweenDeclAndSemicolon, - \Self.semicolon, - \Self.unexpectedAfterSemicolon, + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDetail, + \Self.detail, + \Self.unexpectedBetweenDetailAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -5798,140 +5752,127 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension MemberDeclListItemSyntax: CustomReflectable { +extension DeclModifierDetailSyntax: 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, + "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: - SourceFileSyntax +// MARK: - DeclModifierSyntax -public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .sourceFile else { return nil } + guard node.raw.kind == .declModifier else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SourceFileSyntax` 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 == .sourceFile) + assert(data.raw.kind == .declModifier) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? = nil, - eofToken: TokenSyntax, - _ unexpectedAfterEOFToken: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? = nil, + detail: DeclModifierDetailSyntax? = nil, + _ unexpectedAfterDetail: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeStatements, statements, unexpectedBetweenStatementsAndEOFToken, eofToken, unexpectedAfterEOFToken))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndDetail, detail, unexpectedAfterDetail))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndEOFToken?.raw, - eofToken.raw, - unexpectedAfterEOFToken?.raw, + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndDetail?.raw, + detail?.raw, + unexpectedAfterDetail?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.sourceFile, from: layout, arena: arena, + kind: SyntaxKind.declModifier, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeStatements: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SourceFileSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var statements: CodeBlockItemListSyntax { + public var name: TokenSyntax { get { - return CodeBlockItemListSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = SourceFileSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - /// Adds the provided `Statement` to the node's `statements` - /// collection. - /// - param element: The new `Statement` to add to the node's - /// `statements` collection. - /// - returns: A copy of the receiver with the provided `Statement` - /// appended to its `statements` collection. - public func addStatement(_ element: CodeBlockItemSyntax) -> SourceFileSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[1] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 1, with: collection, arena: arena) - return SourceFileSyntax(newData) - } - - public var unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SourceFileSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var eofToken: TokenSyntax { + public var detail: DeclModifierDetailSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(DeclModifierDetailSyntax.init) } set(value) { - self = SourceFileSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterEOFToken: UnexpectedNodesSyntax? { + public var unexpectedAfterDetail: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SourceFileSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DeclModifierSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeStatements, - \Self.statements, - \Self.unexpectedBetweenStatementsAndEOFToken, - \Self.eofToken, - \Self.unexpectedAfterEOFToken, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndDetail, + \Self.detail, + \Self.unexpectedAfterDetail, ]) } @@ -5953,115 +5894,115 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { } } -extension SourceFileSyntax: CustomReflectable { +extension DeclModifierSyntax: 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, + "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: - InitializerClauseSyntax +// MARK: - InheritedTypeSyntax -public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { +public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .initializerClause else { return nil } + guard node.raw.kind == .inheritedType else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `InitializerClauseSyntax` 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 == .initializerClause) + assert(data.raw.kind == .inheritedType) 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, + _ unexpectedBeforeTypeName: UnexpectedNodesSyntax? = nil, + typeName: T, + _ unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeTypeName, typeName, unexpectedBetweenTypeNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, + unexpectedBeforeTypeName?.raw, + typeName.raw, + unexpectedBetweenTypeNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.initializerClause, from: layout, arena: arena, + kind: SyntaxKind.inheritedType, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { + public var unexpectedBeforeTypeName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = InitializerClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = InheritedTypeSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var equal: TokenSyntax { + public var typeName: TypeSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = InitializerClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = InheritedTypeSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = InitializerClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = InheritedTypeSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var value: ExprSyntax { + public var trailingComma: TokenSyntax? { get { - return ExprSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = InitializerClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = InheritedTypeSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterValue: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = InitializerClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = InheritedTypeSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeEqual, - \Self.equal, - \Self.unexpectedBetweenEqualAndValue, - \Self.value, - \Self.unexpectedAfterValue, + \Self.unexpectedBeforeTypeName, + \Self.typeName, + \Self.unexpectedBetweenTypeNameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -6083,551 +6024,449 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { } } -extension InitializerClauseSyntax: CustomReflectable { +extension InheritedTypeSyntax: 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, + "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: - FunctionParameterSyntax +// MARK: - TypeInheritanceClauseSyntax -public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { +public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionParameter else { return nil } + guard node.raw.kind == .typeInheritanceClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `FunctionParameterSyntax` 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 == .functionParameter) + assert(data.raw.kind == .typeInheritanceClause) 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, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? = nil, + inheritedTypeCollection: InheritedTypeListSyntax, + _ unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAttributes, attributes, unexpectedBetweenAttributesAndModifiers, modifiers, unexpectedBetweenModifiersAndFirstName, firstName, unexpectedBetweenFirstNameAndSecondName, secondName, unexpectedBetweenSecondNameAndColon, colon, unexpectedBetweenColonAndType, type, unexpectedBetweenTypeAndEllipsis, ellipsis, unexpectedBetweenEllipsisAndDefaultArgument, defaultArgument, unexpectedBetweenDefaultArgumentAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndInheritedTypeCollection, inheritedTypeCollection, unexpectedAfterInheritedTypeCollection))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes?.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers?.raw, - unexpectedBetweenModifiersAndFirstName?.raw, - firstName?.raw, - unexpectedBetweenFirstNameAndSecondName?.raw, - secondName?.raw, - unexpectedBetweenSecondNameAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndType?.raw, - type?.raw, - unexpectedBetweenTypeAndEllipsis?.raw, - ellipsis?.raw, - unexpectedBetweenEllipsisAndDefaultArgument?.raw, - defaultArgument?.raw, - unexpectedBetweenDefaultArgumentAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeColon?.raw, + colon.raw, + unexpectedBetweenColonAndInheritedTypeCollection?.raw, + inheritedTypeCollection.raw, + unexpectedAfterInheritedTypeCollection?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionParameter, from: layout, arena: arena, + kind: SyntaxKind.typeInheritanceClause, 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 unexpectedBeforeColon: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = TypeInheritanceClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var attributes: AttributeListSyntax? { + public var colon: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) - } - } - - /// Adds the provided `Attribute` to the node's `attributes` - /// collection. - /// - param element: The new `Attribute` to add to the node's - /// `attributes` collection. - /// - returns: A copy of the receiver with the provided `Attribute` - /// appended to its `attributes` collection. - public func addAttribute(_ element: Syntax) -> 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 = TypeInheritanceClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 1, with: collection, arena: arena) - return FunctionParameterSyntax(newData) } - public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = TypeInheritanceClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var modifiers: ModifierListSyntax? { + public var inheritedTypeCollection: InheritedTypeListSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(ModifierListSyntax.init) + return InheritedTypeListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = TypeInheritanceClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - /// Adds the provided `Modifier` to the node's `modifiers` + /// Adds the provided `InheritedType` to the node's `inheritedTypeCollection` /// 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 `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.modifierList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.inheritedTypeList, from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return FunctionParameterSyntax(newData) + return TypeInheritanceClauseSyntax(newData) } - public var unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? { + public var unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = TypeInheritanceClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var firstName: TokenSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) - } + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeColon, + \Self.colon, + \Self.unexpectedBetweenColonAndInheritedTypeCollection, + \Self.inheritedTypeCollection, + \Self.unexpectedAfterInheritedTypeCollection, + ]) } - public var unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + 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 secondName: TokenSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) - } +extension TypeInheritanceClauseSyntax: 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, + ]) } +} - public var unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } +// MARK: - MemberDeclBlockSyntax + +public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .memberDeclBlock else { return nil } + self._syntaxNode = node._syntaxNode } - public var colon: TokenSyntax? { - get { - return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) - } + /// 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 == .memberDeclBlock) + self._syntaxNode = Syntax(data) } - public var unexpectedBetweenColonAndType: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + 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, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndMembers, members, unexpectedBetweenMembersAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndMembers?.raw, + members.raw, + unexpectedBetweenMembersAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.memberDeclBlock, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } + self.init(data) } - public var type: TypeSyntax? { + public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { get { - return data.child(at: 11, parent: Syntax(self)).map(TypeSyntax.init) + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclBlockSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? { + public var leftBrace: TokenSyntax { get { - return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclBlockSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var ellipsis: TokenSyntax? { + public var unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? { get { - return data.child(at: 13, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclBlockSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? { + public var members: MemberDeclListSyntax { get { - return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return MemberDeclListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclBlockSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var defaultArgument: InitializerClauseSyntax? { - get { - return data.child(at: 15, parent: Syntax(self)).map(InitializerClauseSyntax.init) - } - set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 15, with: value?.raw, arena: SyntaxArena())) + /// 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) } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return MemberDeclBlockSyntax(newData) } - public var unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? { get { - return data.child(at: 16, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 16, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclBlockSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + public var rightBrace: TokenSyntax { get { - return data.child(at: 17, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 17, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclBlockSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { get { - return data.child(at: 18, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = FunctionParameterSyntax(data.replacingChild(at: 18, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclBlockSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAttributes, - \Self.attributes, - \Self.unexpectedBetweenAttributesAndModifiers, - \Self.modifiers, - \Self.unexpectedBetweenModifiersAndFirstName, - \Self.firstName, - \Self.unexpectedBetweenFirstNameAndSecondName, - \Self.secondName, - \Self.unexpectedBetweenSecondNameAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndType, - \Self.type, - \Self.unexpectedBetweenTypeAndEllipsis, - \Self.ellipsis, - \Self.unexpectedBetweenEllipsisAndDefaultArgument, - \Self.defaultArgument, - \Self.unexpectedBetweenDefaultArgumentAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, - ]) - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: + \Self.unexpectedBeforeLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndMembers, + \Self.members, + \Self.unexpectedBetweenMembersAndRightBrace, + \Self.rightBrace, + \Self.unexpectedAfterRightBrace, + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: return nil case 1: - return "attributes" + return nil case 2: return nil case 3: - return "modifiers" + return nil 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 FunctionParameterSyntax: CustomReflectable { +extension MemberDeclBlockSyntax: 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, + "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, ]) } } -// MARK: - AccessPathComponentSyntax +// MARK: - MemberDeclListItemSyntax -public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// A member declaration of a type consisting of a declaration and an +/// optional semicolon; +/// +public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessPathComponent else { return nil } + guard node.raw.kind == .memberDeclListItem else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessPathComponentSyntax` node from the given `SyntaxData`. This assumes + /// 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 == .accessPathComponent) + assert(data.raw.kind == .memberDeclListItem) 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, + _ unexpectedBeforeDecl: UnexpectedNodesSyntax? = nil, + decl: D, + _ unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax? = nil, + _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingDot, trailingDot, unexpectedAfterTrailingDot))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDecl, decl, unexpectedBetweenDeclAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingDot?.raw, - trailingDot?.raw, - unexpectedAfterTrailingDot?.raw, + unexpectedBeforeDecl?.raw, + decl.raw, + unexpectedBetweenDeclAndSemicolon?.raw, + semicolon?.raw, + unexpectedAfterSemicolon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessPathComponent, from: layout, arena: arena, + kind: SyntaxKind.memberDeclListItem, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeDecl: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessPathComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclListItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + /// The declaration of the type member. + public var decl: DeclSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return DeclSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = AccessPathComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = MemberDeclListItemSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessPathComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclListItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var trailingDot: TokenSyntax? { + /// An optional trailing semicolon. + public var semicolon: TokenSyntax? { get { return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = AccessPathComponentSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclListItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingDot: UnexpectedNodesSyntax? { + public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessPathComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = MemberDeclListItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndTrailingDot, - \Self.trailingDot, - \Self.unexpectedAfterTrailingDot, + \Self.unexpectedBeforeDecl, + \Self.decl, + \Self.unexpectedBetweenDeclAndSemicolon, + \Self.semicolon, + \Self.unexpectedAfterSemicolon, ]) } @@ -6636,7 +6475,7 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: @@ -6649,139 +6488,134 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AccessPathComponentSyntax: CustomReflectable { +extension MemberDeclListItemSyntax: 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, + "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: - AccessorParameterSyntax +// MARK: - SourceFileSyntax -public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { +public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorParameter else { return nil } + guard node.raw.kind == .sourceFile else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessorParameterSyntax` 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 == .accessorParameter) + assert(data.raw.kind == .sourceFile) self._syntaxNode = Syntax(data) } 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, + _ unexpectedBeforeStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? = nil, + eofToken: TokenSyntax, + _ unexpectedAfterEOFToken: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndName, name, unexpectedBetweenNameAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeStatements, statements, unexpectedBetweenStatementsAndEOFToken, eofToken, unexpectedAfterEOFToken))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeStatements?.raw, + statements.raw, + unexpectedBetweenStatementsAndEOFToken?.raw, + eofToken.raw, + unexpectedAfterEOFToken?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorParameter, from: layout, arena: arena, + kind: SyntaxKind.sourceFile, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeStatements: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessorParameterSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - public var leftParen: TokenSyntax { - get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) - } - set(value) { - self = AccessorParameterSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = SourceFileSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? { + public var statements: CodeBlockItemListSyntax { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return CodeBlockItemListSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = AccessorParameterSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = SourceFileSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { - get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) - } - set(value) { - self = AccessorParameterSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + /// Adds the provided `Statement` to the node's `statements` + /// collection. + /// - param element: The new `Statement` to add to the node's + /// `statements` collection. + /// - returns: A copy of the receiver with the provided `Statement` + /// appended to its `statements` collection. + public func addStatement(_ element: CodeBlockItemSyntax) -> SourceFileSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[1] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 1, with: collection, arena: arena) + return SourceFileSyntax(newData) } - public var unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessorParameterSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = SourceFileSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var rightParen: TokenSyntax { + public var eofToken: TokenSyntax { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = AccessorParameterSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = SourceFileSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterEOFToken: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessorParameterSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = SourceFileSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndName, - \Self.name, - \Self.unexpectedBetweenNameAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeStatements, + \Self.statements, + \Self.unexpectedBetweenStatementsAndEOFToken, + \Self.eofToken, + \Self.unexpectedAfterEOFToken, ]) } @@ -6794,12 +6628,8 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "name" - case 4: return nil - case 5: - return nil - case 6: + case 4: return nil default: fatalError("Invalid index") @@ -6807,160 +6637,115 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { } } -extension AccessorParameterSyntax: CustomReflectable { +extension SourceFileSyntax: 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, + "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: - AccessorBlockSyntax +// MARK: - InitializerClauseSyntax -public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { +public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorBlock else { return nil } + guard node.raw.kind == .initializerClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AccessorBlockSyntax` 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 == .accessorBlock) + assert(data.raw.kind == .initializerClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? = nil, - accessors: AccessorListSyntax, - _ unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, + equal: TokenSyntax = .equalToken(), + _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, + value: V, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndAccessors, accessors, unexpectedBetweenAccessorsAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeEqual, equal, unexpectedBetweenEqualAndValue, value, unexpectedAfterValue))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndAccessors?.raw, - accessors.raw, - unexpectedBetweenAccessorsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, + unexpectedBeforeEqual?.raw, + equal.raw, + unexpectedBetweenEqualAndValue?.raw, + value.raw, + unexpectedAfterValue?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorBlock, from: layout, arena: arena, + kind: SyntaxKind.initializerClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { + public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessorBlockSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = InitializerClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftBrace: TokenSyntax { + public var equal: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = AccessorBlockSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = InitializerClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? { + public var unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessorBlockSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = InitializerClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var accessors: AccessorListSyntax { + public var value: ExprSyntax { get { - return AccessorListSyntax(data.child(at: 3, parent: Syntax(self))!) + return ExprSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = AccessorBlockSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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 = InitializerClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return AccessorBlockSyntax(newData) } - public var unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedAfterValue: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AccessorBlockSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var rightBrace: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = AccessorBlockSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = AccessorBlockSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = InitializerClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftBrace, - \Self.leftBrace, - \Self.unexpectedBetweenLeftBraceAndAccessors, - \Self.accessors, - \Self.unexpectedBetweenAccessorsAndRightBrace, - \Self.rightBrace, - \Self.unexpectedAfterRightBrace, + \Self.unexpectedBeforeEqual, + \Self.equal, + \Self.unexpectedBetweenEqualAndValue, + \Self.value, + \Self.unexpectedAfterValue, ]) } @@ -6976,442 +6761,383 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension AccessorBlockSyntax: CustomReflectable { +extension InitializerClauseSyntax: 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, + "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: - 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: - FunctionParameterSyntax +public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .patternBinding else { return nil } + guard node.raw.kind == .functionParameter else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PatternBindingSyntax` 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 == .patternBinding) + assert(data.raw.kind == .functionParameter) 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, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax? = nil, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T? = nil, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? = nil, + defaultArgument: InitializerClauseSyntax? = nil, + _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax? = nil, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedBetweenInitializerAndAccessor, accessor, unexpectedBetweenAccessorAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAttributes, attributes, unexpectedBetweenAttributesAndModifiers, modifiers, unexpectedBetweenModifiersAndFirstName, firstName, unexpectedBetweenFirstNameAndSecondName, secondName, unexpectedBetweenSecondNameAndColon, colon, unexpectedBetweenColonAndType, type, unexpectedBetweenTypeAndEllipsis, ellipsis, unexpectedBetweenEllipsisAndDefaultArgument, defaultArgument, unexpectedBetweenDefaultArgumentAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer?.raw, - unexpectedBetweenInitializerAndAccessor?.raw, - accessor?.raw, - unexpectedBetweenAccessorAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.patternBinding, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforePattern: UnexpectedNodesSyntax? { + unexpectedBeforeAttributes?.raw, + attributes?.raw, + unexpectedBetweenAttributesAndModifiers?.raw, + modifiers?.raw, + unexpectedBetweenModifiersAndFirstName?.raw, + firstName?.raw, + unexpectedBetweenFirstNameAndSecondName?.raw, + secondName?.raw, + unexpectedBetweenSecondNameAndColon?.raw, + colon?.raw, + unexpectedBetweenColonAndType?.raw, + type?.raw, + unexpectedBetweenTypeAndEllipsis?.raw, + ellipsis?.raw, + unexpectedBetweenEllipsisAndDefaultArgument?.raw, + defaultArgument?.raw, + unexpectedBetweenDefaultArgumentAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.functionParameter, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + /// This initializer exists solely because Swift 5.6 does not support + /// `Optional.none` as a default value of a generic parameter. + /// The above initializer thus defaults to `nil` instead, but that means it + /// is not actually callable when either not passing the defaulted parameter, + /// or passing `nil`. + /// + /// Hack around that limitation using this initializer, which takes a + /// `Missing*` syntax node instead. `Missing*` is used over the base type as + /// the base type would allow implicit conversion from a string literal, + /// which the above initializer doesn't support. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax? = nil, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: MissingTypeSyntax? = nil, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? = nil, + defaultArgument: InitializerClauseSyntax? = nil, + _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndFirstName, + firstName: firstName, + unexpectedBetweenFirstNameAndSecondName, + secondName: secondName, + unexpectedBetweenSecondNameAndColon, + colon: colon, + unexpectedBetweenColonAndType, + type: Optional.none, + unexpectedBetweenTypeAndEllipsis, + ellipsis: ellipsis, + unexpectedBetweenEllipsisAndDefaultArgument, + defaultArgument: defaultArgument, + unexpectedBetweenDefaultArgumentAndTrailingComma, + trailingComma: trailingComma, + unexpectedAfterTrailingComma, + trailingTrivia: trailingTrivia + ) + } + + public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var pattern: PatternSyntax { + public var attributes: AttributeListSyntax? { get { - return PatternSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + /// 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) + } + + public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var typeAnnotation: TypeAnnotationSyntax? { + public var modifiers: ModifierListSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TypeAnnotationSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(ModifierListSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + /// Adds the provided `Modifier` to the node's `modifiers` + /// collection. + /// - param element: The new `Modifier` to add to the node's + /// `modifiers` collection. + /// - returns: A copy of the receiver with the provided `Modifier` + /// appended to its `modifiers` collection. + public func addModifier(_ element: DeclModifierSyntax) -> FunctionParameterSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return FunctionParameterSyntax(newData) + } + + public var unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var initializer: InitializerClauseSyntax? { + public var firstName: TokenSyntax? { get { - return data.child(at: 5, parent: Syntax(self)).map(InitializerClauseSyntax.init) + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? { + public var unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var accessor: Accessor? { + public var secondName: TokenSyntax? { get { - return data.child(at: 7, parent: Syntax(self)).map(Accessor.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + public var colon: TokenSyntax? { get { return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndType: UnexpectedNodesSyntax? { get { return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PatternBindingSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } - 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 var type: TypeSyntax? { + get { + return data.child(at: 11, parent: Syntax(self)).map(TypeSyntax.init) + } + set(value) { + self = FunctionParameterSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) + } } - 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") + public var unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? { + get { + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = FunctionParameterSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) } } -} -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, - ]) + public var ellipsis: TokenSyntax? { + get { + return data.child(at: 13, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = FunctionParameterSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) + } } -} -// MARK: - EnumCaseElementSyntax - -/// -/// 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 == .enumCaseElement else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// 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 == .enumCaseElement) - 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, - trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndAssociatedValue, associatedValue, unexpectedBetweenAssociatedValueAndRawValue, rawValue, unexpectedBetweenRawValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndAssociatedValue?.raw, - associatedValue?.raw, - unexpectedBetweenAssociatedValueAndRawValue?.raw, - rawValue?.raw, - unexpectedBetweenRawValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseElement, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { - get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The name of this case. - public var identifier: TokenSyntax { - get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) - } - set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? { - get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The set of associated values of the case. - public var associatedValue: ParameterClauseSyntax? { - get { - return data.child(at: 3, parent: Syntax(self)).map(ParameterClauseSyntax.init) - } - set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The raw value of this enum element, if present. - /// - public var rawValue: InitializerClauseSyntax? { + public var defaultArgument: InitializerClauseSyntax? { get { - return data.child(at: 5, parent: Syntax(self)).map(InitializerClauseSyntax.init) + return data.child(at: 15, parent: Syntax(self)).map(InitializerClauseSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 15, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 16, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 16, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The trailing comma of this element, if the case has - /// multiple elements. - /// public var trailingComma: TokenSyntax? { get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 17, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 17, with: value?.raw, arena: SyntaxArena())) } } public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 18, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = EnumCaseElementSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = FunctionParameterSyntax(data.replacingChild(at: 18, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIdentifier, - \Self.identifier, - \Self.unexpectedBetweenIdentifierAndAssociatedValue, - \Self.associatedValue, - \Self.unexpectedBetweenAssociatedValueAndRawValue, - \Self.rawValue, - \Self.unexpectedBetweenRawValueAndTrailingComma, + \Self.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, ]) @@ -7422,11 +7148,11 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "attributes" case 2: return nil case 3: - return "associated values" + return "modifiers" case 4: return nil case 5: @@ -7434,128 +7160,158 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { case 6: return nil case 7: - return nil + return "internal name" case 8: return nil + case 9: + return nil + case 10: + return nil + case 11: + return "type" + case 12: + return nil + case 13: + return nil + case 14: + return nil + case 15: + return "default argument" + case 16: + return nil + case 17: + return nil + case 18: + return nil default: fatalError("Invalid index") } } } -extension EnumCaseElementSyntax: CustomReflectable { +extension FunctionParameterSyntax: 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, + "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: - DesignatedTypeElementSyntax +// MARK: - AccessPathComponentSyntax -public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { +public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .designatedTypeElement else { return nil } + guard node.raw.kind == .accessPathComponent else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DesignatedTypeElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AccessPathComponentSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .designatedTypeElement) + assert(data.raw.kind == .accessPathComponent) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, - leadingComma: TokenSyntax = .commaToken(), - _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, name: TokenSyntax, - _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? = nil, + trailingDot: TokenSyntax? = nil, + _ unexpectedAfterTrailingDot: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeadingComma, leadingComma, unexpectedBetweenLeadingCommaAndName, name, unexpectedAfterName))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingDot, trailingDot, unexpectedAfterTrailingDot))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeadingComma?.raw, - leadingComma.raw, - unexpectedBetweenLeadingCommaAndName?.raw, + unexpectedBeforeName?.raw, name.raw, - unexpectedAfterName?.raw, + unexpectedBetweenNameAndTrailingDot?.raw, + trailingDot?.raw, + unexpectedAfterTrailingDot?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.designatedTypeElement, from: layout, arena: arena, + kind: SyntaxKind.accessPathComponent, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = AccessPathComponentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leadingComma: TokenSyntax { + public var name: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = AccessPathComponentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = AccessPathComponentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + public var trailingDot: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = AccessPathComponentSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterName: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingDot: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DesignatedTypeElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = AccessPathComponentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeadingComma, - \Self.leadingComma, - \Self.unexpectedBetweenLeadingCommaAndName, + \Self.unexpectedBeforeName, \Self.name, - \Self.unexpectedAfterName, + \Self.unexpectedBetweenNameAndTrailingDot, + \Self.trailingDot, + \Self.unexpectedAfterTrailingDot, ]) } @@ -7564,7 +7320,7 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "name" case 2: return nil case 3: @@ -7577,167 +7333,139 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { } } -extension DesignatedTypeElementSyntax: CustomReflectable { +extension AccessPathComponentSyntax: 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, + "unexpectedBeforeName": unexpectedBeforeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedAfterName": unexpectedAfterName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - OperatorPrecedenceAndTypesSyntax +// MARK: - AccessorParameterSyntax -/// -/// A clause to specify precedence group in infix operator declarations, and designated types in any operator declaration. -/// -public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { +public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .operatorPrecedenceAndTypes else { return nil } + guard node.raw.kind == .accessorParameter else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OperatorPrecedenceAndTypesSyntax` 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 == .operatorPrecedenceAndTypes) + assert(data.raw.kind == .accessorParameter) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, - precedenceGroup: TokenSyntax, - _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, - designatedTypes: DesignatedTypeListSyntax, - _ unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndPrecedenceGroup, precedenceGroup, unexpectedBetweenPrecedenceGroupAndDesignatedTypes, designatedTypes, unexpectedAfterDesignatedTypes))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndName, name, unexpectedBetweenNameAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndPrecedenceGroup?.raw, - precedenceGroup.raw, - unexpectedBetweenPrecedenceGroupAndDesignatedTypes?.raw, - designatedTypes.raw, - unexpectedAfterDesignatedTypes?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndName?.raw, + name.raw, + unexpectedBetweenNameAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.operatorPrecedenceAndTypes, from: layout, arena: arena, + kind: SyntaxKind.accessorParameter, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeColon: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = AccessorParameterSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var leftParen: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = AccessorParameterSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = AccessorParameterSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The precedence group for this operator - /// - public var precedenceGroup: TokenSyntax { + public var name: TokenSyntax { get { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = AccessorParameterSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = AccessorParameterSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The designated types associated with this operator. - /// - public var designatedTypes: DesignatedTypeListSyntax { + public var rightParen: TokenSyntax { get { - return DesignatedTypeListSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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 = AccessorParameterSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return OperatorPrecedenceAndTypesSyntax(newData) } - public var unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = AccessorParameterSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeColon, - \Self.colon, - \Self.unexpectedBetweenColonAndPrecedenceGroup, - \Self.precedenceGroup, - \Self.unexpectedBetweenPrecedenceGroupAndDesignatedTypes, - \Self.designatedTypes, - \Self.unexpectedAfterDesignatedTypes, + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndName, + \Self.name, + \Self.unexpectedBetweenNameAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -7750,7 +7478,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "precedence group" + return "name" case 4: return nil case 5: @@ -7763,171 +7491,160 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { } } -extension OperatorPrecedenceAndTypesSyntax: CustomReflectable { +extension AccessorParameterSyntax: 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, + "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, ]) } } -// MARK: - PrecedenceGroupRelationSyntax +// MARK: - AccessorBlockSyntax -/// -/// Specify the new precedence group's relation to existing precedence -/// groups. -/// -public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { +public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupRelation else { return nil } + guard node.raw.kind == .accessorBlock else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupRelationSyntax` 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 == .precedenceGroupRelation) + assert(data.raw.kind == .accessorBlock) 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, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? = nil, + accessors: AccessorListSyntax, + _ unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeHigherThanOrLowerThan, higherThanOrLowerThan, unexpectedBetweenHigherThanOrLowerThanAndColon, colon, unexpectedBetweenColonAndOtherNames, otherNames, unexpectedAfterOtherNames))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndAccessors, accessors, unexpectedBetweenAccessorsAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeHigherThanOrLowerThan?.raw, - higherThanOrLowerThan.raw, - unexpectedBetweenHigherThanOrLowerThanAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndOtherNames?.raw, - otherNames.raw, - unexpectedAfterOtherNames?.raw, + unexpectedBeforeLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndAccessors?.raw, + accessors.raw, + unexpectedBetweenAccessorsAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupRelation, from: layout, arena: arena, + kind: SyntaxKind.accessorBlock, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = AccessorBlockSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The relation to specified other precedence groups. - /// - public var higherThanOrLowerThan: TokenSyntax { + public var leftBrace: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = AccessorBlockSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = AccessorBlockSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var accessors: AccessorListSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return AccessorListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = AccessorBlockSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? { + /// Adds the provided `Accessor` to the node's `accessors` + /// collection. + /// - param element: The new `Accessor` to add to the node's + /// `accessors` collection. + /// - returns: A copy of the receiver with the provided `Accessor` + /// appended to its `accessors` collection. + public func addAccessor(_ element: AccessorDeclSyntax) -> AccessorBlockSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.accessorList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return AccessorBlockSyntax(newData) + } + + public var unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = AccessorBlockSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The name of other precedence group to which this precedence - /// group relates. - /// - public var otherNames: PrecedenceGroupNameListSyntax { + public var rightBrace: TokenSyntax { get { - return PrecedenceGroupNameListSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = AccessorBlockSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - /// 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) - } - - public var unexpectedAfterOtherNames: UnexpectedNodesSyntax? { + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = AccessorBlockSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeHigherThanOrLowerThan, - \Self.higherThanOrLowerThan, - \Self.unexpectedBetweenHigherThanOrLowerThanAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndOtherNames, - \Self.otherNames, - \Self.unexpectedAfterOtherNames, + \Self.unexpectedBeforeLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndAccessors, + \Self.accessors, + \Self.unexpectedBetweenAccessorsAndRightBrace, + \Self.rightBrace, + \Self.unexpectedAfterRightBrace, ]) } @@ -7953,115 +7670,223 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { } } -extension PrecedenceGroupRelationSyntax: CustomReflectable { +extension AccessorBlockSyntax: 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, + "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: - PrecedenceGroupNameElementSyntax +// MARK: - PatternBindingSyntax + +public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { + public enum Accessor: SyntaxChildChoices { + case `accessors`(AccessorBlockSyntax) + case `getter`(CodeBlockSyntax) + public var _syntaxNode: Syntax { + switch self { + case .accessors(let node): return node._syntaxNode + case .getter(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: AccessorBlockSyntax) { + self = .accessors(node) + } + public init(_ node: CodeBlockSyntax) { + self = .getter(node) + } + public init?(_ node: S) { + if let node = node.as(AccessorBlockSyntax.self) { + self = .accessors(node) + return + } + if let node = node.as(CodeBlockSyntax.self) { + self = .getter(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(AccessorBlockSyntax.self), + .node(CodeBlockSyntax.self), + ]) + } + } -public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupNameElement else { return nil } + guard node.raw.kind == .patternBinding else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupNameElementSyntax` 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 == .precedenceGroupNameElement) + assert(data.raw.kind == .patternBinding) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax? = nil, + _ unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? = nil, + accessor: Accessor? = nil, + _ unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax? = nil, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedBetweenInitializerAndAccessor, accessor, unexpectedBetweenAccessorAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer?.raw, + unexpectedBetweenInitializerAndAccessor?.raw, + accessor?.raw, + unexpectedBetweenAccessorAndTrailingComma?.raw, trailingComma?.raw, unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupNameElement, from: layout, arena: arena, + kind: SyntaxKind.patternBinding, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforePattern: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = PatternBindingSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax { + public var pattern: PatternSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return PatternSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = PatternBindingSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = PatternBindingSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var typeAnnotation: TypeAnnotationSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(TypeAnnotationSyntax.init) + } + set(value) { + self = PatternBindingSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PatternBindingSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var initializer: InitializerClauseSyntax? { + get { + return data.child(at: 5, parent: Syntax(self)).map(InitializerClauseSyntax.init) + } + set(value) { + self = PatternBindingSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PatternBindingSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var accessor: Accessor? { + get { + return data.child(at: 7, parent: Syntax(self)).map(Accessor.init) + } + set(value) { + self = PatternBindingSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PatternBindingSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public var trailingComma: TokenSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = PatternBindingSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) } } public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = PatternBindingSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndTrailingComma, + \Self.unexpectedBeforePattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedBetweenInitializerAndAccessor, + \Self.accessor, + \Self.unexpectedBetweenAccessorAndTrailingComma, \Self.trailingComma, \Self.unexpectedAfterTrailingComma, ]) @@ -8072,163 +7897,207 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return nil case 2: return nil case 3: - return nil + return "type annotation" case 4: return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil default: fatalError("Invalid index") } } } -extension PrecedenceGroupNameElementSyntax: CustomReflectable { +extension PatternBindingSyntax: 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, + "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: - PrecedenceGroupAssignmentSyntax +// MARK: - EnumCaseElementSyntax /// -/// Specifies the precedence of an operator when used in an operation -/// that includes optional chaining. +/// 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 PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { +public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssignment else { return nil } + guard node.raw.kind == .enumCaseElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupAssignmentSyntax` 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 == .precedenceGroupAssignment) + assert(data.raw.kind == .enumCaseElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? = nil, - assignmentKeyword: TokenSyntax = .keyword(.assignment), - _ unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, - flag: TokenSyntax, - _ unexpectedAfterFlag: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? = nil, + associatedValue: ParameterClauseSyntax? = nil, + _ unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? = nil, + rawValue: InitializerClauseSyntax? = nil, + _ unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssignmentKeyword, assignmentKeyword, unexpectedBetweenAssignmentKeywordAndColon, colon, unexpectedBetweenColonAndFlag, flag, unexpectedAfterFlag))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedBetweenIdentifierAndAssociatedValue, associatedValue, unexpectedBetweenAssociatedValueAndRawValue, rawValue, unexpectedBetweenRawValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAssignmentKeyword?.raw, - assignmentKeyword.raw, - unexpectedBetweenAssignmentKeywordAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndFlag?.raw, - flag.raw, - unexpectedAfterFlag?.raw, + unexpectedBeforeIdentifier?.raw, + identifier.raw, + unexpectedBetweenIdentifierAndAssociatedValue?.raw, + associatedValue?.raw, + unexpectedBetweenAssociatedValueAndRawValue?.raw, + rawValue?.raw, + unexpectedBetweenRawValueAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssignment, from: layout, arena: arena, + kind: SyntaxKind.enumCaseElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var assignmentKeyword: TokenSyntax { + /// The name of this case. + public var identifier: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + /// The set of associated values of the case. + public var associatedValue: ParameterClauseSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(ParameterClauseSyntax.init) } set(value) { - self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } /// - /// 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 raw value of this enum element, if present. /// - public var flag: TokenSyntax { + public var rawValue: InitializerClauseSyntax? { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(InitializerClauseSyntax.init) } set(value) { - self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterFlag: UnexpectedNodesSyntax? { + public var unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = EnumCaseElementSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + /// + /// The trailing comma of this element, if the case has + /// multiple elements. + /// + public var trailingComma: TokenSyntax? { + get { + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = EnumCaseElementSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = EnumCaseElementSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAssignmentKeyword, - \Self.assignmentKeyword, - \Self.unexpectedBetweenAssignmentKeywordAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndFlag, - \Self.flag, - \Self.unexpectedAfterFlag, + \Self.unexpectedBeforeIdentifier, + \Self.identifier, + \Self.unexpectedBetweenIdentifierAndAssociatedValue, + \Self.associatedValue, + \Self.unexpectedBetweenAssociatedValueAndRawValue, + \Self.rawValue, + \Self.unexpectedBetweenRawValueAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -8241,164 +8110,136 @@ public struct PrecedenceGroupAssignmentSyntax: 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 PrecedenceGroupAssignmentSyntax: CustomReflectable { +extension EnumCaseElementSyntax: 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, + "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: - PrecedenceGroupAssociativitySyntax +// MARK: - DesignatedTypeElementSyntax -/// -/// 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 struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssociativity else { return nil } + guard node.raw.kind == .designatedTypeElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrecedenceGroupAssociativitySyntax` 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 == .precedenceGroupAssociativity) + assert(data.raw.kind == .designatedTypeElement) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? = nil, - associativityKeyword: TokenSyntax = .keyword(.associativity), - _ unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, + leadingComma: TokenSyntax = .commaToken(), + _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssociativityKeyword, associativityKeyword, unexpectedBetweenAssociativityKeywordAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedAfterValue))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeadingComma, leadingComma, unexpectedBetweenLeadingCommaAndName, name, unexpectedAfterName))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAssociativityKeyword?.raw, - associativityKeyword.raw, - unexpectedBetweenAssociativityKeywordAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw, + unexpectedBeforeLeadingComma?.raw, + leadingComma.raw, + unexpectedBetweenLeadingCommaAndName?.raw, + name.raw, + unexpectedAfterName?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssociativity, from: layout, arena: arena, + kind: SyntaxKind.designatedTypeElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var associativityKeyword: TokenSyntax { + public var leadingComma: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var name: TokenSyntax { get { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + public var unexpectedAfterName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// 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 { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterValue: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DesignatedTypeElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAssociativityKeyword, - \Self.associativityKeyword, - \Self.unexpectedBetweenAssociativityKeywordAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedAfterValue, + \Self.unexpectedBeforeLeadingComma, + \Self.leadingComma, + \Self.unexpectedBetweenLeadingCommaAndName, + \Self.name, + \Self.unexpectedAfterName, ]) } @@ -8414,431 +8255,664 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension PrecedenceGroupAssociativitySyntax: CustomReflectable { +extension DesignatedTypeElementSyntax: 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, + "unexpectedBeforeLeadingComma": unexpectedBeforeLeadingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leadingComma": Syntax(leadingComma).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeadingCommaAndName": unexpectedBetweenLeadingCommaAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedAfterName": unexpectedAfterName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - AttributeSyntax +// MARK: - OperatorPrecedenceAndTypesSyntax /// -/// An `@` attribute. +/// A clause to specify precedence group in infix operator declarations, and designated types in any operator declaration. /// -public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { - public enum Argument: SyntaxChildChoices { - case `argumentList`(TupleExprElementListSyntax) - case `token`(TokenSyntax) - case `string`(StringLiteralExprSyntax) - case `availability`(AvailabilitySpecListSyntax) - case `specializeArguments`(SpecializeAttributeSpecListSyntax) - case `objCName`(ObjCSelectorSyntax) - case `implementsArguments`(ImplementsAttributeArgumentsSyntax) - case `differentiableArguments`(DifferentiableAttributeArgumentsSyntax) - case `derivativeRegistrationArguments`(DerivativeRegistrationAttributeArgumentsSyntax) - case `backDeployArguments`(BackDeployAttributeSpecListSyntax) - case `conventionArguments`(ConventionAttributeArgumentsSyntax) - case `conventionWitnessMethodArguments`(ConventionWitnessMethodAttributeArgumentsSyntax) - case `opaqueReturnTypeOfAttributeArguments`(OpaqueReturnTypeOfAttributeArgumentsSyntax) - case `exposeAttributeArguments`(ExposeAttributeArgumentsSyntax) - case `originallyDefinedInArguments`(OriginallyDefinedInArgumentsSyntax) - case `underscorePrivateAttributeArguments`(UnderscorePrivateAttributeArgumentsSyntax) - case `dynamicReplacementArguments`(DynamicReplacementArgumentsSyntax) - case `unavailableFromAsyncArguments`(UnavailableFromAsyncArgumentsSyntax) - case `effectsArguments`(EffectsArgumentsSyntax) - case `documentationArguments`(DocumentationAttributeArgumentsSyntax) - public var _syntaxNode: Syntax { - switch self { - case .argumentList(let node): return node._syntaxNode - case .token(let node): return node._syntaxNode - case .string(let node): return node._syntaxNode - case .availability(let node): return node._syntaxNode - case .specializeArguments(let node): return node._syntaxNode - case .objCName(let node): return node._syntaxNode - case .implementsArguments(let node): return node._syntaxNode - case .differentiableArguments(let node): return node._syntaxNode - case .derivativeRegistrationArguments(let node): return node._syntaxNode - case .backDeployArguments(let node): return node._syntaxNode - case .conventionArguments(let node): return node._syntaxNode - case .conventionWitnessMethodArguments(let node): return node._syntaxNode - case .opaqueReturnTypeOfAttributeArguments(let node): return node._syntaxNode - case .exposeAttributeArguments(let node): return node._syntaxNode - case .originallyDefinedInArguments(let node): return node._syntaxNode - case .underscorePrivateAttributeArguments(let node): return node._syntaxNode - case .dynamicReplacementArguments(let node): return node._syntaxNode - case .unavailableFromAsyncArguments(let node): return node._syntaxNode - case .effectsArguments(let node): return node._syntaxNode - case .documentationArguments(let node): return node._syntaxNode - } +public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .operatorPrecedenceAndTypes else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// 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 == .operatorPrecedenceAndTypes) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, + precedenceGroup: TokenSyntax, + _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, + designatedTypes: DesignatedTypeListSyntax, + _ unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeColon, colon, unexpectedBetweenColonAndPrecedenceGroup, precedenceGroup, unexpectedBetweenPrecedenceGroupAndDesignatedTypes, designatedTypes, unexpectedAfterDesignatedTypes))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeColon?.raw, + colon.raw, + unexpectedBetweenColonAndPrecedenceGroup?.raw, + precedenceGroup.raw, + unexpectedBetweenPrecedenceGroupAndDesignatedTypes?.raw, + designatedTypes.raw, + unexpectedAfterDesignatedTypes?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.operatorPrecedenceAndTypes, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: TupleExprElementListSyntax) { - self = .argumentList(node) + self.init(data) + } + + public var unexpectedBeforeColon: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } - public init(_ node: TokenSyntax) { - self = .token(node) + set(value) { + self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } - public init(_ node: StringLiteralExprSyntax) { - self = .string(node) + } + + public var colon: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } - public init(_ node: AvailabilitySpecListSyntax) { - self = .availability(node) + set(value) { + self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } - public init(_ node: SpecializeAttributeSpecListSyntax) { - self = .specializeArguments(node) + } + + public var unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } - public init(_ node: ObjCSelectorSyntax) { - self = .objCName(node) + set(value) { + self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } - public init(_ node: ImplementsAttributeArgumentsSyntax) { - self = .implementsArguments(node) + } + + /// + /// The precedence group for this operator + /// + public var precedenceGroup: TokenSyntax { + get { + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } - public init(_ node: DifferentiableAttributeArgumentsSyntax) { - self = .differentiableArguments(node) + set(value) { + self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } - public init(_ node: DerivativeRegistrationAttributeArgumentsSyntax) { - self = .derivativeRegistrationArguments(node) + } + + public var unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } - public init(_ node: BackDeployAttributeSpecListSyntax) { - self = .backDeployArguments(node) + set(value) { + self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + /// + /// The designated types associated with this operator. + /// + public var designatedTypes: DesignatedTypeListSyntax { + get { + return DesignatedTypeListSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + /// 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 var unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = OperatorPrecedenceAndTypesSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + 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 == .precedenceGroupRelation else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// 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 == .precedenceGroupRelation) + 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, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeHigherThanOrLowerThan, higherThanOrLowerThan, unexpectedBetweenHigherThanOrLowerThanAndColon, colon, unexpectedBetweenColonAndOtherNames, otherNames, unexpectedAfterOtherNames))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeHigherThanOrLowerThan?.raw, + higherThanOrLowerThan.raw, + unexpectedBetweenHigherThanOrLowerThanAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndOtherNames?.raw, + otherNames.raw, + unexpectedAfterOtherNames?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.precedenceGroupRelation, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + /// + /// The relation to specified other precedence groups. + /// + public var higherThanOrLowerThan: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var colon: TokenSyntax { + get { + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + /// + /// The name of other precedence group to which this precedence + /// group relates. + /// + public var otherNames: PrecedenceGroupNameListSyntax { + get { + return PrecedenceGroupNameListSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + /// 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) + } + + public var unexpectedAfterOtherNames: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = PrecedenceGroupRelationSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + 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") + } + } +} + +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, + ]) + } +} + +// 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 + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeName?.raw, + name.raw, + unexpectedBetweenNameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.precedenceGroupNameElement, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } - public init(_ node: ConventionAttributeArgumentsSyntax) { - self = .conventionArguments(node) + self.init(data) + } + + public var unexpectedBeforeName: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } - public init(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) { - self = .conventionWitnessMethodArguments(node) + set(value) { + self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } - public init(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) { - self = .opaqueReturnTypeOfAttributeArguments(node) + } + + public var name: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } - public init(_ node: ExposeAttributeArgumentsSyntax) { - self = .exposeAttributeArguments(node) + set(value) { + self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } - public init(_ node: OriginallyDefinedInArgumentsSyntax) { - self = .originallyDefinedInArguments(node) + } + + public var unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } - public init(_ node: UnderscorePrivateAttributeArgumentsSyntax) { - self = .underscorePrivateAttributeArguments(node) + set(value) { + self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } - public init(_ node: DynamicReplacementArgumentsSyntax) { - self = .dynamicReplacementArguments(node) + } + + public var trailingComma: TokenSyntax? { + get { + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } - public init(_ node: UnavailableFromAsyncArgumentsSyntax) { - self = .unavailableFromAsyncArguments(node) + set(value) { + self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } - public init(_ node: EffectsArgumentsSyntax) { - self = .effectsArguments(node) + } + + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } - public init(_ node: DocumentationAttributeArgumentsSyntax) { - self = .documentationArguments(node) + set(value) { + self = PrecedenceGroupNameElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } - public init?(_ node: S) { - if let node = node.as(TupleExprElementListSyntax.self) { - self = .argumentList(node) - return - } - if let node = node.as(TokenSyntax.self) { - self = .token(node) - return - } - if let node = node.as(StringLiteralExprSyntax.self) { - self = .string(node) - return - } - if let node = node.as(AvailabilitySpecListSyntax.self) { - self = .availability(node) - return - } - if let node = node.as(SpecializeAttributeSpecListSyntax.self) { - self = .specializeArguments(node) - return - } - if let node = node.as(ObjCSelectorSyntax.self) { - self = .objCName(node) - return - } - if let node = node.as(ImplementsAttributeArgumentsSyntax.self) { - self = .implementsArguments(node) - return - } - if let node = node.as(DifferentiableAttributeArgumentsSyntax.self) { - self = .differentiableArguments(node) - return - } - if let node = node.as(DerivativeRegistrationAttributeArgumentsSyntax.self) { - self = .derivativeRegistrationArguments(node) - return - } - if let node = node.as(BackDeployAttributeSpecListSyntax.self) { - self = .backDeployArguments(node) - return - } - if let node = node.as(ConventionAttributeArgumentsSyntax.self) { - self = .conventionArguments(node) - return - } - if let node = node.as(ConventionWitnessMethodAttributeArgumentsSyntax.self) { - self = .conventionWitnessMethodArguments(node) - return - } - if let node = node.as(OpaqueReturnTypeOfAttributeArgumentsSyntax.self) { - self = .opaqueReturnTypeOfAttributeArguments(node) - return - } - if let node = node.as(ExposeAttributeArgumentsSyntax.self) { - self = .exposeAttributeArguments(node) - return - } - if let node = node.as(OriginallyDefinedInArgumentsSyntax.self) { - self = .originallyDefinedInArguments(node) - return - } - if let node = node.as(UnderscorePrivateAttributeArgumentsSyntax.self) { - self = .underscorePrivateAttributeArguments(node) - return - } - if let node = node.as(DynamicReplacementArgumentsSyntax.self) { - self = .dynamicReplacementArguments(node) - return - } - if let node = node.as(UnavailableFromAsyncArgumentsSyntax.self) { - self = .unavailableFromAsyncArguments(node) - return - } - if let node = node.as(EffectsArgumentsSyntax.self) { - self = .effectsArguments(node) - return - } - if let node = node.as(DocumentationAttributeArgumentsSyntax.self) { - self = .documentationArguments(node) - return - } + } + + 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") } + } +} - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(TupleExprElementListSyntax.self), - .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(BackDeployAttributeSpecListSyntax.self), - .node(ConventionAttributeArgumentsSyntax.self), - .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), - .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), - .node(ExposeAttributeArgumentsSyntax.self), - .node(OriginallyDefinedInArgumentsSyntax.self), - .node(UnderscorePrivateAttributeArgumentsSyntax.self), - .node(DynamicReplacementArgumentsSyntax.self), - .node(UnavailableFromAsyncArgumentsSyntax.self), - .node(EffectsArgumentsSyntax.self), - .node(DocumentationAttributeArgumentsSyntax.self), - ]) - } +extension PrecedenceGroupNameElementSyntax: 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: - PrecedenceGroupAssignmentSyntax +/// +/// Specifies the precedence of an operator when used in an operation +/// that includes optional chaining. +/// +public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .attribute else { return nil } + guard node.raw.kind == .precedenceGroupAssignment else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AttributeSyntax` 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 == .attribute) + assert(data.raw.kind == .precedenceGroupAssignment) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, - atSignToken: TokenSyntax = .atSignToken(), - _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, - attributeName: A, - _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, - argument: Argument? = nil, - _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? = nil, + assignmentKeyword: TokenSyntax = .keyword(.assignment), + _ unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, + flag: TokenSyntax, + _ unexpectedAfterFlag: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAtSignToken, atSignToken, unexpectedBetweenAtSignTokenAndAttributeName, attributeName, unexpectedBetweenAttributeNameAndLeftParen, leftParen, unexpectedBetweenLeftParenAndArgument, argument, unexpectedBetweenArgumentAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssignmentKeyword, assignmentKeyword, unexpectedBetweenAssignmentKeywordAndColon, colon, unexpectedBetweenColonAndFlag, flag, unexpectedAfterFlag))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAtSignToken?.raw, - atSignToken.raw, - unexpectedBetweenAtSignTokenAndAttributeName?.raw, - attributeName.raw, - unexpectedBetweenAttributeNameAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArgument?.raw, - argument?.raw, - unexpectedBetweenArgumentAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeAssignmentKeyword?.raw, + assignmentKeyword.raw, + unexpectedBetweenAssignmentKeywordAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndFlag?.raw, + flag.raw, + unexpectedAfterFlag?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.attribute, from: layout, arena: arena, + kind: SyntaxKind.precedenceGroupAssignment, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? { + public var unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AttributeSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The `@` sign. - public var atSignToken: TokenSyntax { + public var assignmentKeyword: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = AttributeSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AttributeSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The name of the attribute. - public var attributeName: TypeSyntax { + public var colon: TokenSyntax { get { - return TypeSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = AttributeSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AttributeSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } /// - /// If the attribute takes arguments, the opening parenthesis. + /// 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 leftParen: TokenSyntax? { + public var flag: TokenSyntax { get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = AttributeSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? { + public var unexpectedAfterFlag: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AttributeSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// 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 { - return data.child(at: 7, parent: Syntax(self)).map(Argument.init) - } - set(value) { - self = AttributeSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = AttributeSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// If the attribute takes arguments, the closing parenthesis. - /// - public var rightParen: TokenSyntax? { - get { - return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = AttributeSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = AttributeSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssignmentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAtSignToken, - \Self.atSignToken, - \Self.unexpectedBetweenAtSignTokenAndAttributeName, - \Self.attributeName, - \Self.unexpectedBetweenAttributeNameAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndArgument, - \Self.argument, - \Self.unexpectedBetweenArgumentAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeAssignmentKeyword, + \Self.assignmentKeyword, + \Self.unexpectedBetweenAssignmentKeywordAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndFlag, + \Self.flag, + \Self.unexpectedAfterFlag, ]) } @@ -8851,214 +8925,164 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "name" + return nil case 4: return nil case 5: return nil case 6: return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension AttributeSyntax: CustomReflectable { +extension PrecedenceGroupAssignmentSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAtSignToken": unexpectedBeforeAtSignToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "atSignToken": Syntax(atSignToken).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAtSignTokenAndAttributeName": unexpectedBetweenAtSignTokenAndAttributeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "attributeName": Syntax(attributeName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAttributeNameAndLeftParen": unexpectedBetweenAttributeNameAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": leftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenLeftParenAndArgument": unexpectedBetweenLeftParenAndArgument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "argument": argument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenArgumentAndRightParen": unexpectedBetweenArgumentAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": rightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - AvailabilityEntrySyntax +// MARK: - PrecedenceGroupAssociativitySyntax /// -/// The availability argument for the _specialize attribute +/// Specifies how a sequence of operators with the same precedence level +/// are grouped together in the absence of grouping parentheses. /// -public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityEntry else { return nil } + guard node.raw.kind == .precedenceGroupAssociativity else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AvailabilityEntrySyntax` 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 == .availabilityEntry) + assert(data.raw.kind == .precedenceGroupAssociativity) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax = .keyword(.availability), - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? = nil, + associativityKeyword: TokenSyntax = .keyword(.associativity), + _ unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, - availabilityList: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax = .semicolonToken(), - _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndAvailabilityList, availabilityList, unexpectedBetweenAvailabilityListAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssociativityKeyword, associativityKeyword, unexpectedBetweenAssociativityKeywordAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedAfterValue))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, + unexpectedBeforeAssociativityKeyword?.raw, + associativityKeyword.raw, + unexpectedBetweenAssociativityKeywordAndColon?.raw, colon.raw, - unexpectedBetweenColonAndAvailabilityList?.raw, - availabilityList.raw, - unexpectedBetweenAvailabilityListAndSemicolon?.raw, - semicolon.raw, - unexpectedAfterSemicolon?.raw, + unexpectedBetweenColonAndValue?.raw, + value.raw, + unexpectedAfterValue?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityEntry, 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 { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The label of the argument - public var label: TokenSyntax { + public var associativityKeyword: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The colon separating the label and the value public var colon: TokenSyntax { get { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var availabilityList: AvailabilitySpecListSyntax { + /// + /// 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 { - return AvailabilitySpecListSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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) + self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return AvailabilityEntrySyntax(newData) } - public var unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? { + public var unexpectedAfterValue: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public var semicolon: TokenSyntax { - get { - return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) - } - set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = AvailabilityEntrySyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = PrecedenceGroupAssociativitySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, + return .layout([ + \Self.unexpectedBeforeAssociativityKeyword, + \Self.associativityKeyword, + \Self.unexpectedBetweenAssociativityKeywordAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndAvailabilityList, - \Self.availabilityList, - \Self.unexpectedBetweenAvailabilityListAndSemicolon, - \Self.semicolon, - \Self.unexpectedAfterSemicolon, + \Self.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedAfterValue, ]) } @@ -9067,7 +9091,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -9078,187 +9102,427 @@ 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 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), - "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, + "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: - LabeledSpecializeEntrySyntax +// MARK: - AttributeSyntax /// -/// A labeled argument for the `@_specialize` attribute like -/// `exported: true` +/// An `@` attribute. /// -public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { + public enum Argument: SyntaxChildChoices { + case `argumentList`(TupleExprElementListSyntax) + case `token`(TokenSyntax) + case `string`(StringLiteralExprSyntax) + case `availability`(AvailabilitySpecListSyntax) + case `specializeArguments`(SpecializeAttributeSpecListSyntax) + case `objCName`(ObjCSelectorSyntax) + case `implementsArguments`(ImplementsAttributeArgumentsSyntax) + case `differentiableArguments`(DifferentiableAttributeArgumentsSyntax) + case `derivativeRegistrationArguments`(DerivativeRegistrationAttributeArgumentsSyntax) + case `backDeployArguments`(BackDeployAttributeSpecListSyntax) + case `conventionArguments`(ConventionAttributeArgumentsSyntax) + case `conventionWitnessMethodArguments`(ConventionWitnessMethodAttributeArgumentsSyntax) + case `opaqueReturnTypeOfAttributeArguments`(OpaqueReturnTypeOfAttributeArgumentsSyntax) + case `exposeAttributeArguments`(ExposeAttributeArgumentsSyntax) + case `originallyDefinedInArguments`(OriginallyDefinedInArgumentsSyntax) + case `underscorePrivateAttributeArguments`(UnderscorePrivateAttributeArgumentsSyntax) + case `dynamicReplacementArguments`(DynamicReplacementArgumentsSyntax) + case `unavailableFromAsyncArguments`(UnavailableFromAsyncArgumentsSyntax) + case `effectsArguments`(EffectsArgumentsSyntax) + case `documentationArguments`(DocumentationAttributeArgumentsSyntax) + public var _syntaxNode: Syntax { + switch self { + case .argumentList(let node): return node._syntaxNode + case .token(let node): return node._syntaxNode + case .string(let node): return node._syntaxNode + case .availability(let node): return node._syntaxNode + case .specializeArguments(let node): return node._syntaxNode + case .objCName(let node): return node._syntaxNode + case .implementsArguments(let node): return node._syntaxNode + case .differentiableArguments(let node): return node._syntaxNode + case .derivativeRegistrationArguments(let node): return node._syntaxNode + case .backDeployArguments(let node): return node._syntaxNode + case .conventionArguments(let node): return node._syntaxNode + case .conventionWitnessMethodArguments(let node): return node._syntaxNode + case .opaqueReturnTypeOfAttributeArguments(let node): return node._syntaxNode + case .exposeAttributeArguments(let node): return node._syntaxNode + case .originallyDefinedInArguments(let node): return node._syntaxNode + case .underscorePrivateAttributeArguments(let node): return node._syntaxNode + case .dynamicReplacementArguments(let node): return node._syntaxNode + case .unavailableFromAsyncArguments(let node): return node._syntaxNode + case .effectsArguments(let node): return node._syntaxNode + case .documentationArguments(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: TupleExprElementListSyntax) { + self = .argumentList(node) + } + public init(_ node: TokenSyntax) { + self = .token(node) + } + public init(_ node: StringLiteralExprSyntax) { + self = .string(node) + } + public init(_ node: AvailabilitySpecListSyntax) { + self = .availability(node) + } + public init(_ node: SpecializeAttributeSpecListSyntax) { + self = .specializeArguments(node) + } + public init(_ node: ObjCSelectorSyntax) { + self = .objCName(node) + } + public init(_ node: ImplementsAttributeArgumentsSyntax) { + self = .implementsArguments(node) + } + public init(_ node: DifferentiableAttributeArgumentsSyntax) { + self = .differentiableArguments(node) + } + public init(_ node: DerivativeRegistrationAttributeArgumentsSyntax) { + self = .derivativeRegistrationArguments(node) + } + public init(_ node: BackDeployAttributeSpecListSyntax) { + self = .backDeployArguments(node) + } + public init(_ node: ConventionAttributeArgumentsSyntax) { + self = .conventionArguments(node) + } + public init(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) { + self = .conventionWitnessMethodArguments(node) + } + public init(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) { + self = .opaqueReturnTypeOfAttributeArguments(node) + } + public init(_ node: ExposeAttributeArgumentsSyntax) { + self = .exposeAttributeArguments(node) + } + public init(_ node: OriginallyDefinedInArgumentsSyntax) { + self = .originallyDefinedInArguments(node) + } + public init(_ node: UnderscorePrivateAttributeArgumentsSyntax) { + self = .underscorePrivateAttributeArguments(node) + } + public init(_ node: DynamicReplacementArgumentsSyntax) { + self = .dynamicReplacementArguments(node) + } + public init(_ node: UnavailableFromAsyncArgumentsSyntax) { + self = .unavailableFromAsyncArguments(node) + } + public init(_ node: EffectsArgumentsSyntax) { + self = .effectsArguments(node) + } + public init(_ node: DocumentationAttributeArgumentsSyntax) { + self = .documentationArguments(node) + } + public init?(_ node: S) { + if let node = node.as(TupleExprElementListSyntax.self) { + self = .argumentList(node) + return + } + if let node = node.as(TokenSyntax.self) { + self = .token(node) + return + } + if let node = node.as(StringLiteralExprSyntax.self) { + self = .string(node) + return + } + if let node = node.as(AvailabilitySpecListSyntax.self) { + self = .availability(node) + return + } + if let node = node.as(SpecializeAttributeSpecListSyntax.self) { + self = .specializeArguments(node) + return + } + if let node = node.as(ObjCSelectorSyntax.self) { + self = .objCName(node) + return + } + if let node = node.as(ImplementsAttributeArgumentsSyntax.self) { + self = .implementsArguments(node) + return + } + if let node = node.as(DifferentiableAttributeArgumentsSyntax.self) { + self = .differentiableArguments(node) + return + } + if let node = node.as(DerivativeRegistrationAttributeArgumentsSyntax.self) { + self = .derivativeRegistrationArguments(node) + return + } + if let node = node.as(BackDeployAttributeSpecListSyntax.self) { + self = .backDeployArguments(node) + return + } + if let node = node.as(ConventionAttributeArgumentsSyntax.self) { + self = .conventionArguments(node) + return + } + if let node = node.as(ConventionWitnessMethodAttributeArgumentsSyntax.self) { + self = .conventionWitnessMethodArguments(node) + return + } + if let node = node.as(OpaqueReturnTypeOfAttributeArgumentsSyntax.self) { + self = .opaqueReturnTypeOfAttributeArguments(node) + return + } + if let node = node.as(ExposeAttributeArgumentsSyntax.self) { + self = .exposeAttributeArguments(node) + return + } + if let node = node.as(OriginallyDefinedInArgumentsSyntax.self) { + self = .originallyDefinedInArguments(node) + return + } + if let node = node.as(UnderscorePrivateAttributeArgumentsSyntax.self) { + self = .underscorePrivateAttributeArguments(node) + return + } + if let node = node.as(DynamicReplacementArgumentsSyntax.self) { + self = .dynamicReplacementArguments(node) + return + } + if let node = node.as(UnavailableFromAsyncArgumentsSyntax.self) { + self = .unavailableFromAsyncArguments(node) + return + } + if let node = node.as(EffectsArgumentsSyntax.self) { + self = .effectsArguments(node) + return + } + if let node = node.as(DocumentationAttributeArgumentsSyntax.self) { + self = .documentationArguments(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(TupleExprElementListSyntax.self), + .node(TokenSyntax.self), + .node(StringLiteralExprSyntax.self), + .node(AvailabilitySpecListSyntax.self), + .node(SpecializeAttributeSpecListSyntax.self), + .node(ObjCSelectorSyntax.self), + .node(ImplementsAttributeArgumentsSyntax.self), + .node(DifferentiableAttributeArgumentsSyntax.self), + .node(DerivativeRegistrationAttributeArgumentsSyntax.self), + .node(BackDeployAttributeSpecListSyntax.self), + .node(ConventionAttributeArgumentsSyntax.self), + .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), + .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), + .node(ExposeAttributeArgumentsSyntax.self), + .node(OriginallyDefinedInArgumentsSyntax.self), + .node(UnderscorePrivateAttributeArgumentsSyntax.self), + .node(DynamicReplacementArgumentsSyntax.self), + .node(UnavailableFromAsyncArgumentsSyntax.self), + .node(EffectsArgumentsSyntax.self), + .node(DocumentationAttributeArgumentsSyntax.self), + ]) + } + } + public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .labeledSpecializeEntry else { return nil } + guard node.raw.kind == .attribute else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `LabeledSpecializeEntrySyntax` 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 == .labeledSpecializeEntry) + assert(data.raw.kind == .attribute) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, + atSignToken: TokenSyntax = .atSignToken(), + _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, + attributeName: A, + _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, + argument: Argument? = nil, + _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAtSignToken, atSignToken, unexpectedBetweenAtSignTokenAndAttributeName, attributeName, unexpectedBetweenAttributeNameAndLeftParen, leftParen, unexpectedBetweenLeftParenAndArgument, argument, unexpectedBetweenArgumentAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeAtSignToken?.raw, + atSignToken.raw, + unexpectedBetweenAtSignTokenAndAttributeName?.raw, + attributeName.raw, + unexpectedBetweenAttributeNameAndLeftParen?.raw, + leftParen?.raw, + unexpectedBetweenLeftParenAndArgument?.raw, + argument?.raw, + unexpectedBetweenArgumentAndRightParen?.raw, + rightParen?.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.labeledSpecializeEntry, from: layout, arena: arena, + kind: SyntaxKind.attribute, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The label of the argument - public var label: TokenSyntax { + /// The `@` sign. + public var atSignToken: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The colon separating the label and the value - public var colon: TokenSyntax { + /// The name of the attribute. + public var attributeName: TypeSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return TypeSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - /// The value for this argument - public var value: TokenSyntax { + /// + /// If the attribute takes arguments, the opening parenthesis. + /// + public var leftParen: TokenSyntax? { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } /// - /// A trailing comma if this argument is followed by another one + /// The arguments of the attribute. In case the attribute + /// takes multiple arguments, they are gather in the + /// appropriate takes first. /// - public var trailingComma: TokenSyntax? { + public var argument: Argument? { get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(Argument.init) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = AttributeSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + /// + /// If the attribute takes arguments, the closing parenthesis. + /// + public var rightParen: TokenSyntax? { + get { + return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = AttributeSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AttributeSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedBetweenValueAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeAtSignToken, + \Self.atSignToken, + \Self.unexpectedBetweenAtSignTokenAndAttributeName, + \Self.attributeName, + \Self.unexpectedBetweenAttributeNameAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndArgument, + \Self.argument, + \Self.unexpectedBetweenArgumentAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -9267,95 +9531,99 @@ public struct LabeledSpecializeEntrySyntax: 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 default: fatalError("Invalid index") } } } -extension LabeledSpecializeEntrySyntax: CustomReflectable { +extension AttributeSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLabel": unexpectedBeforeLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "label": Syntax(label).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLabelAndColon": unexpectedBetweenLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndValue": unexpectedBetweenColonAndValue.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "value": Syntax(value).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenValueAndTrailingComma": unexpectedBetweenValueAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "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, + "unexpectedBetweenLeftParenAndArgument": unexpectedBetweenLeftParenAndArgument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "argument": argument.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenArgumentAndRightParen": unexpectedBetweenArgumentAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightParen": rightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - TargetFunctionEntrySyntax +// MARK: - AvailabilityEntrySyntax /// -/// A labeled argument for the `@_specialize` attribute with a function -/// decl value like -/// `target: myFunc(_:)` +/// The availability argument for the _specialize attribute /// -public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { +public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .targetFunctionEntry else { return nil } + guard node.raw.kind == .availabilityEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `TargetFunctionEntrySyntax` 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 == .targetFunctionEntry) + assert(data.raw.kind == .availabilityEntry) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax = .keyword(.target), + label: TokenSyntax = .keyword(.availability), _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, - declname: DeclNameSyntax, - _ unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, + availabilityList: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax = .semicolonToken(), + _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndDeclname, declname, unexpectedBetweenDeclnameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndAvailabilityList, availabilityList, unexpectedBetweenAvailabilityListAndSemicolon, semicolon, unexpectedAfterSemicolon))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label.raw, unexpectedBetweenLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndDeclname?.raw, - declname.raw, - unexpectedBetweenDeclnameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBetweenColonAndAvailabilityList?.raw, + availabilityList.raw, + unexpectedBetweenAvailabilityListAndSemicolon?.raw, + semicolon.raw, + unexpectedAfterSemicolon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.targetFunctionEntry, from: layout, arena: arena, + kind: SyntaxKind.availabilityEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } @@ -9367,7 +9635,7 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } @@ -9377,7 +9645,7 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } @@ -9386,7 +9654,7 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } @@ -9396,56 +9664,71 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - /// The value for this argument - public var declname: DeclNameSyntax { + public var availabilityList: AvailabilitySpecListSyntax { get { - return DeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) + return AvailabilitySpecListSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + /// 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) } - public var unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - /// - /// A trailing comma if this argument is followed by another one - /// - public var trailingComma: TokenSyntax? { + public var semicolon: TokenSyntax { get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterSemicolon: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = TargetFunctionEntrySyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityEntrySyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } @@ -9455,11 +9738,11 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { \Self.label, \Self.unexpectedBetweenLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndDeclname, - \Self.declname, - \Self.unexpectedBetweenDeclnameAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBetweenColonAndAvailabilityList, + \Self.availabilityList, + \Self.unexpectedBetweenAvailabilityListAndSemicolon, + \Self.semicolon, + \Self.unexpectedAfterSemicolon, ]) } @@ -9476,7 +9759,7 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return "declaration name" + return nil case 6: return nil case 7: @@ -9489,126 +9772,177 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { } } -extension TargetFunctionEntrySyntax: CustomReflectable { +extension AvailabilityEntrySyntax: 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, + "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: - DeclNameSyntax +// MARK: - LabeledSpecializeEntrySyntax -public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// A labeled argument for the `@_specialize` attribute like +/// `exported: true` +/// +public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declName else { return nil } + guard node.raw.kind == .labeledSpecializeEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DeclNameSyntax` 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 == .declName) + assert(data.raw.kind == .labeledSpecializeEntry) 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(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDeclBaseName?.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 raw = RawSyntax.makeLayout( - kind: SyntaxKind.declName, from: layout, arena: arena, + kind: SyntaxKind.labeledSpecializeEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The base name of the protocol's requirement. - /// - public var declBaseName: TokenSyntax { + /// The label of the argument + public var label: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The colon separating the label and the value + public var colon: TokenSyntax { + get { + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + /// The value for this argument + public var value: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } /// - /// 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 { - return data.child(at: 3, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DeclNameSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = LabeledSpecializeEntrySyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } 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.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedBetweenValueAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -9617,194 +9951,199 @@ 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 "value" + case 6: + return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension DeclNameSyntax: CustomReflectable { +extension LabeledSpecializeEntrySyntax: 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), + "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: - ImplementsAttributeArgumentsSyntax +// MARK: - TargetFunctionEntrySyntax /// -/// The arguments for the `@_implements` attribute of the form -/// `Type, methodName(arg1Label:arg2Label:)` +/// A labeled argument for the `@_specialize` attribute with a function +/// decl value like +/// `target: myFunc(_:)` /// -public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .implementsAttributeArguments else { return nil } + guard node.raw.kind == .targetFunctionEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ImplementsAttributeArgumentsSyntax` 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 == .implementsAttributeArguments) + assert(data.raw.kind == .targetFunctionEntry) 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 = .keyword(.target), + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, + declname: DeclNameSyntax, + _ unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeType, type, unexpectedBetweenTypeAndComma, comma, unexpectedBetweenCommaAndDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndDeclname, declname, unexpectedBetweenDeclnameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedBetweenTypeAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndDeclBaseName?.raw, - declBaseName.raw, - unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, - declNameArguments?.raw, - unexpectedAfterDeclNameArguments?.raw, + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndDeclname?.raw, + declname.raw, + unexpectedBetweenDeclnameAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.implementsAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.targetFunctionEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeType: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// - /// 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 { - return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// - /// 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 { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The base name of the protocol's requirement. - /// - public var declBaseName: TokenSyntax { + /// The value for this argument + public var declname: DeclNameSyntax { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return DeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } /// - /// 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 { - return data.child(at: 7, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = TargetFunctionEntrySyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } 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.unexpectedBetweenColonAndDeclname, + \Self.declname, + \Self.unexpectedBetweenDeclnameAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -9813,7 +10152,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 0: return nil case 1: - return "type" + return "label" case 2: return nil case 3: @@ -9821,11 +10160,11 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable case 4: return nil case 5: - return "declaration base name" + return "declaration name" case 6: return nil case 7: - return "declaration name arguments" + return nil case 8: return nil default: @@ -9834,124 +10173,126 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } -extension ImplementsAttributeArgumentsSyntax: CustomReflectable { +extension TargetFunctionEntrySyntax: 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), + "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: - ObjCSelectorPieceSyntax +// MARK: - DeclNameSyntax -/// -/// 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 ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { +public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .objCSelectorPiece else { return nil } + guard node.raw.kind == .declName else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ObjCSelectorPieceSyntax` 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 == .objCSelectorPiece) + assert(data.raw.kind == .declName) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax? = nil, - _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? = nil, + declBaseName: TokenSyntax, + _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndColon, colon, unexpectedAfterColon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name?.raw, - unexpectedBetweenNameAndColon?.raw, - colon?.raw, - unexpectedAfterColon?.raw, + unexpectedBeforeDeclBaseName?.raw, + declBaseName.raw, + unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedAfterDeclNameArguments?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.objCSelectorPiece, from: layout, arena: arena, + kind: SyntaxKind.declName, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeName: UnexpectedNodesSyntax? { + public var unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ObjCSelectorPieceSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var name: TokenSyntax? { + /// + /// The base name of the protocol's requirement. + /// + public var declBaseName: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ObjCSelectorPieceSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ObjCSelectorPieceSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax? { + /// + /// The argument labels of the protocol's requirement if it + /// is a function requirement. + /// + public var declNameArguments: DeclNameArgumentsSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) } set(value) { - self = ObjCSelectorPieceSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterColon: UnexpectedNodesSyntax? { + public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ObjCSelectorPieceSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DeclNameSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndColon, - \Self.colon, - \Self.unexpectedAfterColon, + \Self.unexpectedBeforeDeclBaseName, + \Self.declBaseName, + \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedAfterDeclNameArguments, ]) } @@ -9960,11 +10301,11 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "name" + return "base name" case 2: return nil case 3: - return nil + return "arguments" case 4: return nil default: @@ -9973,199 +10314,181 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { } } -extension ObjCSelectorPieceSyntax: CustomReflectable { +extension DeclNameSyntax: 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, + "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: - DifferentiableAttributeArgumentsSyntax +// MARK: - ImplementsAttributeArgumentsSyntax /// -/// The arguments for the `@differentiable` attribute: an optional -/// differentiability kind, an optional differentiability parameter clause, -/// and an optional 'where' clause. +/// The arguments for the `@_implements` attribute of the form +/// `Type, methodName(arg1Label:arg2Label:)` /// -public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiableAttributeArguments else { return nil } + guard node.raw.kind == .implementsAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiableAttributeArgumentsSyntax` 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 == .differentiableAttributeArguments) + assert(data.raw.kind == .implementsAttributeArguments) self._syntaxNode = Syntax(data) } - public init( + 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, + _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? = nil, + declBaseName: TokenSyntax, + _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDiffKind, diffKind, unexpectedBetweenDiffKindAndDiffKindComma, diffKindComma, unexpectedBetweenDiffKindCommaAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndDiffParamsComma, diffParamsComma, unexpectedBetweenDiffParamsCommaAndWhereClause, whereClause, unexpectedAfterWhereClause))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeType, type, unexpectedBetweenTypeAndComma, comma, unexpectedBetweenCommaAndDeclBaseName, declBaseName, unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDiffKind?.raw, - diffKind?.raw, - unexpectedBetweenDiffKindAndDiffKindComma?.raw, - diffKindComma?.raw, - unexpectedBetweenDiffKindCommaAndDiffParams?.raw, - diffParams?.raw, - unexpectedBetweenDiffParamsAndDiffParamsComma?.raw, - diffParamsComma?.raw, - unexpectedBetweenDiffParamsCommaAndWhereClause?.raw, - whereClause?.raw, - unexpectedAfterWhereClause?.raw, + unexpectedBeforeType?.raw, + type.raw, + unexpectedBetweenTypeAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndDeclBaseName?.raw, + declBaseName.raw, + unexpectedBetweenDeclBaseNameAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedAfterDeclNameArguments?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiableAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.implementsAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDiffKind: UnexpectedNodesSyntax? { + public var unexpectedBeforeType: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var diffKind: TokenSyntax? { + /// + /// The type for which the method with this attribute + /// implements a requirement. + /// + public var type: TypeSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) + return TypeSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } /// - /// The comma following the differentiability kind, if it exists. + /// The comma separating the type and method name /// - public var diffKindComma: TokenSyntax? { + public var comma: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var diffParams: DifferentiabilityParamsClauseSyntax? { + /// + /// The base name of the protocol's requirement. + /// + public var declBaseName: TokenSyntax { get { - return data.child(at: 5, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } /// - /// The comma following the differentiability parameters clause, - /// if it exists. + /// The argument labels of the protocol's requirement if it + /// is a function requirement. /// - public var diffParamsComma: TokenSyntax? { + public var declNameArguments: DeclNameArgumentsSyntax? { get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { + public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } - } - - public var whereClause: GenericWhereClauseSyntax? { - get { - return data.child(at: 9, parent: Syntax(self)).map(GenericWhereClauseSyntax.init) - } - set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = ImplementsAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDiffKind, - \Self.diffKind, - \Self.unexpectedBetweenDiffKindAndDiffKindComma, - \Self.diffKindComma, - \Self.unexpectedBetweenDiffKindCommaAndDiffParams, - \Self.diffParams, - \Self.unexpectedBetweenDiffParamsAndDiffParamsComma, - \Self.diffParamsComma, - \Self.unexpectedBetweenDiffParamsCommaAndWhereClause, - \Self.whereClause, - \Self.unexpectedAfterWhereClause, + \Self.unexpectedBeforeType, + \Self.type, + \Self.unexpectedBetweenTypeAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndDeclBaseName, + \Self.declBaseName, + \Self.unexpectedBetweenDeclBaseNameAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedAfterDeclNameArguments, ]) } @@ -10174,7 +10497,7 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash case 0: return nil case 1: - return nil + return "type" case 2: return nil case 3: @@ -10182,203 +10505,137 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash case 4: return nil case 5: - return nil + return "declaration base name" case 6: return nil case 7: - return nil + return "declaration name arguments" case 8: return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension DifferentiableAttributeArgumentsSyntax: CustomReflectable { +extension ImplementsAttributeArgumentsSyntax: 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, + "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: - DifferentiabilityParamsClauseSyntax - -/// A clause containing differentiability parameters. -public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashable { - public enum Parameters: SyntaxChildChoices { - case `parameter`(DifferentiabilityParamSyntax) - case `parameterList`(DifferentiabilityParamsSyntax) - public var _syntaxNode: Syntax { - switch self { - case .parameter(let node): return node._syntaxNode - case .parameterList(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: DifferentiabilityParamSyntax) { - self = .parameter(node) - } - public init(_ node: DifferentiabilityParamsSyntax) { - self = .parameterList(node) - } - public init?(_ node: S) { - if let node = node.as(DifferentiabilityParamSyntax.self) { - self = .parameter(node) - return - } - if let node = node.as(DifferentiabilityParamsSyntax.self) { - self = .parameterList(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(DifferentiabilityParamSyntax.self), - .node(DifferentiabilityParamsSyntax.self), - ]) - } - } +// MARK: - ObjCSelectorPieceSyntax +/// +/// 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 ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParamsClause else { return nil } + guard node.raw.kind == .objCSelectorPiece else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamsClauseSyntax` 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 == .differentiabilityParamsClause) + assert(data.raw.kind == .objCSelectorPiece) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, - wrtLabel: TokenSyntax = .keyword(.wrt), - _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, - parameters: Parameters, - _ unexpectedAfterParameters: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax? = nil, + _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWrtLabel, wrtLabel, unexpectedBetweenWrtLabelAndColon, colon, unexpectedBetweenColonAndParameters, parameters, unexpectedAfterParameters))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeName, name, unexpectedBetweenNameAndColon, colon, unexpectedAfterColon))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWrtLabel?.raw, - wrtLabel.raw, - unexpectedBetweenWrtLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndParameters?.raw, - parameters.raw, - unexpectedAfterParameters?.raw, + unexpectedBeforeName?.raw, + name?.raw, + unexpectedBetweenNameAndColon?.raw, + colon?.raw, + unexpectedAfterColon?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParamsClause, from: layout, arena: arena, + kind: SyntaxKind.objCSelectorPiece, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ObjCSelectorPieceSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The "wrt" label. - public var wrtLabel: TokenSyntax { + public var name: TokenSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ObjCSelectorPieceSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ObjCSelectorPieceSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The colon separating "wrt" and the parameter list. - /// - public var colon: TokenSyntax { + public var colon: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ObjCSelectorPieceSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { + public var unexpectedAfterColon: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var parameters: Parameters { - get { - return Parameters(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterParameters: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ObjCSelectorPieceSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWrtLabel, - \Self.wrtLabel, - \Self.unexpectedBetweenWrtLabelAndColon, + \Self.unexpectedBeforeName, + \Self.name, + \Self.unexpectedBetweenNameAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndParameters, - \Self.parameters, - \Self.unexpectedAfterParameters, + \Self.unexpectedAfterColon, ]) } @@ -10387,179 +10644,212 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl case 0: return nil case 1: - return nil + return "name" case 2: return nil case 3: return nil case 4: return nil - case 5: - return "parameters" - case 6: - return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamsClauseSyntax: CustomReflectable { +extension ObjCSelectorPieceSyntax: 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, + "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: - DifferentiabilityParamsSyntax +// MARK: - DifferentiableAttributeArgumentsSyntax -/// The differentiability parameters. -public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the `@differentiable` attribute: an optional +/// differentiability kind, an optional differentiability parameter clause, +/// and an optional 'where' clause. +/// +public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParams else { return nil } + guard node.raw.kind == .differentiableAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamsSyntax` 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 == .differentiabilityParams) + assert(data.raw.kind == .differentiableAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? = nil, - diffParams: DifferentiabilityParamListSyntax, - _ unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeDiffKind: UnexpectedNodesSyntax? = nil, + diffKind: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? = nil, + diffKindComma: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamsClauseSyntax? = nil, + _ unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? = nil, + diffParamsComma: TokenSyntax? = nil, + _ unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedAfterWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDiffKind, diffKind, unexpectedBetweenDiffKindAndDiffKindComma, diffKindComma, unexpectedBetweenDiffKindCommaAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndDiffParamsComma, diffParamsComma, unexpectedBetweenDiffParamsCommaAndWhereClause, whereClause, unexpectedAfterWhereClause))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndDiffParams?.raw, - diffParams.raw, - unexpectedBetweenDiffParamsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeDiffKind?.raw, + diffKind?.raw, + unexpectedBetweenDiffKindAndDiffKindComma?.raw, + diffKindComma?.raw, + unexpectedBetweenDiffKindCommaAndDiffParams?.raw, + diffParams?.raw, + unexpectedBetweenDiffParamsAndDiffParamsComma?.raw, + diffParamsComma?.raw, + unexpectedBetweenDiffParamsCommaAndWhereClause?.raw, + whereClause?.raw, + unexpectedAfterWhereClause?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParams, from: layout, arena: arena, + kind: SyntaxKind.differentiableAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeDiffKind: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { + public var diffKind: TokenSyntax? { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// The parameters for differentiation. - public var diffParams: DifferentiabilityParamListSyntax { + /// + /// The comma following the differentiability kind, if it exists. + /// + public var diffKindComma: TokenSyntax? { get { - return DifferentiabilityParamListSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - /// Adds the provided `DifferentiabilityParam` to the node's `diffParams` - /// collection. - /// - param element: The new `DifferentiabilityParam` to add to the node's - /// `diffParams` collection. - /// - returns: A copy of the receiver with the provided `DifferentiabilityParam` - /// appended to its `diffParams` collection. - public func addDifferentiabilityParam(_ element: DifferentiabilityParamSyntax) -> DifferentiabilityParamsSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[3] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, - from: [element.raw], arena: arena) + public var unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? { + public var diffParams: DifferentiabilityParamsClauseSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 5, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var rightParen: TokenSyntax { + public var unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + /// + /// The comma following the differentiability parameters clause, + /// if it exists. + /// + public var diffParamsComma: TokenSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DifferentiabilityParamsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var whereClause: GenericWhereClauseSyntax? { + get { + return data.child(at: 9, parent: Syntax(self)).map(GenericWhereClauseSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterWhereClause: UnexpectedNodesSyntax? { + get { + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DifferentiableAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndDiffParams, + \Self.unexpectedBeforeDiffKind, + \Self.diffKind, + \Self.unexpectedBetweenDiffKindAndDiffKindComma, + \Self.diffKindComma, + \Self.unexpectedBetweenDiffKindCommaAndDiffParams, \Self.diffParams, - \Self.unexpectedBetweenDiffParamsAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBetweenDiffParamsAndDiffParamsComma, + \Self.diffParamsComma, + \Self.unexpectedBetweenDiffParamsCommaAndWhereClause, + \Self.whereClause, + \Self.unexpectedAfterWhereClause, ]) } @@ -10579,127 +10869,200 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil + case 9: + return nil + case 10: + return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamsSyntax: CustomReflectable { +extension DifferentiableAttributeArgumentsSyntax: 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, + "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: - DifferentiabilityParamSyntax +// 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), + ]) + } + } -/// -/// A differentiability parameter: either the "self" identifier, a function -/// parameter name, or a function parameter index. -/// -public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParam else { return nil } + guard node.raw.kind == .differentiabilityParamsClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DifferentiabilityParamSyntax` 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 == .differentiabilityParam) + assert(data.raw.kind == .differentiabilityParamsClause) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, - parameter: TokenSyntax, - _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, + wrtLabel: TokenSyntax = .keyword(.wrt), + _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, + parameters: Parameters, + _ unexpectedAfterParameters: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeParameter, parameter, unexpectedBetweenParameterAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWrtLabel, wrtLabel, unexpectedBetweenWrtLabelAndColon, colon, unexpectedBetweenColonAndParameters, parameters, unexpectedAfterParameters))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeParameter?.raw, - parameter.raw, - unexpectedBetweenParameterAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBeforeWrtLabel?.raw, + wrtLabel.raw, + unexpectedBetweenWrtLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndParameters?.raw, + parameters.raw, + unexpectedAfterParameters?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParam, from: layout, arena: arena, + kind: SyntaxKind.differentiabilityParamsClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeParameter: UnexpectedNodesSyntax? { + public var unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var parameter: TokenSyntax { + /// The "wrt" label. + public var wrtLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + /// + /// The colon separating "wrt" and the parameter list. + /// + public var colon: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DifferentiabilityParamSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var parameters: Parameters { + get { + return Parameters(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterParameters: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DifferentiabilityParamsClauseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeParameter, - \Self.parameter, - \Self.unexpectedBetweenParameterAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeWrtLabel, + \Self.wrtLabel, + \Self.unexpectedBetweenWrtLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndParameters, + \Self.parameters, + \Self.unexpectedAfterParameters, ]) } @@ -10715,257 +11078,172 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return "parameters" + case 6: + return nil default: fatalError("Invalid index") } } } -extension DifferentiabilityParamSyntax: CustomReflectable { +extension DifferentiabilityParamsClauseSyntax: 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, + "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: - DerivativeRegistrationAttributeArgumentsSyntax +// MARK: - DifferentiabilityParamsSyntax -/// -/// The arguments for the '@derivative(of:)' and '@transpose(of:)' -/// attributes: the 'of:' label, the original declaration name, and an -/// optional differentiability parameter list. -/// -public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +/// The differentiability parameters. +public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .derivativeRegistrationAttributeArguments else { return nil } + guard node.raw.kind == .differentiabilityParams else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DerivativeRegistrationAttributeArgumentsSyntax` 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 == .derivativeRegistrationAttributeArguments) + assert(data.raw.kind == .differentiabilityParams) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, - ofLabel: TokenSyntax = .keyword(.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, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamListSyntax, + _ unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeOfLabel, ofLabel, unexpectedBetweenOfLabelAndColon, colon, unexpectedBetweenColonAndOriginalDeclName, originalDeclName, unexpectedBetweenOriginalDeclNameAndPeriod, period, unexpectedBetweenPeriodAndAccessorKind, accessorKind, unexpectedBetweenAccessorKindAndComma, comma, unexpectedBetweenCommaAndDiffParams, diffParams, unexpectedAfterDiffParams))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndDiffParams, diffParams, unexpectedBetweenDiffParamsAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeOfLabel?.raw, - ofLabel.raw, - unexpectedBetweenOfLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndOriginalDeclName?.raw, - originalDeclName.raw, - unexpectedBetweenOriginalDeclNameAndPeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndAccessorKind?.raw, - accessorKind?.raw, - unexpectedBetweenAccessorKindAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndDiffParams?.raw, - diffParams?.raw, - unexpectedAfterDiffParams?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndDiffParams?.raw, + diffParams.raw, + unexpectedBetweenDiffParamsAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.derivativeRegistrationAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.differentiabilityParams, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeOfLabel: UnexpectedNodesSyntax? { - get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The "of" label. - public var ofLabel: TokenSyntax { - get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? { - get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// The colon separating the "of" label and the original - /// declaration name. - /// - public var colon: TokenSyntax { - get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - /// The referenced original declaration name. - public var originalDeclName: QualifiedDeclNameSyntax { - get { - return QualifiedDeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// The period separating the original declaration name and the - /// accessor name. - /// - public var period: TokenSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? { + public var leftParen: TokenSyntax { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - /// The accessor name. - public var accessorKind: TokenSyntax? { + public var unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? { get { - return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? { + /// The parameters for differentiation. + public var diffParams: DifferentiabilityParamListSyntax { get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return DifferentiabilityParamListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var comma: TokenSyntax? { - get { - return data.child(at: 11, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) + /// Adds the provided `DifferentiabilityParam` to the node's `diffParams` + /// collection. + /// - param element: The new `DifferentiabilityParam` to add to the node's + /// `diffParams` collection. + /// - returns: A copy of the receiver with the provided `DifferentiabilityParam` + /// appended to its `diffParams` collection. + public func addDifferentiabilityParam(_ element: DifferentiabilityParamSyntax) -> DifferentiabilityParamsSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return DifferentiabilityParamsSyntax(newData) } - public var unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? { + public var unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var diffParams: DifferentiabilityParamsClauseSyntax? { + public var rightParen: TokenSyntax { get { - return data.child(at: 13, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDiffParams: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } 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.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndDiffParams, \Self.diffParams, - \Self.unexpectedAfterDiffParams, + \Self.unexpectedBetweenDiffParamsAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -10985,247 +11263,127 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy 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 DerivativeRegistrationAttributeArgumentsSyntax: CustomReflectable { +extension DifferentiabilityParamsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeOfLabel": unexpectedBeforeOfLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "ofLabel": Syntax(ofLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOfLabelAndColon": unexpectedBetweenOfLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndOriginalDeclName": unexpectedBetweenColonAndOriginalDeclName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "originalDeclName": Syntax(originalDeclName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOriginalDeclNameAndPeriod": unexpectedBetweenOriginalDeclNameAndPeriod.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenPeriodAndAccessorKind": unexpectedBetweenPeriodAndAccessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "accessorKind": accessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAccessorKindAndComma": unexpectedBetweenAccessorKindAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenCommaAndDiffParams": unexpectedBetweenCommaAndDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "diffParams": diffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterDiffParams": unexpectedAfterDiffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - QualifiedDeclNameSyntax +// MARK: - DifferentiabilityParamSyntax /// -/// An optionally qualified function declaration name (e.g. `+(_:_:)`, -/// `A.B.C.foo(_:_:)`). +/// A differentiability parameter: either the "self" identifier, a function +/// parameter name, or a function parameter index. /// -public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { +public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .qualifiedDeclName else { return nil } + guard node.raw.kind == .differentiabilityParam else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `QualifiedDeclNameSyntax` 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 == .qualifiedDeclName) + assert(data.raw.kind == .differentiabilityParam) 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, + _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, + parameter: TokenSyntax, + _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBaseType, baseType, unexpectedBetweenBaseTypeAndDot, dot, unexpectedBetweenDotAndName, name, unexpectedBetweenNameAndArguments, arguments, unexpectedAfterArguments))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeParameter, parameter, unexpectedBetweenParameterAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeBaseType?.raw, - baseType?.raw, - unexpectedBetweenBaseTypeAndDot?.raw, - dot?.raw, - unexpectedBetweenDotAndName?.raw, - name.raw, - unexpectedBetweenNameAndArguments?.raw, - arguments?.raw, - unexpectedAfterArguments?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.qualifiedDeclName, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - /// This initializer exists solely because Swift 5.6 does not support - /// `Optional.none` as a default value of a generic parameter. - /// The above initializer thus defaults to `nil` instead, but that means it - /// is not actually callable when either not passing the defaulted parameter, - /// or passing `nil`. - /// - /// Hack around that limitation using this initializer, which takes a - /// `Missing*` syntax node instead. `Missing*` is used over the base type as - /// the base type would allow implicit conversion from a string literal, - /// which the above initializer doesn't support. - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, - baseType: MissingTypeSyntax? = nil, - _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax? = nil, - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, - arguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeBaseType, - baseType: Optional.none, - unexpectedBetweenBaseTypeAndDot, - dot: dot, - unexpectedBetweenDotAndName, - name: name, - unexpectedBetweenNameAndArguments, - arguments: arguments, - unexpectedAfterArguments, - trailingTrivia: trailingTrivia - ) - } - - public var unexpectedBeforeBaseType: UnexpectedNodesSyntax? { - get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// The base type of the qualified name, optionally specified. - /// - public var baseType: TypeSyntax? { - get { - return data.child(at: 1, parent: Syntax(self)).map(TypeSyntax.init) - } - set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? { - get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - public var dot: TokenSyntax? { - get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + unexpectedBeforeParameter?.raw, + parameter.raw, + unexpectedBetweenParameterAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.differentiabilityParam, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) } + self.init(data) } - public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? { + public var unexpectedBeforeParameter: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The base name of the referenced function. - /// - public var name: TokenSyntax { + public var parameter: TokenSyntax { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? { + public var unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - /// - /// The argument labels of the referenced function, optionally - /// specified. - /// - public var arguments: DeclNameArgumentsSyntax? { + public var trailingComma: TokenSyntax? { get { - return data.child(at: 7, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterArguments: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = QualifiedDeclNameSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = DifferentiabilityParamSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } 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.unexpectedBeforeParameter, + \Self.parameter, + \Self.unexpectedBetweenParameterAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -11234,337 +11392,264 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "base type" + return nil case 2: return nil case 3: return nil case 4: return nil - case 5: - return "base name" - case 6: - return nil - case 7: - return "arguments" - case 8: - return nil default: fatalError("Invalid index") } } } -extension QualifiedDeclNameSyntax: CustomReflectable { +extension DifferentiabilityParamSyntax: 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, + "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: - BackDeployAttributeSpecListSyntax +// MARK: - DerivativeRegistrationAttributeArgumentsSyntax /// -/// A collection of arguments for the `@_backDeploy` attribute +/// 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 BackDeployAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashable { +public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .backDeployAttributeSpecList else { return nil } + guard node.raw.kind == .derivativeRegistrationAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `BackDeployAttributeSpecListSyntax` 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 == .backDeployAttributeSpecList) + assert(data.raw.kind == .derivativeRegistrationAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, - beforeLabel: TokenSyntax = .keyword(.before), - _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, + ofLabel: TokenSyntax = .keyword(.of), + _ unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, - versionList: AvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? = nil, + originalDeclName: QualifiedDeclNameSyntax, + _ unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax? = nil, + _ unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? = nil, + accessorKind: TokenSyntax? = nil, + _ unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamsClauseSyntax? = nil, + _ unexpectedAfterDiffParams: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBeforeLabel, beforeLabel, unexpectedBetweenBeforeLabelAndColon, colon, unexpectedBetweenColonAndVersionList, versionList, unexpectedAfterVersionList))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeOfLabel, ofLabel, unexpectedBetweenOfLabelAndColon, colon, unexpectedBetweenColonAndOriginalDeclName, originalDeclName, unexpectedBetweenOriginalDeclNameAndPeriod, period, unexpectedBetweenPeriodAndAccessorKind, accessorKind, unexpectedBetweenAccessorKindAndComma, comma, unexpectedBetweenCommaAndDiffParams, diffParams, unexpectedAfterDiffParams))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeBeforeLabel?.raw, - beforeLabel.raw, - unexpectedBetweenBeforeLabelAndColon?.raw, + unexpectedBeforeOfLabel?.raw, + ofLabel.raw, + unexpectedBetweenOfLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndVersionList?.raw, - versionList.raw, - unexpectedAfterVersionList?.raw, + unexpectedBetweenColonAndOriginalDeclName?.raw, + originalDeclName.raw, + unexpectedBetweenOriginalDeclNameAndPeriod?.raw, + period?.raw, + unexpectedBetweenPeriodAndAccessorKind?.raw, + accessorKind?.raw, + unexpectedBetweenAccessorKindAndComma?.raw, + comma?.raw, + unexpectedBetweenCommaAndDiffParams?.raw, + diffParams?.raw, + unexpectedAfterDiffParams?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.backDeployAttributeSpecList, from: layout, arena: arena, + kind: SyntaxKind.derivativeRegistrationAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeOfLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The "before" label. - public var beforeLabel: TokenSyntax { + /// The "of" label. + public var ofLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } /// - /// The colon separating "before" and the parameter list. + /// The colon separating the "of" label and the original + /// declaration name. /// public var colon: TokenSyntax { get { return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// The list of OS versions in which the declaration became ABI - /// stable. - /// - public var versionList: AvailabilityVersionRestrictionListSyntax { - get { - return AvailabilityVersionRestrictionListSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - /// Adds the provided `Availability` to the node's `versionList` - /// collection. - /// - param element: The new `Availability` to add to the node's - /// `versionList` collection. - /// - returns: A copy of the receiver with the provided `Availability` - /// appended to its `versionList` collection. - public func addAvailability(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> BackDeployAttributeSpecListSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[5] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return BackDeployAttributeSpecListSyntax(newData) - } - - public var unexpectedAfterVersionList: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeBeforeLabel, - \Self.beforeLabel, - \Self.unexpectedBetweenBeforeLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndVersionList, - \Self.versionList, - \Self.unexpectedAfterVersionList, - ]) - } - - 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") + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } -} - -extension BackDeployAttributeSpecListSyntax: 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, - ]) - } -} -// MARK: - AvailabilityVersionRestrictionListEntrySyntax + /// The referenced original declaration name. + public var originalDeclName: QualifiedDeclNameSyntax { + get { + return QualifiedDeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } -/// -/// A single platform/version pair in an attribute, e.g. `iOS 10.1`. -/// -public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax + public var unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } - public init?(_ node: S) { - guard node.raw.kind == .availabilityVersionRestrictionListEntry else { return nil } - self._syntaxNode = node._syntaxNode + /// + /// The period separating the original declaration name and the + /// accessor name. + /// + public var period: TokenSyntax? { + get { + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } } - /// Creates a `AvailabilityVersionRestrictionListEntrySyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .availabilityVersionRestrictionListEntry) - self._syntaxNode = Syntax(data) + public var unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } } - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? = nil, - availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax, - _ unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAvailabilityVersionRestriction, availabilityVersionRestriction, unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAvailabilityVersionRestriction?.raw, - availabilityVersionRestriction.raw, - unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityVersionRestrictionListEntry, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) + /// The accessor name. + public var accessorKind: TokenSyntax? { + get { + return data.child(at: 9, parent: Syntax(self)).map(TokenSyntax.init) + } + set(value) { + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) } - self.init(data) } - public var unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? { + public var unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? { get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } - public var availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax { + public var comma: TokenSyntax? { get { - return AvailabilityVersionRestrictionSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 11, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 11, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 12, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 12, with: value?.raw, arena: SyntaxArena())) } } - /// - /// A trailing comma if the argument is followed by another - /// argument - /// - public var trailingComma: TokenSyntax? { + public var diffParams: DifferentiabilityParamsClauseSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 13, parent: Syntax(self)).map(DifferentiabilityParamsClauseSyntax.init) } set(value) { - self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 13, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterDiffParams: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 14, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DerivativeRegistrationAttributeArgumentsSyntax(data.replacingChild(at: 14, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAvailabilityVersionRestriction, - \Self.availabilityVersionRestriction, - \Self.unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBeforeOfLabel, + \Self.ofLabel, + \Self.unexpectedBetweenOfLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndOriginalDeclName, + \Self.originalDeclName, + \Self.unexpectedBetweenOriginalDeclNameAndPeriod, + \Self.period, + \Self.unexpectedBetweenPeriodAndAccessorKind, + \Self.accessorKind, + \Self.unexpectedBetweenAccessorKindAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndDiffParams, + \Self.diffParams, + \Self.unexpectedAfterDiffParams, ]) } @@ -11580,150 +11665,251 @@ public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, Syn 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 AvailabilityVersionRestrictionListEntrySyntax: CustomReflectable { +extension DerivativeRegistrationAttributeArgumentsSyntax: 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, + "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: - OpaqueReturnTypeOfAttributeArgumentsSyntax +// MARK: - QualifiedDeclNameSyntax /// -/// The arguments for the '@_opaqueReturnTypeOf()'. +/// An optionally qualified function declaration name (e.g. `+(_:_:)`, +/// `A.B.C.foo(_:_:)`). /// -public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { return nil } + guard node.raw.kind == .qualifiedDeclName else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OpaqueReturnTypeOfAttributeArgumentsSyntax` 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 == .opaqueReturnTypeOfAttributeArguments) + assert(data.raw.kind == .qualifiedDeclName) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, - mangledName: StringLiteralExprSyntax, - _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, - ordinal: TokenSyntax, - _ unexpectedAfterOrdinal: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, + baseType: B? = nil, + _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax? = nil, + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeMangledName, mangledName, unexpectedBetweenMangledNameAndComma, comma, unexpectedBetweenCommaAndOrdinal, ordinal, unexpectedAfterOrdinal))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBaseType, baseType, unexpectedBetweenBaseTypeAndDot, dot, unexpectedBetweenDotAndName, name, unexpectedBetweenNameAndArguments, arguments, unexpectedAfterArguments))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeMangledName?.raw, - mangledName.raw, - unexpectedBetweenMangledNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndOrdinal?.raw, - ordinal.raw, - unexpectedAfterOrdinal?.raw, + unexpectedBeforeBaseType?.raw, + baseType?.raw, + unexpectedBetweenBaseTypeAndDot?.raw, + dot?.raw, + unexpectedBetweenDotAndName?.raw, + name.raw, + unexpectedBetweenNameAndArguments?.raw, + arguments?.raw, + unexpectedAfterArguments?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.qualifiedDeclName, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeMangledName: 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 { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = QualifiedDeclNameSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The mangled name of a declaration. - public var mangledName: StringLiteralExprSyntax { + /// + /// The base type of the qualified name, optionally specified. + /// + public var baseType: TypeSyntax? { get { - return StringLiteralExprSyntax(data.child(at: 1, parent: Syntax(self))!) + return data.child(at: 1, parent: Syntax(self)).map(TypeSyntax.init) } set(value) { - self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = QualifiedDeclNameSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = QualifiedDeclNameSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var comma: TokenSyntax { + public var dot: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = QualifiedDeclNameSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? { + public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = QualifiedDeclNameSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - /// The ordinal corresponding to the 'some' keyword that introduced this opaque type. - public var ordinal: TokenSyntax { + /// + /// The base name of the referenced function. + /// + public var name: TokenSyntax { get { return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = QualifiedDeclNameSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterOrdinal: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = QualifiedDeclNameSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + /// + /// The argument labels of the referenced function, optionally + /// specified. + /// + public var arguments: DeclNameArgumentsSyntax? { + get { + return data.child(at: 7, parent: Syntax(self)).map(DeclNameArgumentsSyntax.init) + } + set(value) { + self = QualifiedDeclNameSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterArguments: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = QualifiedDeclNameSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeMangledName, - \Self.mangledName, - \Self.unexpectedBetweenMangledNameAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndOrdinal, - \Self.ordinal, - \Self.unexpectedAfterOrdinal, + \Self.unexpectedBeforeBaseType, + \Self.baseType, + \Self.unexpectedBetweenBaseTypeAndDot, + \Self.dot, + \Self.unexpectedBetweenDotAndName, + \Self.name, + \Self.unexpectedBetweenNameAndArguments, + \Self.arguments, + \Self.unexpectedAfterArguments, ]) } @@ -11732,7 +11918,7 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax case 0: return nil case 1: - return nil + return "base type" case 2: return nil case 3: @@ -11740,202 +11926,186 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax case 4: return nil case 5: - return nil + return "base name" case 6: return nil + case 7: + return "arguments" + case 8: + return nil default: fatalError("Invalid index") } } } -extension OpaqueReturnTypeOfAttributeArgumentsSyntax: CustomReflectable { +extension QualifiedDeclNameSyntax: 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, + "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: - ConventionAttributeArgumentsSyntax +// MARK: - BackDeployAttributeSpecListSyntax /// -/// The arguments for the '@convention(...)'. +/// A collection of arguments for the `@_backDeploy` attribute /// -public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct BackDeployAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionAttributeArguments else { return nil } + guard node.raw.kind == .backDeployAttributeSpecList else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConventionAttributeArgumentsSyntax` 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 == .conventionAttributeArguments) + assert(data.raw.kind == .backDeployAttributeSpecList) 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: StringLiteralExprSyntax? = nil, - _ unexpectedAfterCTypeString: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, + beforeLabel: TokenSyntax = .keyword(.before), + _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, + versionList: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeConventionLabel, conventionLabel, unexpectedBetweenConventionLabelAndComma, comma, unexpectedBetweenCommaAndCTypeLabel, cTypeLabel, unexpectedBetweenCTypeLabelAndColon, colon, unexpectedBetweenColonAndCTypeString, cTypeString, unexpectedAfterCTypeString))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBeforeLabel, beforeLabel, unexpectedBetweenBeforeLabelAndColon, colon, unexpectedBetweenColonAndVersionList, versionList, unexpectedAfterVersionList))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeConventionLabel?.raw, - conventionLabel.raw, - unexpectedBetweenConventionLabelAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndCTypeLabel?.raw, - cTypeLabel?.raw, - unexpectedBetweenCTypeLabelAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndCTypeString?.raw, - cTypeString?.raw, - unexpectedAfterCTypeString?.raw, + unexpectedBeforeBeforeLabel?.raw, + beforeLabel.raw, + unexpectedBetweenBeforeLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndVersionList?.raw, + versionList.raw, + unexpectedAfterVersionList?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.backDeployAttributeSpecList, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - /// The convention label. - public var conventionLabel: TokenSyntax { + /// The "before" label. + public var beforeLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var comma: TokenSyntax? { + /// + /// The colon separating "before" and the parameter list. + /// + public var colon: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var cTypeLabel: TokenSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public var colon: TokenSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) + self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? { + /// + /// The list of OS versions in which the declaration became ABI + /// stable. + /// + public var versionList: AvailabilityVersionRestrictionListSyntax { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return AvailabilityVersionRestrictionListSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var cTypeString: StringLiteralExprSyntax? { - get { - return data.child(at: 9, parent: Syntax(self)).map(StringLiteralExprSyntax.init) - } - set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) + /// Adds the provided `Availability` to the node's `versionList` + /// collection. + /// - param element: The new `Availability` to add to the node's + /// `versionList` collection. + /// - returns: A copy of the receiver with the provided `Availability` + /// appended to its `versionList` collection. + public func addAvailability(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> BackDeployAttributeSpecListSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return BackDeployAttributeSpecListSyntax(newData) } - public var unexpectedAfterCTypeString: UnexpectedNodesSyntax? { + public var unexpectedAfterVersionList: UnexpectedNodesSyntax? { get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = BackDeployAttributeSpecListSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeConventionLabel, - \Self.conventionLabel, - \Self.unexpectedBetweenConventionLabelAndComma, - \Self.comma, - \Self.unexpectedBetweenCommaAndCTypeLabel, - \Self.cTypeLabel, - \Self.unexpectedBetweenCTypeLabelAndColon, + \Self.unexpectedBeforeBeforeLabel, + \Self.beforeLabel, + \Self.unexpectedBetweenBeforeLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndCTypeString, - \Self.cTypeString, - \Self.unexpectedAfterCTypeString, + \Self.unexpectedBetweenColonAndVersionList, + \Self.versionList, + \Self.unexpectedAfterVersionList, ]) } @@ -11955,162 +12125,130 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable return nil case 6: return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension ConventionAttributeArgumentsSyntax: CustomReflectable { +extension BackDeployAttributeSpecListSyntax: 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, + "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: - ConventionWitnessMethodAttributeArgumentsSyntax +// MARK: - AvailabilityVersionRestrictionListEntrySyntax /// -/// The arguments for the '@convention(witness_method: ...)'. +/// A single platform/version pair in an attribute, e.g. `iOS 10.1`. /// -public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { return nil } + guard node.raw.kind == .availabilityVersionRestrictionListEntry else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConventionWitnessMethodAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AvailabilityVersionRestrictionListEntrySyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .conventionWitnessMethodAttributeArguments) + assert(data.raw.kind == .availabilityVersionRestrictionListEntry) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, - witnessMethodLabel: TokenSyntax = .keyword(.witness_method), - _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, - protocolName: TokenSyntax, - _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? = nil, + availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax, + _ unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWitnessMethodLabel, witnessMethodLabel, unexpectedBetweenWitnessMethodLabelAndColon, colon, unexpectedBetweenColonAndProtocolName, protocolName, unexpectedAfterProtocolName))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAvailabilityVersionRestriction, availabilityVersionRestriction, unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWitnessMethodLabel?.raw, - witnessMethodLabel.raw, - unexpectedBetweenWitnessMethodLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndProtocolName?.raw, - protocolName.raw, - unexpectedAfterProtocolName?.raw, + unexpectedBeforeAvailabilityVersionRestriction?.raw, + availabilityVersionRestriction.raw, + unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionWitnessMethodAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.availabilityVersionRestrictionListEntry, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var witnessMethodLabel: TokenSyntax { + public var availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return AvailabilityVersionRestrictionSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + /// + /// A trailing comma if the argument is followed by another + /// argument + /// + public var trailingComma: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var protocolName: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterProtocolName: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityVersionRestrictionListEntrySyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWitnessMethodLabel, - \Self.witnessMethodLabel, - \Self.unexpectedBetweenWitnessMethodLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndProtocolName, - \Self.protocolName, - \Self.unexpectedAfterProtocolName, + \Self.unexpectedBeforeAvailabilityVersionRestriction, + \Self.availabilityVersionRestriction, + \Self.unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -12126,154 +12264,150 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S return nil case 4: return nil - case 5: - return nil - case 6: - return nil default: fatalError("Invalid index") } } } -extension ConventionWitnessMethodAttributeArgumentsSyntax: CustomReflectable { +extension AvailabilityVersionRestrictionListEntrySyntax: 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, + "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: - ExposeAttributeArgumentsSyntax +// MARK: - OpaqueReturnTypeOfAttributeArgumentsSyntax /// -/// The arguments for the '@_expose' attribute +/// The arguments for the '@_opaqueReturnTypeOf()'. /// -public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .exposeAttributeArguments else { return nil } + guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ExposeAttributeArgumentsSyntax` 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 == .exposeAttributeArguments) + assert(data.raw.kind == .opaqueReturnTypeOfAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLanguage: UnexpectedNodesSyntax? = nil, - language: TokenSyntax, - _ unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? = nil, - cxxName: StringLiteralExprSyntax? = nil, - _ unexpectedAfterCxxName: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, + mangledName: StringLiteralExprSyntax, + _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, + ordinal: TokenSyntax, + _ unexpectedAfterOrdinal: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLanguage, language, unexpectedBetweenLanguageAndComma, comma, unexpectedBetweenCommaAndCxxName, cxxName, unexpectedAfterCxxName))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeMangledName, mangledName, unexpectedBetweenMangledNameAndComma, comma, unexpectedBetweenCommaAndOrdinal, ordinal, unexpectedAfterOrdinal))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLanguage?.raw, - language.raw, - unexpectedBetweenLanguageAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndCxxName?.raw, - cxxName?.raw, - unexpectedAfterCxxName?.raw, + unexpectedBeforeMangledName?.raw, + mangledName.raw, + unexpectedBetweenMangledNameAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndOrdinal?.raw, + ordinal.raw, + unexpectedAfterOrdinal?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.exposeAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLanguage: UnexpectedNodesSyntax? { + public var unexpectedBeforeMangledName: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var language: TokenSyntax { + /// The mangled name of a declaration. + public var mangledName: StringLiteralExprSyntax { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return StringLiteralExprSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var comma: TokenSyntax? { + public var comma: TokenSyntax { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var cxxName: StringLiteralExprSyntax? { + /// The ordinal corresponding to the 'some' keyword that introduced this opaque type. + public var ordinal: TokenSyntax { get { - return data.child(at: 5, parent: Syntax(self)).map(StringLiteralExprSyntax.init) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterCxxName: UnexpectedNodesSyntax? { + public var unexpectedAfterOrdinal: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = OpaqueReturnTypeOfAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLanguage, - \Self.language, - \Self.unexpectedBetweenLanguageAndComma, + \Self.unexpectedBeforeMangledName, + \Self.mangledName, + \Self.unexpectedBetweenMangledNameAndComma, \Self.comma, - \Self.unexpectedBetweenCommaAndCxxName, - \Self.cxxName, - \Self.unexpectedAfterCxxName, + \Self.unexpectedBetweenCommaAndOrdinal, + \Self.ordinal, + \Self.unexpectedAfterOrdinal, ]) } @@ -12299,211 +12433,193 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { } } -extension ExposeAttributeArgumentsSyntax: CustomReflectable { +extension OpaqueReturnTypeOfAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLanguage": unexpectedBeforeLanguage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "language": Syntax(language).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLanguageAndComma": unexpectedBetweenLanguageAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenCommaAndCxxName": unexpectedBetweenCommaAndCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "cxxName": cxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterCxxName": unexpectedAfterCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - OriginallyDefinedInArgumentsSyntax +// MARK: - ConventionAttributeArgumentsSyntax /// -/// The arguments for the '@_originallyDefinedIn' attribute +/// The arguments for the '@convention(...)'. /// -public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .originallyDefinedInArguments else { return nil } + guard node.raw.kind == .conventionAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OriginallyDefinedInArgumentsSyntax` 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 == .originallyDefinedInArguments) + assert(data.raw.kind == .conventionAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? = nil, - moduleLabel: TokenSyntax = .keyword(.module), - _ unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? = nil, - moduleName: StringLiteralExprSyntax, - _ unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? = nil, - platforms: AvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterPlatforms: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? = nil, + conventionLabel: TokenSyntax, + _ unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? = nil, + cTypeLabel: TokenSyntax? = nil, + _ unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? = nil, + cTypeString: StringLiteralExprSyntax? = nil, + _ unexpectedAfterCTypeString: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeModuleLabel, moduleLabel, unexpectedBetweenModuleLabelAndColon, colon, unexpectedBetweenColonAndModuleName, moduleName, unexpectedBetweenModuleNameAndComma, comma, unexpectedBetweenCommaAndPlatforms, platforms, unexpectedAfterPlatforms))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeConventionLabel, conventionLabel, unexpectedBetweenConventionLabelAndComma, comma, unexpectedBetweenCommaAndCTypeLabel, cTypeLabel, unexpectedBetweenCTypeLabelAndColon, colon, unexpectedBetweenColonAndCTypeString, cTypeString, unexpectedAfterCTypeString))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeModuleLabel?.raw, - moduleLabel.raw, - unexpectedBetweenModuleLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndModuleName?.raw, - moduleName.raw, - unexpectedBetweenModuleNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndPlatforms?.raw, - platforms.raw, - unexpectedAfterPlatforms?.raw, + unexpectedBeforeConventionLabel?.raw, + conventionLabel.raw, + unexpectedBetweenConventionLabelAndComma?.raw, + comma?.raw, + unexpectedBetweenCommaAndCTypeLabel?.raw, + cTypeLabel?.raw, + unexpectedBetweenCTypeLabelAndColon?.raw, + colon?.raw, + unexpectedBetweenColonAndCTypeString?.raw, + cTypeString?.raw, + unexpectedAfterCTypeString?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.originallyDefinedInArguments, from: layout, arena: arena, + kind: SyntaxKind.conventionAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var moduleLabel: TokenSyntax { + /// The convention label. + public var conventionLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var comma: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var moduleName: StringLiteralExprSyntax { + public var cTypeLabel: TokenSyntax? { get { - return StringLiteralExprSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var comma: TokenSyntax { + public var colon: TokenSyntax? { get { - return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? { get { return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } - public var platforms: AvailabilityVersionRestrictionListSyntax { + public var cTypeString: StringLiteralExprSyntax? { get { - return AvailabilityVersionRestrictionListSyntax(data.child(at: 9, parent: Syntax(self))!) + return data.child(at: 9, parent: Syntax(self)).map(StringLiteralExprSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) - } - } - - /// Adds the provided `Platform` to the node's `platforms` - /// collection. - /// - param element: The new `Platform` to add to the node's - /// `platforms` collection. - /// - returns: A copy of the receiver with the provided `Platform` - /// appended to its `platforms` collection. - public func addPlatform(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> OriginallyDefinedInArgumentsSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[9] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, - from: [element.raw], arena: arena) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 9, with: collection, arena: arena) - return OriginallyDefinedInArgumentsSyntax(newData) } - public var unexpectedAfterPlatforms: UnexpectedNodesSyntax? { + public var unexpectedAfterCTypeString: UnexpectedNodesSyntax? { get { return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) + self = ConventionAttributeArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeModuleLabel, - \Self.moduleLabel, - \Self.unexpectedBetweenModuleLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndModuleName, - \Self.moduleName, - \Self.unexpectedBetweenModuleNameAndComma, + \Self.unexpectedBeforeConventionLabel, + \Self.conventionLabel, + \Self.unexpectedBetweenConventionLabelAndComma, \Self.comma, - \Self.unexpectedBetweenCommaAndPlatforms, - \Self.platforms, - \Self.unexpectedAfterPlatforms, + \Self.unexpectedBetweenCommaAndCTypeLabel, + \Self.cTypeLabel, + \Self.unexpectedBetweenCTypeLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndCTypeString, + \Self.cTypeString, + \Self.unexpectedAfterCTypeString, ]) } @@ -12537,100 +12653,100 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } -extension OriginallyDefinedInArgumentsSyntax: CustomReflectable { +extension ConventionAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeModuleLabel": unexpectedBeforeModuleLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "moduleLabel": Syntax(moduleLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenModuleLabelAndColon": unexpectedBetweenModuleLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndModuleName": unexpectedBetweenColonAndModuleName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "moduleName": Syntax(moduleName).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenModuleNameAndComma": unexpectedBetweenModuleNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCommaAndPlatforms": unexpectedBetweenCommaAndPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "platforms": Syntax(platforms).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPlatforms": unexpectedAfterPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - UnderscorePrivateAttributeArgumentsSyntax +// MARK: - ConventionWitnessMethodAttributeArgumentsSyntax /// -/// The arguments for the '@_private' attribute +/// The arguments for the '@convention(witness_method: ...)'. /// -public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .underscorePrivateAttributeArguments else { return nil } + guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `UnderscorePrivateAttributeArgumentsSyntax` 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 == .underscorePrivateAttributeArguments) + assert(data.raw.kind == .conventionWitnessMethodAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? = nil, - sourceFileLabel: TokenSyntax = .keyword(.sourceFile), - _ unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, + witnessMethodLabel: TokenSyntax = .keyword(.witness_method), + _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? = nil, - filename: StringLiteralExprSyntax, - _ unexpectedAfterFilename: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, + protocolName: TokenSyntax, + _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSourceFileLabel, sourceFileLabel, unexpectedBetweenSourceFileLabelAndColon, colon, unexpectedBetweenColonAndFilename, filename, unexpectedAfterFilename))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWitnessMethodLabel, witnessMethodLabel, unexpectedBetweenWitnessMethodLabelAndColon, colon, unexpectedBetweenColonAndProtocolName, protocolName, unexpectedAfterProtocolName))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeSourceFileLabel?.raw, - sourceFileLabel.raw, - unexpectedBetweenSourceFileLabelAndColon?.raw, + unexpectedBeforeWitnessMethodLabel?.raw, + witnessMethodLabel.raw, + unexpectedBetweenWitnessMethodLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndFilename?.raw, - filename.raw, - unexpectedAfterFilename?.raw, + unexpectedBetweenColonAndProtocolName?.raw, + protocolName.raw, + unexpectedAfterProtocolName?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.underscorePrivateAttributeArguments, from: layout, arena: arena, + kind: SyntaxKind.conventionWitnessMethodAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var sourceFileLabel: TokenSyntax { + public var witnessMethodLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } @@ -12639,46 +12755,46 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var filename: StringLiteralExprSyntax { + public var protocolName: TokenSyntax { get { - return StringLiteralExprSyntax(data.child(at: 5, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterFilename: UnexpectedNodesSyntax? { + public var unexpectedAfterProtocolName: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ConventionWitnessMethodAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeSourceFileLabel, - \Self.sourceFileLabel, - \Self.unexpectedBetweenSourceFileLabelAndColon, + \Self.unexpectedBeforeWitnessMethodLabel, + \Self.witnessMethodLabel, + \Self.unexpectedBetweenWitnessMethodLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndFilename, - \Self.filename, - \Self.unexpectedAfterFilename, + \Self.unexpectedBetweenColonAndProtocolName, + \Self.protocolName, + \Self.unexpectedAfterProtocolName, ]) } @@ -12704,144 +12820,144 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH } } -extension UnderscorePrivateAttributeArgumentsSyntax: CustomReflectable { +extension ConventionWitnessMethodAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeSourceFileLabel": unexpectedBeforeSourceFileLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "sourceFileLabel": Syntax(sourceFileLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenSourceFileLabelAndColon": unexpectedBetweenSourceFileLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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), - "unexpectedBetweenColonAndFilename": unexpectedBetweenColonAndFilename.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "filename": Syntax(filename).asProtocol(SyntaxProtocol.self), - "unexpectedAfterFilename": unexpectedAfterFilename.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - DynamicReplacementArgumentsSyntax +// MARK: - ExposeAttributeArgumentsSyntax /// -/// The arguments for the '@_dynamicReplacement' attribute +/// The arguments for the '@_expose' attribute /// -public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dynamicReplacementArguments else { return nil } + guard node.raw.kind == .exposeAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DynamicReplacementArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ExposeAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .dynamicReplacementArguments) + assert(data.raw.kind == .exposeAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, - forLabel: TokenSyntax = .keyword(.for), - _ unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, - declname: DeclNameSyntax, - _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLanguage: UnexpectedNodesSyntax? = nil, + language: TokenSyntax, + _ unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? = nil, + cxxName: StringLiteralExprSyntax? = nil, + _ unexpectedAfterCxxName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeForLabel, forLabel, unexpectedBetweenForLabelAndColon, colon, unexpectedBetweenColonAndDeclname, declname, unexpectedAfterDeclname))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLanguage, language, unexpectedBetweenLanguageAndComma, comma, unexpectedBetweenCommaAndCxxName, cxxName, unexpectedAfterCxxName))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeForLabel?.raw, - forLabel.raw, - unexpectedBetweenForLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndDeclname?.raw, - declname.raw, - unexpectedAfterDeclname?.raw, + unexpectedBeforeLanguage?.raw, + language.raw, + unexpectedBetweenLanguageAndComma?.raw, + comma?.raw, + unexpectedBetweenCommaAndCxxName?.raw, + cxxName?.raw, + unexpectedAfterCxxName?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dynamicReplacementArguments, from: layout, arena: arena, + kind: SyntaxKind.exposeAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeForLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeLanguage: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var forLabel: TokenSyntax { + public var language: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var comma: TokenSyntax? { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { + public var unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var declname: DeclNameSyntax { + public var cxxName: StringLiteralExprSyntax? { get { - return DeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) + return data.child(at: 5, parent: Syntax(self)).map(StringLiteralExprSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterDeclname: UnexpectedNodesSyntax? { + public var unexpectedAfterCxxName: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = ExposeAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeForLabel, - \Self.forLabel, - \Self.unexpectedBetweenForLabelAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndDeclname, - \Self.declname, - \Self.unexpectedAfterDeclname, + \Self.unexpectedBeforeLanguage, + \Self.language, + \Self.unexpectedBetweenLanguageAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndCxxName, + \Self.cxxName, + \Self.unexpectedAfterCxxName, ]) } @@ -12867,96 +12983,104 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable } } -extension DynamicReplacementArgumentsSyntax: CustomReflectable { +extension ExposeAttributeArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeForLabel": unexpectedBeforeForLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "forLabel": Syntax(forLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenForLabelAndColon": unexpectedBetweenForLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndDeclname": unexpectedBetweenColonAndDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "declname": Syntax(declname).asProtocol(SyntaxProtocol.self), - "unexpectedAfterDeclname": unexpectedAfterDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLanguage": unexpectedBeforeLanguage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "language": Syntax(language).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLanguageAndComma": unexpectedBetweenLanguageAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenCommaAndCxxName": unexpectedBetweenCommaAndCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "cxxName": cxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterCxxName": unexpectedAfterCxxName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - UnavailableFromAsyncArgumentsSyntax +// MARK: - OriginallyDefinedInArgumentsSyntax /// -/// The arguments for the '@_unavailableFromAsync' attribute +/// The arguments for the '@_originallyDefinedIn' attribute /// -public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashable { +public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unavailableFromAsyncArguments else { return nil } + guard node.raw.kind == .originallyDefinedInArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `UnavailableFromAsyncArgumentsSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `OriginallyDefinedInArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .unavailableFromAsyncArguments) + assert(data.raw.kind == .originallyDefinedInArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? = nil, - messageLabel: TokenSyntax = .keyword(.message), - _ unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? = nil, + moduleLabel: TokenSyntax = .keyword(.module), + _ unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? = nil, - message: StringLiteralExprSyntax, - _ unexpectedAfterMessage: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? = nil, + moduleName: StringLiteralExprSyntax, + _ unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? = nil, + platforms: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterPlatforms: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeMessageLabel, messageLabel, unexpectedBetweenMessageLabelAndColon, colon, unexpectedBetweenColonAndMessage, message, unexpectedAfterMessage))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeModuleLabel, moduleLabel, unexpectedBetweenModuleLabelAndColon, colon, unexpectedBetweenColonAndModuleName, moduleName, unexpectedBetweenModuleNameAndComma, comma, unexpectedBetweenCommaAndPlatforms, platforms, unexpectedAfterPlatforms))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeMessageLabel?.raw, - messageLabel.raw, - unexpectedBetweenMessageLabelAndColon?.raw, + unexpectedBeforeModuleLabel?.raw, + moduleLabel.raw, + unexpectedBetweenModuleLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndMessage?.raw, - message.raw, - unexpectedAfterMessage?.raw, + unexpectedBetweenColonAndModuleName?.raw, + moduleName.raw, + unexpectedBetweenModuleNameAndComma?.raw, + comma.raw, + unexpectedBetweenCommaAndPlatforms?.raw, + platforms.raw, + unexpectedAfterPlatforms?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unavailableFromAsyncArguments, from: layout, arena: arena, + kind: SyntaxKind.originallyDefinedInArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var messageLabel: TokenSyntax { + public var moduleLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } @@ -12965,46 +13089,105 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var message: StringLiteralExprSyntax { + public var moduleName: StringLiteralExprSyntax { get { return StringLiteralExprSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var comma: TokenSyntax { + get { + return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) + } + set(value) { + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + } + } + + public var platforms: AvailabilityVersionRestrictionListSyntax { + get { + return AvailabilityVersionRestrictionListSyntax(data.child(at: 9, parent: Syntax(self))!) + } + set(value) { + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) + } + } + + /// Adds the provided `Platform` to the node's `platforms` + /// collection. + /// - param element: The new `Platform` to add to the node's + /// `platforms` collection. + /// - returns: A copy of the receiver with the provided `Platform` + /// appended to its `platforms` collection. + public func addPlatform(_ element: AvailabilityVersionRestrictionListEntrySyntax) -> OriginallyDefinedInArgumentsSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[9] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 9, with: collection, arena: arena) + return OriginallyDefinedInArgumentsSyntax(newData) } - public var unexpectedAfterMessage: UnexpectedNodesSyntax? { + public var unexpectedAfterPlatforms: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = OriginallyDefinedInArgumentsSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeMessageLabel, - \Self.messageLabel, - \Self.unexpectedBetweenMessageLabelAndColon, + \Self.unexpectedBeforeModuleLabel, + \Self.moduleLabel, + \Self.unexpectedBetweenModuleLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndMessage, - \Self.message, - \Self.unexpectedAfterMessage, + \Self.unexpectedBetweenColonAndModuleName, + \Self.moduleName, + \Self.unexpectedBetweenModuleNameAndComma, + \Self.comma, + \Self.unexpectedBetweenCommaAndPlatforms, + \Self.platforms, + \Self.unexpectedAfterPlatforms, ]) } @@ -13024,139 +13207,114 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl 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 UnavailableFromAsyncArgumentsSyntax: CustomReflectable { +extension OriginallyDefinedInArgumentsSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeMessageLabel": unexpectedBeforeMessageLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "messageLabel": Syntax(messageLabel).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenMessageLabelAndColon": unexpectedBetweenMessageLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeModuleLabel": unexpectedBeforeModuleLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "moduleLabel": Syntax(moduleLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenModuleLabelAndColon": unexpectedBetweenModuleLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonAndMessage": unexpectedBetweenColonAndMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "message": Syntax(message).asProtocol(SyntaxProtocol.self), - "unexpectedAfterMessage": unexpectedAfterMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenColonAndModuleName": unexpectedBetweenColonAndModuleName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "moduleName": Syntax(moduleName).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenModuleNameAndComma": unexpectedBetweenModuleNameAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "comma": Syntax(comma).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCommaAndPlatforms": unexpectedBetweenCommaAndPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "platforms": Syntax(platforms).asProtocol(SyntaxProtocol.self), + "unexpectedAfterPlatforms": unexpectedAfterPlatforms.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DocumentationAttributeArgumentSyntax - -public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable { - public enum Value: SyntaxChildChoices { - case `token`(TokenSyntax) - case `string`(StringLiteralExprSyntax) - public var _syntaxNode: Syntax { - switch self { - case .token(let node): return node._syntaxNode - case .string(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: TokenSyntax) { - self = .token(node) - } - public init(_ node: StringLiteralExprSyntax) { - self = .string(node) - } - public init?(_ node: S) { - if let node = node.as(TokenSyntax.self) { - self = .token(node) - return - } - if let node = node.as(StringLiteralExprSyntax.self) { - self = .string(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(TokenSyntax.self), - .node(StringLiteralExprSyntax.self), - ]) - } - } +// MARK: - UnderscorePrivateAttributeArgumentsSyntax +/// +/// The arguments for the '@_private' attribute +/// +public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .documentationAttributeArgument else { return nil } + guard node.raw.kind == .underscorePrivateAttributeArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DocumentationAttributeArgumentSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnderscorePrivateAttributeArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .documentationAttributeArgument) + assert(data.raw.kind == .underscorePrivateAttributeArguments) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? = nil, + sourceFileLabel: TokenSyntax = .keyword(.sourceFile), + _ unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: Value, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? = nil, + filename: StringLiteralExprSyntax, + _ unexpectedAfterFilename: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSourceFileLabel, sourceFileLabel, unexpectedBetweenSourceFileLabelAndColon, colon, unexpectedBetweenColonAndFilename, filename, unexpectedAfterFilename))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, + unexpectedBeforeSourceFileLabel?.raw, + sourceFileLabel.raw, + unexpectedBetweenSourceFileLabelAndColon?.raw, colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBetweenColonAndFilename?.raw, + filename.raw, + unexpectedAfterFilename?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.documentationAttributeArgument, from: layout, arena: arena, + kind: SyntaxKind.underscorePrivateAttributeArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { + public var unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var label: TokenSyntax { + public var sourceFileLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } @@ -13165,69 +13323,46 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var value: Value { + public var filename: StringLiteralExprSyntax { get { - return Value(data.child(at: 5, parent: Syntax(self))!) + return StringLiteralExprSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterFilename: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - /// - /// A trailing comma if this argument is followed by another one - /// - public var trailingComma: TokenSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = UnderscorePrivateAttributeArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndColon, + \Self.unexpectedBeforeSourceFileLabel, + \Self.sourceFileLabel, + \Self.unexpectedBetweenSourceFileLabelAndColon, \Self.colon, - \Self.unexpectedBetweenColonAndValue, - \Self.value, - \Self.unexpectedBetweenValueAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBetweenColonAndFilename, + \Self.filename, + \Self.unexpectedAfterFilename, ]) } @@ -13236,7 +13371,7 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab case 0: return nil case 1: - return "label" + return nil case 2: return nil case 3: @@ -13247,129 +13382,150 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab return nil case 6: return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension DocumentationAttributeArgumentSyntax: CustomReflectable { +extension UnderscorePrivateAttributeArgumentsSyntax: 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, + "unexpectedBeforeSourceFileLabel": unexpectedBeforeSourceFileLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "sourceFileLabel": Syntax(sourceFileLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenSourceFileLabelAndColon": unexpectedBetweenSourceFileLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "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, + "unexpectedBetweenColonAndFilename": unexpectedBetweenColonAndFilename.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "filename": Syntax(filename).asProtocol(SyntaxProtocol.self), + "unexpectedAfterFilename": unexpectedAfterFilename.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - WhereClauseSyntax +// MARK: - DynamicReplacementArgumentsSyntax -public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the '@_dynamicReplacement' attribute +/// +public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .whereClause else { return nil } + guard node.raw.kind == .dynamicReplacementArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `WhereClauseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DynamicReplacementArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .whereClause) + assert(data.raw.kind == .dynamicReplacementArguments) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, - whereKeyword: TokenSyntax = .keyword(.where), - _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, - guardResult: G, - _ unexpectedAfterGuardResult: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, + forLabel: TokenSyntax = .keyword(.for), + _ unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, + declname: DeclNameSyntax, + _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWhereKeyword, whereKeyword, unexpectedBetweenWhereKeywordAndGuardResult, guardResult, unexpectedAfterGuardResult))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeForLabel, forLabel, unexpectedBetweenForLabelAndColon, colon, unexpectedBetweenColonAndDeclname, declname, unexpectedAfterDeclname))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeWhereKeyword?.raw, - whereKeyword.raw, - unexpectedBetweenWhereKeywordAndGuardResult?.raw, - guardResult.raw, - unexpectedAfterGuardResult?.raw, + unexpectedBeforeForLabel?.raw, + forLabel.raw, + unexpectedBetweenForLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndDeclname?.raw, + declname.raw, + unexpectedAfterDeclname?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.whereClause, from: layout, arena: arena, + kind: SyntaxKind.dynamicReplacementArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeForLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = WhereClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var whereKeyword: TokenSyntax { + public var forLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = WhereClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? { + public var unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = WhereClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var guardResult: ExprSyntax { + public var colon: TokenSyntax { get { - return ExprSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = WhereClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterGuardResult: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = WhereClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var declname: DeclNameSyntax { + get { + return DeclNameSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterDeclname: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DynamicReplacementArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeWhereKeyword, - \Self.whereKeyword, - \Self.unexpectedBetweenWhereKeywordAndGuardResult, - \Self.guardResult, - \Self.unexpectedAfterGuardResult, + \Self.unexpectedBeforeForLabel, + \Self.forLabel, + \Self.unexpectedBetweenForLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndDeclname, + \Self.declname, + \Self.unexpectedAfterDeclname, ]) } @@ -13385,164 +13541,154 @@ 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 DynamicReplacementArgumentsSyntax: 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, + "unexpectedBeforeForLabel": unexpectedBeforeForLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "forLabel": Syntax(forLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenForLabelAndColon": unexpectedBetweenForLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndDeclname": unexpectedBetweenColonAndDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "declname": Syntax(declname).asProtocol(SyntaxProtocol.self), + "unexpectedAfterDeclname": unexpectedAfterDeclname.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - YieldListSyntax +// MARK: - UnavailableFromAsyncArgumentsSyntax -public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { +/// +/// The arguments for the '@_unavailableFromAsync' attribute +/// +public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .yieldList else { return nil } + guard node.raw.kind == .unavailableFromAsyncArguments else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `YieldListSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnavailableFromAsyncArgumentsSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .yieldList) + assert(data.raw.kind == .unavailableFromAsyncArguments) 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, + _ unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? = nil, + messageLabel: TokenSyntax = .keyword(.message), + _ unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? = nil, + message: StringLiteralExprSyntax, + _ unexpectedAfterMessage: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndElementList, elementList, unexpectedBetweenElementListAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeMessageLabel, messageLabel, unexpectedBetweenMessageLabelAndColon, colon, unexpectedBetweenColonAndMessage, message, unexpectedAfterMessage))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElementList?.raw, - elementList.raw, - unexpectedBetweenElementListAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeMessageLabel?.raw, + messageLabel.raw, + unexpectedBetweenMessageLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndMessage?.raw, + message.raw, + unexpectedAfterMessage?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldList, from: layout, arena: arena, + kind: SyntaxKind.unavailableFromAsyncArguments, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = YieldListSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { + public var messageLabel: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = YieldListSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? { + public var unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = YieldListSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var elementList: YieldExprListSyntax { + public var colon: TokenSyntax { get { - return YieldExprListSyntax(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = YieldListSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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 = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return YieldListSyntax(newData) } - public var unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = YieldListSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var rightParen: TokenSyntax { + public var message: StringLiteralExprSyntax { get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + return StringLiteralExprSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = YieldListSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterMessage: UnexpectedNodesSyntax? { get { return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = YieldListSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = UnavailableFromAsyncArgumentsSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndElementList, - \Self.elementList, - \Self.unexpectedBetweenElementListAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeMessageLabel, + \Self.messageLabel, + \Self.unexpectedBetweenMessageLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndMessage, + \Self.message, + \Self.unexpectedAfterMessage, ]) } @@ -13568,64 +13714,46 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { } } -extension YieldListSyntax: CustomReflectable { +extension UnavailableFromAsyncArgumentsSyntax: 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, + "unexpectedBeforeMessageLabel": unexpectedBeforeMessageLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "messageLabel": Syntax(messageLabel).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenMessageLabelAndColon": unexpectedBetweenMessageLabelAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonAndMessage": unexpectedBetweenColonAndMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "message": Syntax(message).asProtocol(SyntaxProtocol.self), + "unexpectedAfterMessage": unexpectedAfterMessage.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ConditionElementSyntax +// MARK: - DocumentationAttributeArgumentSyntax -public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { - public enum Condition: SyntaxChildChoices { - case `expression`(ExprSyntax) - case `availability`(AvailabilityConditionSyntax) - case `matchingPattern`(MatchingPatternConditionSyntax) - case `optionalBinding`(OptionalBindingConditionSyntax) +public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashable { + public enum Value: SyntaxChildChoices { + case `token`(TokenSyntax) + case `string`(StringLiteralExprSyntax) public var _syntaxNode: Syntax { switch self { - case .expression(let node): return node._syntaxNode - case .availability(let node): return node._syntaxNode - case .matchingPattern(let node): return node._syntaxNode - case .optionalBinding(let node): return node._syntaxNode + case .token(let node): return node._syntaxNode + case .string(let node): return node._syntaxNode } } init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: Node) { - self = .expression(ExprSyntax(node)) - } - public init(_ node: AvailabilityConditionSyntax) { - self = .availability(node) - } - public init(_ node: MatchingPatternConditionSyntax) { - self = .matchingPattern(node) + public init(_ node: TokenSyntax) { + self = .token(node) } - public init(_ node: OptionalBindingConditionSyntax) { - self = .optionalBinding(node) + public init(_ node: StringLiteralExprSyntax) { + self = .string(node) } public init?(_ node: S) { - if let node = node.as(ExprSyntax.self) { - self = .expression(node) - return - } - if let node = node.as(AvailabilityConditionSyntax.self) { - self = .availability(node) - return - } - if let node = node.as(MatchingPatternConditionSyntax.self) { - self = .matchingPattern(node) + if let node = node.as(TokenSyntax.self) { + self = .token(node) return } - if let node = node.as(OptionalBindingConditionSyntax.self) { - self = .optionalBinding(node) + if let node = node.as(StringLiteralExprSyntax.self) { + self = .string(node) return } return nil @@ -13633,10 +13761,8 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { public static var structure: SyntaxNodeStructure { return .choices([ - .node(ExprSyntax.self), - .node(AvailabilityConditionSyntax.self), - .node(MatchingPatternConditionSyntax.self), - .node(OptionalBindingConditionSyntax.self), + .node(TokenSyntax.self), + .node(StringLiteralExprSyntax.self), ]) } } @@ -13644,95 +13770,146 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conditionElement else { return nil } + guard node.raw.kind == .documentationAttributeArgument else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ConditionElementSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DocumentationAttributeArgumentSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .conditionElement) + assert(data.raw.kind == .documentationAttributeArgument) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, - condition: Condition, - _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: Value, + _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax? = nil, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCondition, condition, unexpectedBetweenConditionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLabel, label, unexpectedBetweenLabelAndColon, colon, unexpectedBetweenColonAndValue, value, unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeCondition?.raw, - condition.raw, - unexpectedBetweenConditionAndTrailingComma?.raw, + unexpectedBeforeLabel?.raw, + label.raw, + unexpectedBetweenLabelAndColon?.raw, + colon.raw, + unexpectedBetweenColonAndValue?.raw, + value.raw, + unexpectedBetweenValueAndTrailingComma?.raw, trailingComma?.raw, unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conditionElement, from: layout, arena: arena, + kind: SyntaxKind.documentationAttributeArgument, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { + public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var condition: Condition { + public var label: TokenSyntax { get { - return Condition(data.child(at: 1, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public var colon: TokenSyntax { + get { + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + } + set(value) { + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? { + get { + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var value: Value { + get { + return Value(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } + /// + /// A trailing comma if this argument is followed by another one + /// public var trailingComma: TokenSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = ConditionElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = DocumentationAttributeArgumentSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeCondition, - \Self.condition, - \Self.unexpectedBetweenConditionAndTrailingComma, + \Self.unexpectedBeforeLabel, + \Self.label, + \Self.unexpectedBetweenLabelAndColon, + \Self.colon, + \Self.unexpectedBetweenColonAndValue, + \Self.value, + \Self.unexpectedBetweenValueAndTrailingComma, \Self.trailingComma, \Self.unexpectedAfterTrailingComma, ]) @@ -13743,195 +13920,140 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "label" case 2: return nil case 3: return nil case 4: return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension ConditionElementSyntax: CustomReflectable { +extension DocumentationAttributeArgumentSyntax: 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, + "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: - AvailabilityConditionSyntax +// MARK: - WhereClauseSyntax -public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { +public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityCondition else { return nil } + guard node.raw.kind == .whereClause else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AvailabilityConditionSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `WhereClauseSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .availabilityCondition) + assert(data.raw.kind == .whereClause) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? = nil, - availabilityKeyword: TokenSyntax, - _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, - availabilitySpec: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, + whereKeyword: TokenSyntax = .keyword(.where), + _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, + guardResult: G, + _ unexpectedAfterGuardResult: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAvailabilityKeyword, availabilityKeyword, unexpectedBetweenAvailabilityKeywordAndLeftParen, leftParen, unexpectedBetweenLeftParenAndAvailabilitySpec, availabilitySpec, unexpectedBetweenAvailabilitySpecAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWhereKeyword, whereKeyword, unexpectedBetweenWhereKeywordAndGuardResult, guardResult, unexpectedAfterGuardResult))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeAvailabilityKeyword?.raw, - availabilityKeyword.raw, - unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, - availabilitySpec.raw, - unexpectedBetweenAvailabilitySpecAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeWhereKeyword?.raw, + whereKeyword.raw, + unexpectedBetweenWhereKeywordAndGuardResult?.raw, + guardResult.raw, + unexpectedAfterGuardResult?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityCondition, from: layout, arena: arena, + kind: SyntaxKind.whereClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = WhereClauseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var availabilityKeyword: TokenSyntax { + public var whereKeyword: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = WhereClauseSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = WhereClauseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var leftParen: TokenSyntax { + public var guardResult: ExprSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return ExprSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = WhereClauseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? { + public var unexpectedAfterGuardResult: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var availabilitySpec: AvailabilitySpecListSyntax { - get { - return AvailabilitySpecListSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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) - } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return AvailabilityConditionSyntax(newData) - } - - public var unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public var rightParen: TokenSyntax { - get { - return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) - } - set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = AvailabilityConditionSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = WhereClauseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAvailabilityKeyword, - \Self.availabilityKeyword, - \Self.unexpectedBetweenAvailabilityKeywordAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, - \Self.availabilitySpec, - \Self.unexpectedBetweenAvailabilitySpecAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeWhereKeyword, + \Self.whereKeyword, + \Self.unexpectedBetweenWhereKeywordAndGuardResult, + \Self.guardResult, + \Self.unexpectedAfterGuardResult, ]) } @@ -13947,181 +14069,164 @@ public struct AvailabilityConditionSyntax: 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 AvailabilityConditionSyntax: CustomReflectable { +extension WhereClauseSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAvailabilityKeyword": unexpectedBeforeAvailabilityKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "availabilityKeyword": Syntax(availabilityKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAvailabilityKeywordAndLeftParen": unexpectedBetweenAvailabilityKeywordAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndAvailabilitySpec": unexpectedBetweenLeftParenAndAvailabilitySpec.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "availabilitySpec": Syntax(availabilitySpec).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAvailabilitySpecAndRightParen": unexpectedBetweenAvailabilitySpecAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "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: - MatchingPatternConditionSyntax +// MARK: - YieldListSyntax -public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { +public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .matchingPatternCondition else { return nil } + guard node.raw.kind == .yieldList else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `MatchingPatternConditionSyntax` 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 == .matchingPatternCondition) + assert(data.raw.kind == .yieldList) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .keyword(.case), - _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax, - _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, + elementList: YieldExprListSyntax, + _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLeftParen, leftParen, unexpectedBetweenLeftParenAndElementList, elementList, unexpectedBetweenElementListAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer.raw, - unexpectedAfterInitializer?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndElementList?.raw, + elementList.raw, + unexpectedBetweenElementListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.matchingPatternCondition, from: layout, arena: arena, + kind: SyntaxKind.yieldList, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = YieldListSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var caseKeyword: TokenSyntax { + public var leftParen: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = YieldListSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - public var pattern: PatternSyntax { - get { - return PatternSyntax(data.child(at: 3, parent: Syntax(self))!) - } - set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = YieldListSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + public var elementList: YieldExprListSyntax { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return YieldExprListSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = YieldListSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var typeAnnotation: TypeAnnotationSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(TypeAnnotationSyntax.init) - } - set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + /// Adds the provided `Element` to the node's `elementList` + /// collection. + /// - param element: The new `Element` to add to the node's + /// `elementList` collection. + /// - returns: A copy of the receiver with the provided `Element` + /// appended to its `elementList` collection. + public func addElement(_ element: YieldExprListElementSyntax) -> YieldListSyntax { + var collection: RawSyntax + let arena = SyntaxArena() + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.yieldExprList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return YieldListSyntax(newData) } - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + public var unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = YieldListSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var initializer: InitializerClauseSyntax { + public var rightParen: TokenSyntax { get { - return InitializerClauseSyntax(data.child(at: 7, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + self = YieldListSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = MatchingPatternConditionSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = YieldListSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } 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.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndElementList, + \Self.elementList, + \Self.unexpectedBetweenElementListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -14141,177 +14246,179 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension MatchingPatternConditionSyntax: CustomReflectable { +extension YieldListSyntax: 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, + "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: - OptionalBindingConditionSyntax +// MARK: - ConditionElementSyntax + +public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { + public enum Condition: SyntaxChildChoices { + case `expression`(ExprSyntax) + case `availability`(AvailabilityConditionSyntax) + case `matchingPattern`(MatchingPatternConditionSyntax) + case `optionalBinding`(OptionalBindingConditionSyntax) + public var _syntaxNode: Syntax { + switch self { + case .expression(let node): return node._syntaxNode + case .availability(let node): return node._syntaxNode + case .matchingPattern(let node): return node._syntaxNode + case .optionalBinding(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: Node) { + self = .expression(ExprSyntax(node)) + } + public init(_ node: AvailabilityConditionSyntax) { + self = .availability(node) + } + public init(_ node: MatchingPatternConditionSyntax) { + self = .matchingPattern(node) + } + public init(_ node: OptionalBindingConditionSyntax) { + self = .optionalBinding(node) + } + public init?(_ node: S) { + if let node = node.as(ExprSyntax.self) { + self = .expression(node) + return + } + if let node = node.as(AvailabilityConditionSyntax.self) { + self = .availability(node) + return + } + if let node = node.as(MatchingPatternConditionSyntax.self) { + self = .matchingPattern(node) + return + } + if let node = node.as(OptionalBindingConditionSyntax.self) { + self = .optionalBinding(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(ExprSyntax.self), + .node(AvailabilityConditionSyntax.self), + .node(MatchingPatternConditionSyntax.self), + .node(OptionalBindingConditionSyntax.self), + ]) + } + } -public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .optionalBindingCondition else { return nil } + guard node.raw.kind == .conditionElement else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `OptionalBindingConditionSyntax` 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 == .optionalBindingCondition) + assert(data.raw.kind == .conditionElement) 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, + _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, + condition: Condition, + _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLetOrVarKeyword, letOrVarKeyword, unexpectedBetweenLetOrVarKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCondition, condition, unexpectedBetweenConditionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLetOrVarKeyword?.raw, - letOrVarKeyword.raw, - unexpectedBetweenLetOrVarKeywordAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer?.raw, - unexpectedAfterInitializer?.raw, + unexpectedBeforeCondition?.raw, + condition.raw, + unexpectedBetweenConditionAndTrailingComma?.raw, + trailingComma?.raw, + unexpectedAfterTrailingComma?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.optionalBindingCondition, from: layout, arena: arena, + kind: SyntaxKind.conditionElement, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLetOrVarKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var letOrVarKeyword: TokenSyntax { + public var condition: Condition { get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + return Condition(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLetOrVarKeywordAndPattern: UnexpectedNodesSyntax? { + public var unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var pattern: PatternSyntax { + public var trailingComma: TokenSyntax? { get { - return PatternSyntax(data.child(at: 3, parent: Syntax(self))!) + return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init) } set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { + public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var typeAnnotation: TypeAnnotationSyntax? { - get { - return data.child(at: 5, parent: Syntax(self)).map(TypeAnnotationSyntax.init) - } - set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public var initializer: InitializerClauseSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(InitializerClauseSyntax.init) - } - set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = OptionalBindingConditionSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) + self = ConditionElementSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } 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.unexpectedBeforeCondition, + \Self.condition, + \Self.unexpectedBetweenConditionAndTrailingComma, + \Self.trailingComma, + \Self.unexpectedAfterTrailingComma, ]) } @@ -14327,212 +14434,188 @@ public struct OptionalBindingConditionSyntax: 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 OptionalBindingConditionSyntax: CustomReflectable { +extension ConditionElementSyntax: 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, + "unexpectedBeforeCondition": unexpectedBeforeCondition.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "condition": Syntax(condition).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenConditionAndTrailingComma": unexpectedBetweenConditionAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - SwitchCaseSyntax - -public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { - public enum Label: SyntaxChildChoices { - case `default`(SwitchDefaultLabelSyntax) - case `case`(SwitchCaseLabelSyntax) - public var _syntaxNode: Syntax { - switch self { - case .default(let node): return node._syntaxNode - case .case(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: SwitchDefaultLabelSyntax) { - self = .default(node) - } - public init(_ node: SwitchCaseLabelSyntax) { - self = .case(node) - } - public init?(_ node: S) { - if let node = node.as(SwitchDefaultLabelSyntax.self) { - self = .default(node) - return - } - if let node = node.as(SwitchCaseLabelSyntax.self) { - self = .case(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(SwitchDefaultLabelSyntax.self), - .node(SwitchCaseLabelSyntax.self), - ]) - } - } +// MARK: - AvailabilityConditionSyntax +public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchCase else { return nil } + guard node.raw.kind == .availabilityCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchCaseSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AvailabilityConditionSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .switchCase) + assert(data.raw.kind == .availabilityCondition) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, - unknownAttr: AttributeSyntax? = nil, - _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, - label: Label, - _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? = nil, + availabilityKeyword: TokenSyntax, + _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, + availabilitySpec: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeUnknownAttr, unknownAttr, unexpectedBetweenUnknownAttrAndLabel, label, unexpectedBetweenLabelAndStatements, statements, unexpectedAfterStatements))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAvailabilityKeyword, availabilityKeyword, unexpectedBetweenAvailabilityKeywordAndLeftParen, leftParen, unexpectedBetweenLeftParenAndAvailabilitySpec, availabilitySpec, unexpectedBetweenAvailabilitySpecAndRightParen, rightParen, unexpectedAfterRightParen))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeUnknownAttr?.raw, - unknownAttr?.raw, - unexpectedBetweenUnknownAttrAndLabel?.raw, - label.raw, - unexpectedBetweenLabelAndStatements?.raw, - statements.raw, - unexpectedAfterStatements?.raw, + unexpectedBeforeAvailabilityKeyword?.raw, + availabilityKeyword.raw, + unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndAvailabilitySpec?.raw, + availabilitySpec.raw, + unexpectedBetweenAvailabilitySpecAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchCase, from: layout, arena: arena, + kind: SyntaxKind.availabilityCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? { + public var unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SwitchCaseSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityConditionSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var unknownAttr: AttributeSyntax? { + public var availabilityKeyword: TokenSyntax { get { - return data.child(at: 1, parent: Syntax(self)).map(AttributeSyntax.init) + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = SwitchCaseSyntax(data.replacingChild(at: 1, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityConditionSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? { + public var unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SwitchCaseSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityConditionSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var label: Label { + public var leftParen: TokenSyntax { get { - return Label(data.child(at: 3, parent: Syntax(self))!) + return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = SwitchCaseSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = AvailabilityConditionSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SwitchCaseSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityConditionSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var statements: CodeBlockItemListSyntax { + public var availabilitySpec: AvailabilitySpecListSyntax { get { - return CodeBlockItemListSyntax(data.child(at: 5, parent: Syntax(self))!) + return AvailabilitySpecListSyntax(data.child(at: 5, parent: Syntax(self))!) } set(value) { - self = SwitchCaseSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + self = AvailabilityConditionSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) } } - /// Adds the provided `Statement` to the node's `statements` + /// Adds the provided `AvailabilityArgument` to the node's `availabilitySpec` /// collection. - /// - param element: The new `Statement` to add to the node's - /// `statements` collection. - /// - returns: A copy of the receiver with the provided `Statement` - /// appended to its `statements` collection. - public func addStatement(_ element: CodeBlockItemSyntax) -> SwitchCaseSyntax { + /// - param element: The new `AvailabilityArgument` to add to the node's + /// `availabilitySpec` collection. + /// - returns: A copy of the receiver with the provided `AvailabilityArgument` + /// appended to its `availabilitySpec` collection. + public func addAvailabilityArgument(_ element: AvailabilityArgumentSyntax) -> AvailabilityConditionSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, from: [element.raw], arena: arena) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return SwitchCaseSyntax(newData) + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return AvailabilityConditionSyntax(newData) + } + + public var unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AvailabilityConditionSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } } - public var unexpectedAfterStatements: UnexpectedNodesSyntax? { + public var rightParen: TokenSyntax { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return TokenSyntax(data.child(at: 7, parent: Syntax(self))!) } set(value) { - self = SwitchCaseSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = AvailabilityConditionSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = AvailabilityConditionSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeUnknownAttr, - \Self.unknownAttr, - \Self.unexpectedBetweenUnknownAttrAndLabel, - \Self.label, - \Self.unexpectedBetweenLabelAndStatements, - \Self.statements, - \Self.unexpectedAfterStatements, + \Self.unexpectedBeforeAvailabilityKeyword, + \Self.availabilityKeyword, + \Self.unexpectedBetweenAvailabilityKeywordAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndAvailabilitySpec, + \Self.availabilitySpec, + \Self.unexpectedBetweenAvailabilitySpecAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -14545,130 +14628,184 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "label" + return nil case 4: return nil case 5: return nil case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension SwitchCaseSyntax: CustomReflectable { +extension AvailabilityConditionSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeUnknownAttr": unexpectedBeforeUnknownAttr.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unknownAttr": unknownAttr.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenUnknownAttrAndLabel": unexpectedBetweenUnknownAttrAndLabel.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "label": Syntax(label).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLabelAndStatements": unexpectedBetweenLabelAndStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), - "unexpectedAfterStatements": unexpectedAfterStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeAvailabilityKeyword": unexpectedBeforeAvailabilityKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "availabilityKeyword": Syntax(availabilityKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAvailabilityKeywordAndLeftParen": unexpectedBetweenAvailabilityKeywordAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftParenAndAvailabilitySpec": unexpectedBetweenLeftParenAndAvailabilitySpec.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "availabilitySpec": Syntax(availabilitySpec).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAvailabilitySpecAndRightParen": unexpectedBetweenAvailabilitySpecAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - SwitchDefaultLabelSyntax +// MARK: - MatchingPatternConditionSyntax -public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { +public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchDefaultLabel else { return nil } + guard node.raw.kind == .matchingPatternCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SwitchDefaultLabelSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `MatchingPatternConditionSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .switchDefaultLabel) + assert(data.raw.kind == .matchingPatternCondition) self._syntaxNode = Syntax(data) } - public init( + public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, - defaultKeyword: TokenSyntax = .keyword(.default), - _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .keyword(.case), + _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax, + _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDefaultKeyword, defaultKeyword, unexpectedBetweenDefaultKeywordAndColon, colon, unexpectedAfterColon))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeDefaultKeyword?.raw, - defaultKeyword.raw, - unexpectedBetweenDefaultKeywordAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, + unexpectedBeforeCaseKeyword?.raw, + caseKeyword.raw, + unexpectedBetweenCaseKeywordAndPattern?.raw, + pattern.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer.raw, + unexpectedAfterInitializer?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchDefaultLabel, from: layout, arena: arena, + kind: SyntaxKind.matchingPatternCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? { + public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SwitchDefaultLabelSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = MatchingPatternConditionSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) } } - public var defaultKeyword: TokenSyntax { + public var caseKeyword: TokenSyntax { get { return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) } set(value) { - self = SwitchDefaultLabelSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = MatchingPatternConditionSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? { get { return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SwitchDefaultLabelSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = MatchingPatternConditionSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } - public var colon: TokenSyntax { + public var pattern: PatternSyntax { get { - return TokenSyntax(data.child(at: 3, parent: Syntax(self))!) + return PatternSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = SwitchDefaultLabelSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) + self = MatchingPatternConditionSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedAfterColon: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = SwitchDefaultLabelSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = MatchingPatternConditionSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + } + } + + public var typeAnnotation: TypeAnnotationSyntax? { + get { + return data.child(at: 5, parent: Syntax(self)).map(TypeAnnotationSyntax.init) + } + set(value) { + self = MatchingPatternConditionSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + } + } + + public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MatchingPatternConditionSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + + public var initializer: InitializerClauseSyntax { + get { + return InitializerClauseSyntax(data.child(at: 7, parent: Syntax(self))!) + } + set(value) { + self = MatchingPatternConditionSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { + get { + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MatchingPatternConditionSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeDefaultKeyword, - \Self.defaultKeyword, - \Self.unexpectedBetweenDefaultKeywordAndColon, - \Self.colon, - \Self.unexpectedAfterColon, + \Self.unexpectedBeforeCaseKeyword, + \Self.caseKeyword, + \Self.unexpectedBetweenCaseKeywordAndPattern, + \Self.pattern, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedAfterInitializer, ]) } @@ -14684,145 +14821,181 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension SwitchDefaultLabelSyntax: CustomReflectable { +extension MatchingPatternConditionSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeDefaultKeyword": unexpectedBeforeDefaultKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "defaultKeyword": Syntax(defaultKeyword).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDefaultKeywordAndColon": unexpectedBetweenDefaultKeywordAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), - "unexpectedAfterColon": unexpectedAfterColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeCaseKeyword": unexpectedBeforeCaseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "caseKeyword": Syntax(caseKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCaseKeywordAndPattern": unexpectedBetweenCaseKeywordAndPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "initializer": Syntax(initializer).asProtocol(SyntaxProtocol.self), + "unexpectedAfterInitializer": unexpectedAfterInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - CaseItemSyntax +// MARK: - OptionalBindingConditionSyntax -public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { +public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .caseItem else { return nil } + guard node.raw.kind == .optionalBindingCondition else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `CaseItemSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `OptionalBindingConditionSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .caseItem) + assert(data.raw.kind == .optionalBindingCondition) self._syntaxNode = Syntax(data) } public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLetOrVarKeyword: UnexpectedNodesSyntax? = nil, + letOrVarKeyword: TokenSyntax, + _ unexpectedBetweenLetOrVarKeywordAndPattern: UnexpectedNodesSyntax? = nil, pattern: P, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax? = nil, + _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedBetweenPatternAndWhereClause, whereClause, unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma))) { (arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLetOrVarKeyword, letOrVarKeyword, unexpectedBetweenLetOrVarKeywordAndPattern, pattern, unexpectedBetweenPatternAndTypeAnnotation, typeAnnotation, unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, + unexpectedBeforeLetOrVarKeyword?.raw, + letOrVarKeyword.raw, + unexpectedBetweenLetOrVarKeywordAndPattern?.raw, pattern.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw, + unexpectedBetweenPatternAndTypeAnnotation?.raw, + typeAnnotation?.raw, + unexpectedBetweenTypeAnnotationAndInitializer?.raw, + initializer?.raw, + unexpectedAfterInitializer?.raw, ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.caseItem, from: layout, arena: arena, + kind: SyntaxKind.optionalBindingCondition, from: layout, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) return SyntaxData.forRoot(raw) } - self.init(data) + self.init(data) + } + + public var unexpectedBeforeLetOrVarKeyword: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = OptionalBindingConditionSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var letOrVarKeyword: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = OptionalBindingConditionSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } } - public var unexpectedBeforePattern: UnexpectedNodesSyntax? { + public var unexpectedBetweenLetOrVarKeywordAndPattern: UnexpectedNodesSyntax? { get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CaseItemSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + self = OptionalBindingConditionSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) } } public var pattern: PatternSyntax { get { - return PatternSyntax(data.child(at: 1, parent: Syntax(self))!) + return PatternSyntax(data.child(at: 3, parent: Syntax(self))!) } set(value) { - self = CaseItemSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + self = OptionalBindingConditionSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? { get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CaseItemSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + self = OptionalBindingConditionSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) } } - public var whereClause: WhereClauseSyntax? { + public var typeAnnotation: TypeAnnotationSyntax? { get { - return data.child(at: 3, parent: Syntax(self)).map(WhereClauseSyntax.init) + return data.child(at: 5, parent: Syntax(self)).map(TypeAnnotationSyntax.init) } set(value) { - self = CaseItemSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena())) + self = OptionalBindingConditionSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? { get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CaseItemSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) + self = OptionalBindingConditionSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) } } - public var trailingComma: TokenSyntax? { + public var initializer: InitializerClauseSyntax? { get { - return data.child(at: 5, parent: Syntax(self)).map(TokenSyntax.init) + return data.child(at: 7, parent: Syntax(self)).map(InitializerClauseSyntax.init) } set(value) { - self = CaseItemSyntax(data.replacingChild(at: 5, with: value?.raw, arena: SyntaxArena())) + self = OptionalBindingConditionSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) } } - public var unexpectedAfterTrailingComma: UnexpectedNodesSyntax? { + public var unexpectedAfterInitializer: UnexpectedNodesSyntax? { get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } set(value) { - self = CaseItemSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + self = OptionalBindingConditionSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePattern, + \Self.unexpectedBeforeLetOrVarKeyword, + \Self.letOrVarKeyword, + \Self.unexpectedBetweenLetOrVarKeywordAndPattern, \Self.pattern, - \Self.unexpectedBetweenPatternAndWhereClause, - \Self.whereClause, - \Self.unexpectedBetweenWhereClauseAndTrailingComma, - \Self.trailingComma, - \Self.unexpectedAfterTrailingComma, + \Self.unexpectedBetweenPatternAndTypeAnnotation, + \Self.typeAnnotation, + \Self.unexpectedBetweenTypeAnnotationAndInitializer, + \Self.initializer, + \Self.unexpectedAfterInitializer, ]) } @@ -14842,22 +15015,28 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { return nil case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension CaseItemSyntax: CustomReflectable { +extension OptionalBindingConditionSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLetOrVarKeyword": unexpectedBeforeLetOrVarKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "letOrVarKeyword": Syntax(letOrVarKeyword).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLetOrVarKeywordAndPattern": unexpectedBetweenLetOrVarKeywordAndPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPatternAndWhereClause": unexpectedBetweenPatternAndWhereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "whereClause": whereClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenWhereClauseAndTrailingComma": unexpectedBetweenWhereClauseAndTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterTrailingComma": unexpectedAfterTrailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenPatternAndTypeAnnotation": unexpectedBetweenPatternAndTypeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenTypeAnnotationAndInitializer": unexpectedBetweenTypeAnnotationAndInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "initializer": initializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterInitializer": unexpectedAfterInitializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } @@ -15056,185 +15235,6 @@ extension CatchItemSyntax: CustomReflectable { } } -// MARK: - SwitchCaseLabelSyntax - -public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .switchCaseLabel else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// 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 == .switchCaseLabel) - self._syntaxNode = Syntax(data) - } - - public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .keyword(.case), - _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, - caseItems: CaseItemListSyntax, - _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeCaseKeyword, caseKeyword, unexpectedBetweenCaseKeywordAndCaseItems, caseItems, unexpectedBetweenCaseItemsAndColon, colon, unexpectedAfterColon))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndCaseItems?.raw, - caseItems.raw, - unexpectedBetweenCaseItemsAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchCaseLabel, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { - get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchCaseLabelSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - public var caseKeyword: TokenSyntax { - get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) - } - set(value) { - self = SwitchCaseLabelSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? { - get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchCaseLabelSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - public var caseItems: CaseItemListSyntax { - get { - return CaseItemListSyntax(data.child(at: 3, parent: Syntax(self))!) - } - set(value) { - self = SwitchCaseLabelSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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) - } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return SwitchCaseLabelSyntax(newData) - } - - public var unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchCaseLabelSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var colon: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = SwitchCaseLabelSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterColon: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchCaseLabelSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeCaseKeyword, - \Self.caseKeyword, - \Self.unexpectedBetweenCaseKeywordAndCaseItems, - \Self.caseItems, - \Self.unexpectedBetweenCaseItemsAndColon, - \Self.colon, - \Self.unexpectedAfterColon, - ]) - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - case 3: - return nil - case 4: - return nil - case 5: - return nil - case 6: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension SwitchCaseLabelSyntax: 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, - ]) - } -} - // MARK: - CatchClauseSyntax public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable { diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift index dddbf6d616e..d6cb644968f 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift @@ -243,6 +243,106 @@ extension LabeledStmtSyntax: CustomReflectable { } } +// MARK: - ExpressionStmtSyntax + +public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .expressionStmt else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `ExpressionStmtSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .expressionStmt) + self._syntaxNode = Syntax(data) + } + + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedAfterExpression?.raw, + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.expressionStmt, from: layout, arena: arena, + leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { + get { + return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ExpressionStmtSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) + } + } + + public var expression: ExprSyntax { + get { + return ExprSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = ExpressionStmtSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterExpression: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = ExpressionStmtSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedAfterExpression, + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + default: + fatalError("Invalid index") + } + } +} + +extension ExpressionStmtSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeExpression": unexpectedBeforeExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedAfterExpression": unexpectedAfterExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + // MARK: - ContinueStmtSyntax public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { @@ -1451,245 +1551,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 = .keyword(.switch), - _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, - cases: SwitchCaseListSyntax, - _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSwitchKeyword, switchKeyword, unexpectedBetweenSwitchKeywordAndExpression, expression, unexpectedBetweenExpressionAndLeftBrace, leftBrace, unexpectedBetweenLeftBraceAndCases, cases, unexpectedBetweenCasesAndRightBrace, rightBrace, unexpectedAfterRightBrace))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeSwitchKeyword?.raw, - switchKeyword.raw, - unexpectedBetweenSwitchKeywordAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndCases?.raw, - cases.raw, - unexpectedBetweenCasesAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchStmt, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? { - get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - public var switchKeyword: TokenSyntax { - get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? { - get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - public var expression: ExprSyntax { - get { - return ExprSyntax(data.child(at: 3, parent: Syntax(self))!) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var leftBrace: TokenSyntax { - get { - return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public var cases: SwitchCaseListSyntax { - get { - return SwitchCaseListSyntax(data.child(at: 7, parent: Syntax(self))!) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 7, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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) - } - - public var unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } - } - - public var rightBrace: TokenSyntax { - get { - return TokenSyntax(data.child(at: 9, parent: Syntax(self))!) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 9, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = SwitchStmtSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) - } - } - - 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 { @@ -2555,278 +2416,3 @@ 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 = .keyword(.if), - _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, - conditions: ConditionElementListSyntax, - _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, - elseKeyword: TokenSyntax? = nil, - _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, - elseBody: ElseBody? = nil, - _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil - ) { - // Extend the lifetime of all parameters so their arenas don't get destroyed - // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIfKeyword, ifKeyword, unexpectedBetweenIfKeywordAndConditions, conditions, unexpectedBetweenConditionsAndBody, body, unexpectedBetweenBodyAndElseKeyword, elseKeyword, unexpectedBetweenElseKeywordAndElseBody, elseBody, unexpectedAfterElseBody))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeIfKeyword?.raw, - ifKeyword.raw, - unexpectedBetweenIfKeywordAndConditions?.raw, - conditions.raw, - unexpectedBetweenConditionsAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndElseKeyword?.raw, - elseKeyword?.raw, - unexpectedBetweenElseKeywordAndElseBody?.raw, - elseBody?.raw, - unexpectedAfterElseBody?.raw, - ] - let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifStmt, from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? { - get { - return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena())) - } - } - - public var ifKeyword: TokenSyntax { - get { - return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? { - get { - return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) - } - } - - public var conditions: ConditionElementListSyntax { - get { - return ConditionElementListSyntax(data.child(at: 3, parent: Syntax(self))!) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 3, with: value.raw, arena: SyntaxArena())) - } - } - - /// 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) - } - - public var unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? { - get { - return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena())) - } - } - - public var body: CodeBlockSyntax { - get { - return CodeBlockSyntax(data.child(at: 5, parent: Syntax(self))!) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? { - get { - return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) - } - } - - public var elseKeyword: TokenSyntax? { - get { - return data.child(at: 7, parent: Syntax(self)).map(TokenSyntax.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 7, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? { - get { - return data.child(at: 8, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 8, with: value?.raw, arena: SyntaxArena())) - } - } - - public var elseBody: ElseBody? { - get { - return data.child(at: 9, parent: Syntax(self)).map(ElseBody.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 9, with: value?.raw, arena: SyntaxArena())) - } - } - - public var unexpectedAfterElseBody: UnexpectedNodesSyntax? { - get { - return data.child(at: 10, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) - } - set(value) { - self = IfStmtSyntax(data.replacingChild(at: 10, with: value?.raw, arena: SyntaxArena())) - } - } - - 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, - ]) - } -} - diff --git a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift index 19bef0901c4..66c3cc87faa 100644 --- a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift +++ b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift @@ -116,30 +116,30 @@ extension ExtensionDeclSyntax: HasTrailingMemberDeclBlock {} extension ProtocolDeclSyntax: HasTrailingMemberDeclBlock {} extension StructDeclSyntax: HasTrailingMemberDeclBlock {} -// MARK: - IfStmtSyntax -// IfStmtSyntax is a special scenario as we also have the `else` body or an if-else +// MARK: - IfExprSyntax +// IfExprSyntax is a special scenario as we also have the `else` body or an if-else // So we cannot conform to `HasTrailingCodeBlock` -public extension IfStmtSyntax { +public extension IfExprSyntax { init(_ header: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () throws -> CodeBlockItemListSyntax, @CodeBlockItemListBuilder `else` elseBuilder: () throws -> CodeBlockItemListSyntax? = { nil }) throws { - let stmt = StmtSyntax("\(header) {}") - guard let ifStmt = stmt.as(IfStmtSyntax.self) else { - throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: stmt) + let expr = ExprSyntax("\(header) {}") + guard let ifExpr = expr.as(Self.self) else { + throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr) } - self = ifStmt + self = ifExpr self.body = try CodeBlockSyntax(statements: bodyBuilder()) self.elseBody = try elseBuilder().map { .codeBlock(CodeBlockSyntax(statements: $0)) } self.elseKeyword = elseBody != nil ? .keyword(.else) : nil } - init(_ header: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, elseIf: IfStmtSyntax) throws { - let stmt = StmtSyntax("\(header) {}") - guard let ifStmt = stmt.as(IfStmtSyntax.self) else { - throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: stmt) + init(_ header: PartialSyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () -> CodeBlockItemListSyntax, elseIf: IfExprSyntax) throws { + let expr = ExprSyntax("\(header) {}") + guard let ifExpr = expr.as(Self.self) else { + throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr) } - self = ifStmt + self = ifExpr self.body = CodeBlockSyntax(statements: bodyBuilder()) - self.elseBody = .ifStmt(elseIf) + self.elseBody = .ifExpr(elseIf) self.elseKeyword = elseBody != nil ? .keyword(.else) : nil } } @@ -153,17 +153,17 @@ extension SwitchCaseSyntax { } } -// MARK: - SwitchStmtSyntax -// SwitchStmtSyntax is a special scenario as it don't have body or members +// MARK: - SwitchExprSyntax +// SwitchExprSyntax is a special scenario as it don't have body or members // So we cannot conform to `HasTrailingCodeBlock` or `HasTrailingMemberDeclBlock` -public extension SwitchStmtSyntax { +public extension SwitchExprSyntax { init(_ header: PartialSyntaxNodeString, @SwitchCaseListBuilder casesBuilder: () throws -> SwitchCaseListSyntax = { SwitchCaseListSyntax([]) }) throws { - let stmt = StmtSyntax("\(header) {}") - guard let castedStmt = stmt.as(Self.self) else { - throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: stmt) + let expr = ExprSyntax("\(header) {}") + guard let switchExpr = expr.as(Self.self) else { + throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr) } - self = castedStmt + self = switchExpr self.cases = try casesBuilder() } } diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index dfb06f71811..18753f2e3d6 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -199,7 +199,7 @@ extension GuardStmtSyntax { } } -extension IfStmtSyntax { +extension IfExprSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init(leadingTrivia: Trivia? = nil, unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, ifKeyword: TokenSyntax = .keyword(.if), unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, conditions: ConditionElementListSyntax, unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, elseKeyword: TokenSyntax? = nil, unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, elseBody: ElseBody? = nil, unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil, @CodeBlockItemListBuilder bodyBuilder: () throws -> CodeBlockItemListSyntax, trailingTrivia: Trivia? = nil)rethrows { @@ -321,7 +321,7 @@ extension SwitchCaseSyntax { } } -extension SwitchStmtSyntax { +extension SwitchExprSyntax { /// A convenience initializer that allows initializing syntax collections using result builders public init(leadingTrivia: Trivia? = nil, unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, switchKeyword: TokenSyntax = .keyword(.switch), unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntaxProtocol, unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, leftBrace: TokenSyntax = .leftBraceToken(), unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, rightBrace: TokenSyntax = .rightBraceToken(), unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, @SwitchCaseListBuilder casesBuilder: () throws -> SwitchCaseListSyntax, trailingTrivia: Trivia? = nil)rethrows { diff --git a/Tests/SwiftParserTest/ExpressionTests.swift b/Tests/SwiftParserTest/ExpressionTests.swift index 5d21de794d1..4b0a1ad668a 100644 --- a/Tests/SwiftParserTest/ExpressionTests.swift +++ b/Tests/SwiftParserTest/ExpressionTests.swift @@ -1170,3 +1170,418 @@ final class MemberExprTests: XCTestCase { } } } + +final class StatementExpressionTests: XCTestCase { + private func ifZeroElseOne() -> ExprSyntax { + .init( + IfExprSyntax( + conditions: [ + .init( + condition: .expression( + .init( + FunctionCallExprSyntax(callee: MemberAccessExprSyntax(name: "random")) + ) + ) + ) + ], + body: .init(statements: [ + .init(item: .expr(.init(IntegerLiteralExprSyntax(0)))) + ]), + elseKeyword: .keyword(.else), + elseBody: .init( + .codeBlock( + .init(statements: [ + .init(item: .expr(.init(IntegerLiteralExprSyntax(1)))) + ]) + ) + ) + ) + ) + } + private func switchRandomZeroOne() -> ExprSyntax { + .init( + SwitchExprSyntax( + expression: FunctionCallExprSyntax( + callee: MemberAccessExprSyntax( + base: 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( + """ + 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() { + AssertParse( + """ + func foo() { + return if .random() { 0 } else { 1 } + } + """, + substructure: Syntax( + ReturnStmtSyntax(expression: ifZeroElseOne()) + ) + ) + } + func testSwitchExprInReturn() { + AssertParse( + """ + func foo() { + return switch Bool.random() { case true: 0 case false: 1 } + } + """, + substructure: Syntax( + ReturnStmtSyntax(expression: switchRandomZeroOne()) + ) + ) + } + func testTryIf1() { + AssertParse( + """ + func foo() -> Int { + try if .random() { 0 } else { 1 } + } + """, + substructure: Syntax( + TryExprSyntax(expression: ifZeroElseOne()) + ) + ) + } + func testTryIf2() { + AssertParse( + """ + func foo() -> Int { + return try if .random() { 0 } else { 1 } + } + """, + substructure: Syntax( + ReturnStmtSyntax(expression: TryExprSyntax(expression: ifZeroElseOne())) + ) + ) + } + func testTryIf3() { + AssertParse( + """ + func foo() -> Int { + let x = try if .random() { 0 } else { 1 } + return x + } + """, + substructure: Syntax( + TryExprSyntax(expression: ifZeroElseOne()) + ) + ) + } + func testAwaitIf1() { + AssertParse( + """ + func foo() async -> Int { + await if .random() { 0 } else { 1 } + } + """, + substructure: Syntax( + AwaitExprSyntax(expression: ifZeroElseOne()) + ) + ) + } + func testAwaitIf2() { + AssertParse( + """ + func foo() async -> Int { + return await if .random() { 0 } else { 1 } + } + """, + substructure: Syntax( + ReturnStmtSyntax(expression: AwaitExprSyntax(expression: ifZeroElseOne())) + ) + ) + } + func testAwaitIf3() { + AssertParse( + """ + func foo() async -> Int { + let x = await if .random() { 0 } else { 1 } + return x + } + """, + substructure: Syntax( + AwaitExprSyntax(expression: ifZeroElseOne()) + ) + ) + } + func testTrySwitch1() { + AssertParse( + """ + try switch Bool.random() { case true: 0 case false: 1 } + """, + substructure: Syntax( + TryExprSyntax(expression: switchRandomZeroOne()) + ) + ) + } + func testTrySwitch2() { + AssertParse( + """ + func foo() -> Int { + return try switch Bool.random() { case true: 0 case false: 1 } + } + """, + substructure: Syntax( + ReturnStmtSyntax(expression: TryExprSyntax(expression: switchRandomZeroOne())) + ) + ) + } + func testTrySwitch3() { + AssertParse( + """ + func foo() -> Int { + let x = try switch Bool.random() { case true: 0 case false: 1 } + return x + } + """, + substructure: Syntax( + TryExprSyntax(expression: switchRandomZeroOne()) + ) + ) + } + func testAwaitSwitch1() { + AssertParse( + """ + await switch Bool.random() { case true: 0 case false: 1 } + """, + substructure: Syntax( + AwaitExprSyntax(expression: switchRandomZeroOne()) + ) + ) + } + func testAwaitSwitch2() { + AssertParse( + """ + func foo() async -> Int { + return await switch Bool.random() { case true: 0 case false: 1 } + } + """, + substructure: Syntax( + ReturnStmtSyntax(expression: AwaitExprSyntax(expression: switchRandomZeroOne())) + ) + ) + } + func testAwaitSwitch3() { + AssertParse( + """ + func foo() async -> Int { + 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/SwiftParserTest/StatementTests.swift b/Tests/SwiftParserTest/StatementTests.swift index ea4a2b1b371..bf75740cf8d 100644 --- a/Tests/SwiftParserTest/StatementTests.swift +++ b/Tests/SwiftParserTest/StatementTests.swift @@ -21,7 +21,7 @@ final class StatementTests: XCTestCase { if let baz {} """, substructure: Syntax( - IfStmtSyntax( + IfExprSyntax( ifKeyword: .keyword(.if), conditions: ConditionElementListSyntax([ ConditionElementSyntax( @@ -47,7 +47,7 @@ final class StatementTests: XCTestCase { if let self = self {} """, substructure: Syntax( - IfStmtSyntax( + IfExprSyntax( ifKeyword: .keyword(.if), conditions: ConditionElementListSyntax([ ConditionElementSyntax( diff --git a/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift b/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift index 6f4a3df4e9a..3f284c3b452 100644 --- a/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift +++ b/Tests/SwiftRefactorTest/MigrateToNewIfLetSyntax.swift @@ -17,102 +17,116 @@ import SwiftSyntaxBuilder import XCTest import _SwiftSyntaxTestSupport +func AssertRefactorIfLet( + _ syntax: ExprSyntax, + expected: ExprSyntax, + file: StaticString = #file, + line: UInt = #line +) throws { + 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, + file: file, + line: line + ) +} + 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 AssertRefactorIfLet(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) + try AssertRefactorIfLet(baselineSyntax, expected: expectedSyntax) + try AssertRefactorIfLet(expectedSyntax, 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 AssertRefactorIfLet(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 AssertRefactorIfLet(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 AssertRefactorIfLet(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 AssertRefactorIfLet(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 AssertRefactorIfLet(exprStmt.expression, expected: expectedSyntax) } } diff --git a/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift b/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift index 71dde96c134..f604869e98b 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 = IfStmtSyntax(conditions: ConditionElementListSyntax { BooleanLiteralExprSyntax(false) }) {} + let buildable = IfExprSyntax(conditions: ConditionElementListSyntax { BooleanLiteralExprSyntax(false) }) {} AssertBuildResult( buildable, """ @@ -29,16 +29,16 @@ final class IfStmtTests: XCTestCase { ) } - func testIfStmtyntax() throws { - let testCases: [UInt: (IfStmtSyntax, String)] = [ + func testIfStmtSyntax() throws { + let testCases: [UInt: (IfExprSyntax, String)] = [ #line: ( - StmtSyntax( + ExprSyntax( """ if foo == x { return foo } """ - ).cast(IfStmtSyntax.self), + ).cast(IfExprSyntax.self), """ if foo == x { return foo @@ -46,7 +46,7 @@ final class IfStmtTests: XCTestCase { """ ), #line: ( - try IfStmtSyntax("if foo == x") { StmtSyntax("return foo") }, + try IfExprSyntax("if foo == x") { StmtSyntax("return foo") }, """ if foo == x { return foo @@ -54,7 +54,7 @@ final class IfStmtTests: XCTestCase { """ ), #line: ( - try IfStmtSyntax("if foo == x") { + try IfExprSyntax("if foo == x") { StmtSyntax("return foo") } else: { StmtSyntax("return bar") @@ -68,7 +68,7 @@ final class IfStmtTests: XCTestCase { """ ), #line: ( - try IfStmtSyntax("if foo == x", bodyBuilder: { StmtSyntax("return foo") }, elseIf: IfStmtSyntax("if foo == z") { StmtSyntax("return baz") }), + try IfExprSyntax("if foo == x", bodyBuilder: { StmtSyntax("return foo") }, elseIf: IfExprSyntax("if foo == z") { StmtSyntax("return baz") }), """ if foo == x { return foo @@ -86,21 +86,21 @@ final class IfStmtTests: XCTestCase { } func testIfStmtSpacing() { - let testCases: [UInt: (IfStmtSyntax, String)] = [ + let testCases: [UInt: (IfExprSyntax, String)] = [ #line: ( - IfStmtSyntax(conditions: ConditionElementListSyntax { ExprSyntax("!(true)") }) {}, + IfExprSyntax(conditions: ConditionElementListSyntax { ExprSyntax("!(true)") }) {}, """ if !(true) { } """ ), #line: ( - StmtSyntax( + ExprSyntax( """ if !(false) { } """ - ).cast(IfStmtSyntax.self), + ).cast(IfExprSyntax.self), """ if !(false) { } @@ -115,7 +115,7 @@ final class IfStmtTests: XCTestCase { } func testIfLetStmt() { - let buildable = IfStmtSyntax( + let buildable = IfExprSyntax( conditions: ConditionElementListSyntax { OptionalBindingConditionSyntax( letOrVarKeyword: .keyword(.let), @@ -134,7 +134,7 @@ final class IfStmtTests: XCTestCase { } func testIfCaseStmt() { - let buildable = IfStmtSyntax( + let buildable = IfExprSyntax( conditions: ConditionElementListSyntax { MatchingPatternConditionSyntax( pattern: ExpressionPatternSyntax(expression: MemberAccessExprSyntax(name: "x")), diff --git a/Tests/SwiftSyntaxBuilderTest/SwitchTests.swift b/Tests/SwiftSyntaxBuilderTest/SwitchTests.swift index 24f79ab2540..6a46f480cfc 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 = SwitchStmtSyntax(expression: ExprSyntax("count")) { + let syntax = SwitchExprSyntax(expression: ExprSyntax("count")) { for num in 1..<3 { SwitchCaseSyntax("case \(literal: num):") { ExprSyntax("print(count)") @@ -43,7 +43,7 @@ final class SwitchTests: XCTestCase { } func testSwitchStmtSyntaxWithStringParsing() throws { - let syntax = try SwitchStmtSyntax("switch count") { + let syntax = try SwitchExprSyntax("switch count") { for num in 1..<3 { SwitchCaseSyntax("case \(literal: num):") { ExprSyntax("print(count)") diff --git a/gyb_syntax_support/ExprNodes.py b/gyb_syntax_support/ExprNodes.py index 8825cd5b9cf..05ac0122ade 100644 --- a/gyb_syntax_support/ExprNodes.py +++ b/gyb_syntax_support/ExprNodes.py @@ -278,6 +278,95 @@ Child("BooleanLiteral", kind='KeywordToken', token_choices=['KeywordToken|true', 'KeywordToken|false']) ]), + # 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='KeywordToken', token_choices=['KeywordToken|if']), + Child('Conditions', kind='ConditionElementList', + collection_element_name='Condition'), + Child('Body', kind='CodeBlock', name_for_diagnostics='body'), + Child('ElseKeyword', kind='ElseToken', + is_optional=True), + Child('ElseBody', kind='Syntax', name_for_diagnostics='else body', + node_choices=[ + Child('IfExpr', kind='IfExpr'), + Child('CodeBlock', kind='CodeBlock'), + ], + is_optional=True), + ]), + + # 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='KeywordToken', token_choices=['KeywordToken|switch']), + Child('Expression', kind='Expr'), + Child('LeftBrace', kind='LeftBraceToken'), + Child('Cases', kind='SwitchCaseList', + collection_element_name='Case'), + Child('RightBrace', kind='RightBraceToken', + requires_leading_newline=True), + ]), + + # switch-case-list -> switch-case switch-case-list? + Node('SwitchCaseList', name_for_diagnostics=None, kind='SyntaxCollection', + element='Syntax', element_name='SwitchCase', + element_choices=['SwitchCase', 'IfConfigDecl'], + elements_separated_by_newline=True), + + # switch-case -> unknown-attr? switch-case-label stmt-list + # | unknown-attr? switch-default-label stmt-list + Node('SwitchCase', name_for_diagnostics='switch case', kind='Syntax', + traits=['WithStatements'], + parser_function='parseSwitchCase', + children=[ + Child('UnknownAttr', kind='Attribute', is_optional=True), + Child('Label', kind='Syntax', name_for_diagnostics='label', + node_choices=[ + Child('Default', kind='SwitchDefaultLabel'), + Child('Case', kind='SwitchCaseLabel'), + ]), + Child('Statements', kind='CodeBlockItemList', + collection_element_name='Statement', + is_indented=True), + ]), + + # switch-case-label -> 'case' case-item-list ':' + Node('SwitchCaseLabel', name_for_diagnostics=None, kind='Syntax', + children=[ + Child('CaseKeyword', kind='KeywordToken', token_choices=['KeywordToken|case']), + Child('CaseItems', kind='CaseItemList', + collection_element_name='CaseItem'), + Child('Colon', kind='ColonToken'), + ]), + + # switch-default-label -> 'default' ':' + Node('SwitchDefaultLabel', name_for_diagnostics=None, kind='Syntax', + children=[ + Child('DefaultKeyword', kind='KeywordToken', token_choices=['KeywordToken|default']), + Child('Colon', kind='ColonToken'), + ]), + + # case-item -> pattern where-clause? ','? + Node('CaseItem', name_for_diagnostics=None, kind='Syntax', + traits=['WithTrailingComma'], + children=[ + Child('Pattern', kind='Pattern'), + Child('WhereClause', kind='WhereClause', + is_optional=True), + Child('TrailingComma', kind='CommaToken', + is_optional=True), + ]), + # ? expr : # Ternary expression without the condition and the second choice. # NOTE: This appears only in SequenceExpr. diff --git a/gyb_syntax_support/StmtNodes.py b/gyb_syntax_support/StmtNodes.py index 5b6296c492a..a772eaa054c 100644 --- a/gyb_syntax_support/StmtNodes.py +++ b/gyb_syntax_support/StmtNodes.py @@ -10,6 +10,12 @@ Child('Statement', kind='Stmt'), ]), + # expr-stmt -> expression ';'? + Node('ExpressionStmt', name_for_diagnostics='expression', kind='Stmt', + children=[ + Child('Expression', kind='Expr'), + ]), + # continue-stmt -> 'continue' label? ';'? Node('ContinueStmt', name_for_diagnostics="'continue' statement", kind='Stmt', children=[ @@ -36,12 +42,6 @@ Child('Body', kind='CodeBlock'), ]), - # switch-case-list -> switch-case switch-case-list? - Node('SwitchCaseList', name_for_diagnostics=None, kind='SyntaxCollection', - element='Syntax', element_name='SwitchCase', - element_choices=['SwitchCase', 'IfConfigDecl'], - elements_separated_by_newline=True), - # repeat-while-stmt -> label? ':'? 'repeat' code-block 'while' expr ';'? Node('RepeatWhileStmt', name_for_diagnostics="'repeat' statement", kind='Stmt', traits=['WithCodeBlock'], @@ -93,20 +93,6 @@ Child('Body', kind='CodeBlock', name_for_diagnostics='body'), ]), - # switch-stmt -> identifier? ':'? 'switch' expr '{' - # switch-case-list '}' ';'? - Node('SwitchStmt', name_for_diagnostics="'switch' statement", kind='Stmt', - traits=['Braced'], - children=[ - Child('SwitchKeyword', kind='KeywordToken', token_choices=['KeywordToken|switch']), - Child('Expression', kind='Expr'), - Child('LeftBrace', kind='LeftBraceToken'), - Child('Cases', kind='SwitchCaseList', - collection_element_name='Case'), - Child('RightBrace', kind='RightBraceToken', - requires_leading_newline=True), - ]), - # catch-clause-list -> catch-clause catch-clause-list? Node('CatchClauseList', name_for_diagnostics="'catch' clause", kind='SyntaxCollection', element='CatchClause'), @@ -233,60 +219,6 @@ Child('Expression', kind='Expr'), ]), - # if-stmt -> identifier? ':'? 'if' condition-list code-block - # else-clause ';'? - Node('IfStmt', name_for_diagnostics="'if' statement", kind='Stmt', - traits=['WithCodeBlock'], - children=[ - Child('IfKeyword', kind='KeywordToken', token_choices=['KeywordToken|if']), - Child('Conditions', kind='ConditionElementList', - collection_element_name='Condition'), - Child('Body', kind='CodeBlock', name_for_diagnostics='body'), - Child('ElseKeyword', kind='ElseToken', - is_optional=True), - Child('ElseBody', kind='Syntax', name_for_diagnostics='else body', - node_choices=[ - Child('IfStmt', kind='IfStmt'), - Child('CodeBlock', kind='CodeBlock'), - ], - is_optional=True), - ]), - - # switch-case -> unknown-attr? switch-case-label stmt-list - # | unknown-attr? switch-default-label stmt-list - Node('SwitchCase', name_for_diagnostics='switch case', kind='Syntax', - traits=['WithStatements'], - parser_function='parseSwitchCase', - children=[ - Child('UnknownAttr', kind='Attribute', is_optional=True), - Child('Label', kind='Syntax', name_for_diagnostics='label', - node_choices=[ - Child('Default', kind='SwitchDefaultLabel'), - Child('Case', kind='SwitchCaseLabel'), - ]), - Child('Statements', kind='CodeBlockItemList', - collection_element_name='Statement', - is_indented=True), - ]), - - # switch-default-label -> 'default' ':' - Node('SwitchDefaultLabel', name_for_diagnostics=None, kind='Syntax', - children=[ - Child('DefaultKeyword', kind='KeywordToken', token_choices=['KeywordToken|default']), - Child('Colon', kind='ColonToken'), - ]), - - # case-item -> pattern where-clause? ','? - Node('CaseItem', name_for_diagnostics=None, kind='Syntax', - traits=['WithTrailingComma'], - children=[ - Child('Pattern', kind='Pattern'), - Child('WhereClause', kind='WhereClause', - is_optional=True), - Child('TrailingComma', kind='CommaToken', - is_optional=True), - ]), - # catch-item -> pattern? where-clause? ','? Node('CatchItem', name_for_diagnostics=None, kind='Syntax', traits=['WithTrailingComma'], @@ -298,15 +230,6 @@ is_optional=True), ]), - # switch-case-label -> 'case' case-item-list ':' - Node('SwitchCaseLabel', name_for_diagnostics=None, kind='Syntax', - children=[ - Child('CaseKeyword', kind='KeywordToken', token_choices=['KeywordToken|case']), - Child('CaseItems', kind='CaseItemList', - collection_element_name='CaseItem'), - Child('Colon', kind='ColonToken'), - ]), - # catch-clause 'catch' case-item-list? code-block Node('CatchClause', name_for_diagnostics="'catch' clause", kind='Syntax', traits=['WithCodeBlock'],