diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift index 66915c3394d..03324d5fab3 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift @@ -26,17 +26,6 @@ public let EXPR_NODES: [Node] = [ kind: "Expr") ]), - Node(name: "PoundColumnExpr", - nameForDiagnostics: nil, - kind: "Expr", - children: [ - Child(name: "PoundColumn", - kind: "PoundColumnToken", - tokenChoices: [ - "PoundColumn" - ]) - ]), - Node(name: "TupleExprElementList", nameForDiagnostics: nil, kind: "SyntaxCollection", @@ -229,72 +218,6 @@ public let EXPR_NODES: [Node] = [ element: "Expr", elementName: "Expression"), - Node(name: "PoundLineExpr", - nameForDiagnostics: nil, - kind: "Expr", - children: [ - Child(name: "PoundLine", - kind: "PoundLineToken", - tokenChoices: [ - "PoundLine" - ]) - ]), - - Node(name: "PoundFileExpr", - nameForDiagnostics: nil, - kind: "Expr", - children: [ - Child(name: "PoundFile", - kind: "PoundFileToken", - tokenChoices: [ - "PoundFile" - ]) - ]), - - Node(name: "PoundFileIDExpr", - nameForDiagnostics: nil, - kind: "Expr", - children: [ - Child(name: "PoundFileID", - kind: "PoundFileIDToken", - tokenChoices: [ - "PoundFileID" - ]) - ]), - - Node(name: "PoundFilePathExpr", - nameForDiagnostics: nil, - kind: "Expr", - children: [ - Child(name: "PoundFilePath", - kind: "PoundFilePathToken", - tokenChoices: [ - "PoundFilePath" - ]) - ]), - - Node(name: "PoundFunctionExpr", - nameForDiagnostics: nil, - kind: "Expr", - children: [ - Child(name: "PoundFunction", - kind: "PoundFunctionToken", - tokenChoices: [ - "PoundFunction" - ]) - ]), - - Node(name: "PoundDsohandleExpr", - nameForDiagnostics: nil, - kind: "Expr", - children: [ - Child(name: "PoundDsohandle", - kind: "PoundDsohandleToken", - tokenChoices: [ - "PoundDsohandle" - ]) - ]), - Node(name: "SymbolicReferenceExpr", nameForDiagnostics: nil, kind: "Expr", @@ -1162,97 +1085,6 @@ public let EXPR_NODES: [Node] = [ ]) ]), - Node(name: "ObjcNamePiece", - nameForDiagnostics: nil, - kind: "Syntax", - children: [ - Child(name: "Name", - kind: "IdentifierToken", - tokenChoices: [ - "Identifier" - ]), - Child(name: "Dot", - kind: "PeriodToken", - isOptional: true, - tokenChoices: [ - "Period" - ]) - ]), - - Node(name: "ObjcName", - nameForDiagnostics: nil, - kind: "SyntaxCollection", - element: "ObjcNamePiece"), - - Node(name: "ObjcKeyPathExpr", - nameForDiagnostics: "'#keyPath' expression", - kind: "Expr", - traits: [ - "Parenthesized" - ], - children: [ - Child(name: "KeyPath", - kind: "PoundKeyPathToken", - tokenChoices: [ - "PoundKeyPath" - ]), - Child(name: "LeftParen", - kind: "LeftParenToken", - tokenChoices: [ - "LeftParen" - ]), - Child(name: "Name", - kind: "ObjcName", - collectionElementName: "NamePiece"), - Child(name: "RightParen", - kind: "RightParenToken", - tokenChoices: [ - "RightParen" - ]) - ]), - - Node(name: "ObjcSelectorExpr", - nameForDiagnostics: "'#selector' expression", - kind: "Expr", - traits: [ - "Parenthesized" - ], - children: [ - Child(name: "PoundSelector", - kind: "PoundSelectorToken", - tokenChoices: [ - "PoundSelector" - ]), - Child(name: "LeftParen", - kind: "LeftParenToken", - tokenChoices: [ - "LeftParen" - ]), - Child(name: "Kind", - kind: "ContextualKeywordToken", - isOptional: true, - tokenChoices: [ - "ContextualKeyword" - ], - textChoices: [ - "getter", - "setter" - ]), - Child(name: "Colon", - kind: "ColonToken", - isOptional: true, - tokenChoices: [ - "Colon" - ]), - Child(name: "Name", - kind: "Expr"), - Child(name: "RightParen", - kind: "RightParenToken", - tokenChoices: [ - "RightParen" - ]) - ]), - Node(name: "MacroExpansionExpr", nameForDiagnostics: "pound literal expression", kind: "Expr", @@ -1317,35 +1149,6 @@ public let EXPR_NODES: [Node] = [ ]) ]), - Node(name: "ObjectLiteralExpr", - nameForDiagnostics: "object literal", - kind: "Expr", - traits: [ - "Parenthesized" - ], - children: [ - Child(name: "Identifier", - kind: "Token", - tokenChoices: [ - "PoundColorLiteral", - "PoundFileLiteral", - "PoundImageLiteral" - ]), - Child(name: "LeftParen", - kind: "LeftParenToken", - tokenChoices: [ - "LeftParen" - ]), - Child(name: "Arguments", - kind: "TupleExprElementList", - collectionElementName: "Argument"), - Child(name: "RightParen", - kind: "RightParenToken", - tokenChoices: [ - "RightParen" - ]) - ]), - Node(name: "YieldExprList", nameForDiagnostics: "yield list", kind: "SyntaxCollection", diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/TokenSpec.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/TokenSpec.swift index 615ca4bac8f..b58ebb5b631 100644 --- a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/TokenSpec.swift +++ b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/TokenSpec.swift @@ -254,11 +254,6 @@ public let SYNTAX_TOKENS: [TokenSpec] = [ ExprKeywordSpec(name: "True", text: "true"), ExprKeywordSpec(name: "Try", text: "try", requiresTrailingSpace: true), ExprKeywordSpec(name: "Throws", text: "throws", requiresTrailingSpace: true), - KeywordSpec(name: "__FILE__", text: "__FILE__", requiresTrailingSpace: true), - KeywordSpec(name: "__LINE__", text: "__LINE__", requiresTrailingSpace: true), - KeywordSpec(name: "__COLUMN__", text: "__COLUMN__", requiresTrailingSpace: true), - KeywordSpec(name: "__FUNCTION__", text: "__FUNCTION__", requiresTrailingSpace: true), - KeywordSpec(name: "__DSO_HANDLE__", text: "__DSO_HANDLE__", requiresTrailingSpace: true), PatternKeywordSpec(name: "Wildcard", text: "_", requiresTrailingSpace: true), PunctuatorSpec(name: "LeftParen", kind: "l_paren", text: "("), PunctuatorSpec(name: "RightParen", kind: "r_paren", text: ")"), @@ -287,15 +282,6 @@ public let SYNTAX_TOKENS: [TokenSpec] = [ PunctuatorSpec(name: "StringQuote", kind: "string_quote", text: "\"", classification: "StringLiteral"), PunctuatorSpec(name: "SingleQuote", kind: "single_quote", text: "\'", classification: "StringLiteral"), PunctuatorSpec(name: "MultilineStringQuote", kind: "multiline_string_quote", text: "\"\"\"", classification: "StringLiteral"), - PoundKeywordSpec(name: "PoundKeyPath", kind: "pound_keyPath", text: "#keyPath"), - PoundKeywordSpec(name: "PoundLine", kind: "pound_line", text: "#line"), - PoundKeywordSpec(name: "PoundSelector", kind: "pound_selector", text: "#selector"), - PoundKeywordSpec(name: "PoundFile", kind: "pound_file", text: "#file"), - PoundKeywordSpec(name: "PoundFileID", kind: "pound_fileID", text: "#fileID"), - PoundKeywordSpec(name: "PoundFilePath", kind: "pound_filePath", text: "#filePath"), - PoundKeywordSpec(name: "PoundColumn", kind: "pound_column", text: "#column"), - PoundKeywordSpec(name: "PoundFunction", kind: "pound_function", text: "#function"), - PoundKeywordSpec(name: "PoundDsohandle", kind: "pound_dsohandle", text: "#dsohandle"), PoundKeywordSpec(name: "PoundAssert", kind: "pound_assert", text: "#assert"), PoundDirectiveKeywordSpec(name: "PoundSourceLocation", kind: "pound_sourceLocation", text: "#sourceLocation"), PoundDirectiveKeywordSpec(name: "PoundWarning", kind: "pound_warning", text: "#warning"), @@ -306,9 +292,6 @@ public let SYNTAX_TOKENS: [TokenSpec] = [ PoundConditionalDirectiveKeywordSpec(name: "PoundEndif", kind: "pound_endif", text: "#endif"), PoundConfigSpec(name: "PoundAvailable", kind: "pound_available", text: "#available"), PoundConfigSpec(name: "PoundUnavailable", kind: "pound_unavailable", text: "#unavailable"), - PoundObjectLiteralSpec(name: "PoundFileLiteral", kind: "pound_fileLiteral", text: "#fileLiteral", nameForDiagnostics: "file reference", protocol: "ExpressibleByFileReferenceLiteral"), - PoundObjectLiteralSpec(name: "PoundImageLiteral", kind: "pound_imageLiteral", text: "#imageLiteral", nameForDiagnostics: "image", protocol: "ExpressibleByImageLiteral"), - PoundObjectLiteralSpec(name: "PoundColorLiteral", kind: "pound_colorLiteral", text: "#colorLiteral", nameForDiagnostics: "color", protocol: "ExpressibleByColorLiteral"), PoundConfigSpec(name: "PoundHasSymbol", kind: "pound__hasSymbol", text: "#_hasSymbol"), LiteralSpec(name: "IntegerLiteral", kind: "integer_literal", nameForDiagnostics: "integer literal", classification: "IntegerLiteral"), LiteralSpec(name: "FloatingLiteral", kind: "floating_literal", nameForDiagnostics: "floating literal", classification: "FloatingLiteral"), diff --git a/Sources/IDEUtils/generated/SyntaxClassification.swift b/Sources/IDEUtils/generated/SyntaxClassification.swift index 61a996eaea1..c1deb6affff 100644 --- a/Sources/IDEUtils/generated/SyntaxClassification.swift +++ b/Sources/IDEUtils/generated/SyntaxClassification.swift @@ -246,16 +246,6 @@ extension RawTokenKind { return .keyword case .throwsKeyword: return .keyword - case .__file__Keyword: - return .keyword - case .__line__Keyword: - return .keyword - case .__column__Keyword: - return .keyword - case .__function__Keyword: - return .keyword - case .__dso_handle__Keyword: - return .keyword case .wildcardKeyword: return .keyword case .leftParen: @@ -312,24 +302,6 @@ extension RawTokenKind { return .stringLiteral case .multilineStringQuote: return .stringLiteral - case .poundKeyPathKeyword: - return .keyword - case .poundLineKeyword: - return .keyword - case .poundSelectorKeyword: - return .keyword - case .poundFileKeyword: - return .keyword - case .poundFileIDKeyword: - return .keyword - case .poundFilePathKeyword: - return .keyword - case .poundColumnKeyword: - return .keyword - case .poundFunctionKeyword: - return .keyword - case .poundDsohandleKeyword: - return .keyword case .poundAssertKeyword: return .keyword case .poundSourceLocationKeyword: @@ -350,12 +322,6 @@ extension RawTokenKind { return .keyword case .poundUnavailableKeyword: return .keyword - case .poundFileLiteralKeyword: - return .objectLiteral - case .poundImageLiteralKeyword: - return .objectLiteral - case .poundColorLiteralKeyword: - return .objectLiteral case .poundHasSymbolKeyword: return .keyword case .integerLiteral: diff --git a/Sources/SwiftBasicFormat/generated/BasicFormat.swift b/Sources/SwiftBasicFormat/generated/BasicFormat.swift index 8bf11845355..52683f23e20 100644 --- a/Sources/SwiftBasicFormat/generated/BasicFormat.swift +++ b/Sources/SwiftBasicFormat/generated/BasicFormat.swift @@ -226,16 +226,6 @@ open class BasicFormat: SyntaxRewriter { return true case .throwsKeyword: return true - case .__file__Keyword: - return true - case .__line__Keyword: - return true - case .__column__Keyword: - return true - case .__function__Keyword: - return true - case .__dso_handle__Keyword: - return true case .wildcardKeyword: return true case .leftAngle: @@ -250,24 +240,6 @@ open class BasicFormat: SyntaxRewriter { return true case .arrow: return true - case .poundKeyPathKeyword: - return true - case .poundLineKeyword: - return true - case .poundSelectorKeyword: - return true - case .poundFileKeyword: - return true - case .poundFileIDKeyword: - return true - case .poundFilePathKeyword: - return true - case .poundColumnKeyword: - return true - case .poundFunctionKeyword: - return true - case .poundDsohandleKeyword: - return true case .poundAssertKeyword: return true case .poundSourceLocationKeyword: @@ -288,12 +260,6 @@ open class BasicFormat: SyntaxRewriter { return true case .poundUnavailableKeyword: return true - case .poundFileLiteralKeyword: - return true - case .poundImageLiteralKeyword: - return true - case .poundColorLiteralKeyword: - return true case .poundHasSymbolKeyword: return true case .spacedBinaryOperator: diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 11340d15462..79ce307c78a 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -973,8 +973,6 @@ extension Parser { /// primary-expression → implicit-member-expression /// primary-expression → wildcard-expression /// primary-expression → key-path-expression - /// primary-expression → selector-expression - /// primary-expression → key-path-string-expression /// primary-expression → macro-expansion-expression @_spi(RawSyntax) public mutating func parsePrimaryExpression( @@ -1011,36 +1009,6 @@ extension Parser { booleanLiteral: tok, arena: self.arena )) - case (.__file__Keyword, let handle)?: - let tok = self.eat(handle) - return RawExprSyntax(RawPoundFileExprSyntax( - poundFile: tok, - arena: self.arena - )) - case (.__function__Keyword, let handle)?: - let tok = self.eat(handle) - return RawExprSyntax(RawPoundFunctionExprSyntax( - poundFunction: tok, - arena: self.arena - )) - case (.__line__Keyword, let handle)?: - let tok = self.eat(handle) - return RawExprSyntax(RawPoundLineExprSyntax( - poundLine: tok, - arena: self.arena - )) - case (.__column__Keyword, let handle)?: - let tok = self.eat(handle) - return RawExprSyntax(RawPoundColumnExprSyntax( - poundColumn: tok, - arena: self.arena - )) - case (.__dso_handle__Keyword, let handle)?: - let tok = self.eat(handle) - return RawExprSyntax(RawPoundDsohandleExprSyntax( - poundDsohandle: tok, - arena: self.arena - )) case (.identifier, let handle)?, (.selfKeyword, let handle)?, (.initKeyword, let handle)?: // If we have "case let x." or "case let x(", we parse x as a normal // name, not a binding, because it is the start of an enum pattern or @@ -1081,11 +1049,6 @@ extension Parser { self.parseMacroExpansionExpr(pattern: pattern, flavor: flavor) ) - case (.poundSelectorKeyword, _)?: - return RawExprSyntax(self.parseObjectiveCSelectorLiteral()) - case (.poundKeyPathKeyword, _)?: - return RawExprSyntax(self.parseObjectiveCKeyPathExpression()) - case (.leftBrace, _)?: // expr-closure return RawExprSyntax(self.parseClosureExpression()) case (.period, let handle)?, //=.foo @@ -1653,53 +1616,6 @@ extension Parser { } } -extension Parser { - /// Parse an Objective-C #keypath literal. - /// - /// Grammar - /// ======= - /// - /// key-path-string-expression → '#keyPath' '(' expression ')' - @_spi(RawSyntax) - public mutating func parseObjectiveCKeyPathExpression() -> RawObjcKeyPathExprSyntax { - let (unexpectedBeforeKeyword, keyword) = self.expect(.poundKeyPathKeyword) - // Parse the leading '('. - let (unexpectedBeforeLParen, lparen) = self.expect(.leftParen) - - // Parse the sequence of unqualified-names. - var elements = [RawObjcNamePieceSyntax]() - do { - var flags: DeclNameOptions = [] - var keepGoing: RawTokenSyntax? = nil - var loopProgress = LoopProgressCondition() - repeat { - // Parse the next name. - let (name, args) = self.parseDeclNameRef(flags) - assert(args == nil, "Found arguments but did not pass argument flag?") - - // After the first component, we can start parsing keywords. - flags.formUnion(.keywords) - - // Parse the next period to continue the path. - keepGoing = self.consume(if: .period) - elements.append(RawObjcNamePieceSyntax( - name: name, dot: keepGoing, arena: self.arena)) - } while keepGoing != nil && loopProgress.evaluate(currentToken) - } - - // Parse the closing ')'. - let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen) - return RawObjcKeyPathExprSyntax( - unexpectedBeforeKeyword, - keyPath: keyword, - unexpectedBeforeLParen, - leftParen: lparen, - name: RawObjcNameSyntax(elements: elements, arena: self.arena), - unexpectedBeforeRParen, - rightParen: rparen, arena: self.arena) - } -} - extension Parser { /// Parse a 'super' reference to the superclass instance of a class. /// @@ -1925,48 +1841,6 @@ extension Parser { } } -extension Parser { - /// Parse a #selector expression. - /// - /// Grammar - /// ======= - /// - /// selector-expression → '#selector' '(' expression ) - /// selector-expression → '#selector' '(' 'getter' ':' expression ')' - /// selector-expression → '#selector' '(' 'setter' ':' expression ')' - @_spi(RawSyntax) - public mutating func parseObjectiveCSelectorLiteral() -> RawObjcSelectorExprSyntax { - // Consume '#selector'. - let (unexpectedBeforeSelector, selector) = self.expect(.poundSelectorKeyword) - // Parse the leading '('. - let (unexpectedBeforeLParen, lparen) = self.expect(.leftParen) - - // Parse possible 'getter:' or 'setter:' modifiers, and determine - // the kind of selector we're working with. - let kindAndColon = self.consume( - if: { $0.isContextualKeyword(["getter", "setter"])}, - followedBy: { $0.tokenKind == .colon } - ) - let (kind, colon) = (kindAndColon?.0, kindAndColon?.1) - - // Parse the subexpression. - let subexpr = self.parseExpression() - // Parse the closing ')'. - let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen) - return RawObjcSelectorExprSyntax( - unexpectedBeforeSelector, - poundSelector: selector, - unexpectedBeforeLParen, - leftParen: lparen, - kind: kind, - colon: colon, - name: subexpr, - unexpectedBeforeRParen, - rightParen: rparen, - arena: self.arena) - } -} - extension Parser { /// Parse a closure expression. /// diff --git a/Sources/SwiftParser/Lexer.swift b/Sources/SwiftParser/Lexer.swift index 720b8048d13..a4b414814ea 100644 --- a/Sources/SwiftParser/Lexer.swift +++ b/Sources/SwiftParser/Lexer.swift @@ -1565,8 +1565,6 @@ extension Lexer.Cursor { let kind: RawTokenKind switch literal { - case "keyPath": kind = .poundKeyPathKeyword - case "selector": kind = .poundSelectorKeyword case "assert": kind = .poundAssertKeyword case "sourceLocation": kind = .poundSourceLocationKeyword case "warning": kind = .poundWarningKeyword diff --git a/Sources/SwiftParser/RawTokenKindSubset.swift b/Sources/SwiftParser/RawTokenKindSubset.swift index db6aa5f6158..cb149c01932 100644 --- a/Sources/SwiftParser/RawTokenKindSubset.swift +++ b/Sources/SwiftParser/RawTokenKindSubset.swift @@ -681,11 +681,6 @@ enum ParameterModifier: RawTokenKindSubset { } enum PrimaryExpressionStart: RawTokenKindSubset { - case __column__Keyword - case __dso_handle__Keyword - case __file__Keyword - case __function__Keyword - case __line__Keyword case anyKeyword case capitalSelfKeyword case dollarIdentifier @@ -700,8 +695,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset { case nilKeyword case period case pound - case poundKeyPathKeyword - case poundSelectorKeyword case prefixPeriod case regexLiteral case selfKeyword @@ -712,11 +705,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset { init?(lexeme: Lexer.Lexeme) { switch lexeme.tokenKind { - case .__column__Keyword: self = .__column__Keyword - case .__dso_handle__Keyword: self = .__dso_handle__Keyword - case .__file__Keyword: self = .__file__Keyword - case .__function__Keyword: self = .__function__Keyword - case .__line__Keyword: self = .__line__Keyword case .anyKeyword: self = .anyKeyword case .capitalSelfKeyword: self = .capitalSelfKeyword case .dollarIdentifier: self = .dollarIdentifier @@ -731,8 +719,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset { case .nilKeyword: self = .nilKeyword case .period: self = .period case .pound: self = .pound - case .poundKeyPathKeyword: self = .poundKeyPathKeyword - case .poundSelectorKeyword: self = .poundSelectorKeyword case .prefixPeriod: self = .prefixPeriod case .regexLiteral: self = .regexLiteral case .selfKeyword: self = .selfKeyword @@ -746,11 +732,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset { var rawTokenKind: SwiftSyntax.RawTokenKind { switch self { - case .__column__Keyword: return .__column__Keyword - case .__dso_handle__Keyword: return .__dso_handle__Keyword - case .__file__Keyword: return .__file__Keyword - case .__function__Keyword: return .__function__Keyword - case .__line__Keyword: return .__line__Keyword case .anyKeyword: return .anyKeyword case .capitalSelfKeyword: return .capitalSelfKeyword case .dollarIdentifier: return .dollarIdentifier @@ -765,8 +746,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset { case .nilKeyword: return .nilKeyword case .period: return .period case .pound: return .pound - case .poundKeyPathKeyword: return .poundKeyPathKeyword - case .poundSelectorKeyword: return .poundSelectorKeyword case .prefixPeriod: return .prefixPeriod case .regexLiteral: return .regexLiteral case .selfKeyword: return .selfKeyword diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift index 9441b844ea2..14cdb6ba5b4 100644 --- a/Sources/SwiftParser/TokenPrecedence.swift +++ b/Sources/SwiftParser/TokenPrecedence.swift @@ -108,16 +108,14 @@ public enum TokenPrecedence: Comparable { case // Literals .capitalSelfKeyword, .falseKeyword, .floatingLiteral, .integerLiteral, .nilKeyword, .regexLiteral, .selfKeyword, .stringLiteral, .superKeyword, .trueKeyword, - // Legacy literals - .__column__Keyword, .__dso_handle__Keyword, .__file__Keyword, .__function__Keyword, .__line__Keyword, // Pound literals - .poundAvailableKeyword, .poundColorLiteralKeyword, .poundColumnKeyword, .poundDsohandleKeyword, .poundFileIDKeyword, .poundFileKeyword, .poundFileLiteralKeyword, .poundFilePathKeyword, .poundFunctionKeyword, .poundImageLiteralKeyword, .poundKeyPathKeyword, .poundLineKeyword, .poundSelectorKeyword, .poundSourceLocationKeyword, .poundUnavailableKeyword, .poundHasSymbolKeyword, + .poundAvailableKeyword, .poundSourceLocationKeyword, .poundUnavailableKeyword, .poundHasSymbolKeyword, .pound, // Identifiers .dollarIdentifier, .identifier, // '_' can occur in types to replace a type identifier .wildcardKeyword, - // String segment, string interpolation anchor and pound don't really fit anywhere else - .pound, .stringInterpolationAnchor, .stringSegment: + // String segment and string interpolation anchor don't really fit anywhere else + .stringInterpolationAnchor, .stringSegment: self = .identifierLike // MARK: Expr keyword diff --git a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md index 26638957c53..063d07f6e32 100644 --- a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md @@ -108,7 +108,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- - - - @@ -118,12 +117,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- -- -- -- -- -- - - - @@ -154,12 +147,9 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- -- - - - -- ### Types @@ -220,8 +210,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code. - - - -- -- - - - @@ -311,8 +299,6 @@ 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 83188e32bec..f855c72091c 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 .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: return true + case .unknownExpr, .missingExpr, .inOutExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true default: return false } } @@ -851,56 +851,6 @@ public struct RawInOutExprSyntax: RawExprSyntaxNodeProtocol { } } -@_spi(RawSyntax) -public struct RawPoundColumnExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundColumnExpr - } - - 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( - _ unexpectedBeforePoundColumn: RawUnexpectedNodesSyntax? = nil, - poundColumn: RawTokenSyntax, - _ unexpectedAfterPoundColumn: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .poundColumnExpr, uninitializedCount: 3, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundColumn?.raw - layout[1] = poundColumn.raw - layout[2] = unexpectedAfterPoundColumn?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforePoundColumn: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var poundColumn: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterPoundColumn: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - @_spi(RawSyntax) public struct RawTupleExprElementListSyntax: RawSyntaxNodeProtocol { @@ -1801,7 +1751,7 @@ public struct RawExprListSyntax: RawSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawPoundLineExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawSymbolicReferenceExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -1809,7 +1759,7 @@ public struct RawPoundLineExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundLineExpr + return raw.kind == .symbolicReferenceExpr } public var raw: RawSyntax @@ -1824,34 +1774,44 @@ public struct RawPoundLineExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundLine: RawUnexpectedNodesSyntax? = nil, - poundLine: RawTokenSyntax, - _ unexpectedAfterPoundLine: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, + genericArgumentClause: RawGenericArgumentClauseSyntax?, + _ unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundLineExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .symbolicReferenceExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundLine?.raw - layout[1] = poundLine.raw - layout[2] = unexpectedAfterPoundLine?.raw + layout[0] = unexpectedBeforeIdentifier?.raw + layout[1] = identifier.raw + layout[2] = unexpectedBetweenIdentifierAndGenericArgumentClause?.raw + layout[3] = genericArgumentClause?.raw + layout[4] = unexpectedAfterGenericArgumentClause?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundLine: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundLine: RawTokenSyntax { + public var identifier: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterPoundLine: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndGenericArgumentClause: 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 RawPoundFileExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawPrefixOperatorExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -1859,7 +1819,7 @@ public struct RawPoundFileExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundFileExpr + return raw.kind == .prefixOperatorExpr } public var raw: RawSyntax @@ -1874,34 +1834,44 @@ public struct RawPoundFileExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundFile: RawUnexpectedNodesSyntax? = nil, - poundFile: RawTokenSyntax, - _ unexpectedAfterPoundFile: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? = nil, + operatorToken: RawTokenSyntax?, + _ unexpectedBetweenOperatorTokenAndPostfixExpression: RawUnexpectedNodesSyntax? = nil, + postfixExpression: RawExprSyntax, + _ unexpectedAfterPostfixExpression: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundFileExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .prefixOperatorExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundFile?.raw - layout[1] = poundFile.raw - layout[2] = unexpectedAfterPoundFile?.raw + layout[0] = unexpectedBeforeOperatorToken?.raw + layout[1] = operatorToken?.raw + layout[2] = unexpectedBetweenOperatorTokenAndPostfixExpression?.raw + layout[3] = postfixExpression.raw + layout[4] = unexpectedAfterPostfixExpression?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundFile: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundFile: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var operatorToken: RawTokenSyntax? { + layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterPoundFile: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenOperatorTokenAndPostfixExpression: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var postfixExpression: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! + } + public var unexpectedAfterPostfixExpression: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawPoundFileIDExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawBinaryOperatorExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -1909,7 +1879,7 @@ public struct RawPoundFileIDExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundFileIDExpr + return raw.kind == .binaryOperatorExpr } public var raw: RawSyntax @@ -1924,34 +1894,34 @@ public struct RawPoundFileIDExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundFileID: RawUnexpectedNodesSyntax? = nil, - poundFileID: RawTokenSyntax, - _ unexpectedAfterPoundFileID: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? = nil, + operatorToken: RawTokenSyntax, + _ unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundFileIDExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .binaryOperatorExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundFileID?.raw - layout[1] = poundFileID.raw - layout[2] = unexpectedAfterPoundFileID?.raw + layout[0] = unexpectedBeforeOperatorToken?.raw + layout[1] = operatorToken.raw + layout[2] = unexpectedAfterOperatorToken?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundFileID: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundFileID: RawTokenSyntax { + public var operatorToken: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterPoundFileID: RawUnexpectedNodesSyntax? { + public var unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawPoundFilePathExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawArrowExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -1959,7 +1929,7 @@ public struct RawPoundFilePathExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundFilePathExpr + return raw.kind == .arrowExpr } public var raw: RawSyntax @@ -1974,34 +1944,54 @@ public struct RawPoundFilePathExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundFilePath: RawUnexpectedNodesSyntax? = nil, - poundFilePath: RawTokenSyntax, - _ unexpectedAfterPoundFilePath: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeAsyncKeyword: RawUnexpectedNodesSyntax? = nil, + asyncKeyword: RawTokenSyntax?, + _ unexpectedBetweenAsyncKeywordAndThrowsToken: RawUnexpectedNodesSyntax? = nil, + throwsToken: RawTokenSyntax?, + _ unexpectedBetweenThrowsTokenAndArrowToken: RawUnexpectedNodesSyntax? = nil, + arrowToken: RawTokenSyntax, + _ unexpectedAfterArrowToken: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundFilePathExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .arrowExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundFilePath?.raw - layout[1] = poundFilePath.raw - layout[2] = unexpectedAfterPoundFilePath?.raw + layout[0] = unexpectedBeforeAsyncKeyword?.raw + layout[1] = asyncKeyword?.raw + layout[2] = unexpectedBetweenAsyncKeywordAndThrowsToken?.raw + layout[3] = throwsToken?.raw + layout[4] = unexpectedBetweenThrowsTokenAndArrowToken?.raw + layout[5] = arrowToken.raw + layout[6] = unexpectedAfterArrowToken?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundFilePath: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeAsyncKeyword: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundFilePath: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var asyncKeyword: RawTokenSyntax? { + layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterPoundFilePath: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncKeywordAndThrowsToken: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var throwsToken: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) + } + public var unexpectedBetweenThrowsTokenAndArrowToken: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var arrowToken: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedAfterArrowToken: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawPoundFunctionExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawInfixOperatorExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -2009,7 +1999,7 @@ public struct RawPoundFunctionExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundFunctionExpr + return raw.kind == .infixOperatorExpr } public var raw: RawSyntax @@ -2024,34 +2014,54 @@ public struct RawPoundFunctionExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundFunction: RawUnexpectedNodesSyntax? = nil, - poundFunction: RawTokenSyntax, - _ unexpectedAfterPoundFunction: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftOperand: RawUnexpectedNodesSyntax? = nil, + leftOperand: RawExprSyntax, + _ unexpectedBetweenLeftOperandAndOperatorOperand: RawUnexpectedNodesSyntax? = nil, + operatorOperand: RawExprSyntax, + _ unexpectedBetweenOperatorOperandAndRightOperand: RawUnexpectedNodesSyntax? = nil, + rightOperand: RawExprSyntax, + _ unexpectedAfterRightOperand: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundFunctionExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .infixOperatorExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundFunction?.raw - layout[1] = poundFunction.raw - layout[2] = unexpectedAfterPoundFunction?.raw + layout[0] = unexpectedBeforeLeftOperand?.raw + layout[1] = leftOperand.raw + layout[2] = unexpectedBetweenLeftOperandAndOperatorOperand?.raw + layout[3] = operatorOperand.raw + layout[4] = unexpectedBetweenOperatorOperandAndRightOperand?.raw + layout[5] = rightOperand.raw + layout[6] = unexpectedAfterRightOperand?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundFunction: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftOperand: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundFunction: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var leftOperand: RawExprSyntax { + layoutView.children[1].map(RawExprSyntax.init(raw:))! } - public var unexpectedAfterPoundFunction: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftOperandAndOperatorOperand: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } + public var operatorOperand: RawExprSyntax { + layoutView.children[3].map(RawExprSyntax.init(raw:))! + } + public var unexpectedBetweenOperatorOperandAndRightOperand: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var rightOperand: RawExprSyntax { + layoutView.children[5].map(RawExprSyntax.init(raw:))! + } + public var unexpectedAfterRightOperand: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) -public struct RawPoundDsohandleExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawFloatLiteralExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -2059,7 +2069,7 @@ public struct RawPoundDsohandleExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .poundDsohandleExpr + return raw.kind == .floatLiteralExpr } public var raw: RawSyntax @@ -2074,34 +2084,34 @@ public struct RawPoundDsohandleExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundDsohandle: RawUnexpectedNodesSyntax? = nil, - poundDsohandle: RawTokenSyntax, - _ unexpectedAfterPoundDsohandle: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeFloatingDigits: RawUnexpectedNodesSyntax? = nil, + floatingDigits: RawTokenSyntax, + _ unexpectedAfterFloatingDigits: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundDsohandleExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .floatLiteralExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundDsohandle?.raw - layout[1] = poundDsohandle.raw - layout[2] = unexpectedAfterPoundDsohandle?.raw + layout[0] = unexpectedBeforeFloatingDigits?.raw + layout[1] = floatingDigits.raw + layout[2] = unexpectedAfterFloatingDigits?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundDsohandle: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeFloatingDigits: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundDsohandle: RawTokenSyntax { + public var floatingDigits: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedAfterPoundDsohandle: RawUnexpectedNodesSyntax? { + public var unexpectedAfterFloatingDigits: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawSymbolicReferenceExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawTupleExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -2109,7 +2119,7 @@ public struct RawSymbolicReferenceExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .symbolicReferenceExpr + return raw.kind == .tupleExpr } public var raw: RawSyntax @@ -2124,44 +2134,54 @@ public struct RawSymbolicReferenceExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, - genericArgumentClause: RawGenericArgumentClauseSyntax?, - _ unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndElementList: RawUnexpectedNodesSyntax? = nil, + elementList: RawTupleExprElementListSyntax, + _ unexpectedBetweenElementListAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .symbolicReferenceExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .tupleExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeIdentifier?.raw - layout[1] = identifier.raw - layout[2] = unexpectedBetweenIdentifierAndGenericArgumentClause?.raw - layout[3] = genericArgumentClause?.raw - layout[4] = unexpectedAfterGenericArgumentClause?.raw + layout[0] = unexpectedBeforeLeftParen?.raw + layout[1] = leftParen.raw + layout[2] = unexpectedBetweenLeftParenAndElementList?.raw + layout[3] = elementList.raw + layout[4] = unexpectedBetweenElementListAndRightParen?.raw + layout[5] = rightParen.raw + layout[6] = unexpectedAfterRightParen?.raw } self.init(raw: raw) } - public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var identifier: RawTokenSyntax { + public var leftParen: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenIdentifierAndGenericArgumentClause: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndElementList: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var genericArgumentClause: RawGenericArgumentClauseSyntax? { - layoutView.children[3].map(RawGenericArgumentClauseSyntax.init(raw:)) + public var elementList: RawTupleExprElementListSyntax { + layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw:))! } - public var unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? { + 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 RawPrefixOperatorExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawArrayExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -2169,7 +2189,7 @@ public struct RawPrefixOperatorExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .prefixOperatorExpr + return raw.kind == .arrayExpr } public var raw: RawSyntax @@ -2184,400 +2204,30 @@ public struct RawPrefixOperatorExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? = nil, - operatorToken: RawTokenSyntax?, - _ unexpectedBetweenOperatorTokenAndPostfixExpression: RawUnexpectedNodesSyntax? = nil, - postfixExpression: RawExprSyntax, - _ unexpectedAfterPostfixExpression: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? = nil, + leftSquare: RawTokenSyntax, + _ unexpectedBetweenLeftSquareAndElements: RawUnexpectedNodesSyntax? = nil, + elements: RawArrayElementListSyntax, + _ unexpectedBetweenElementsAndRightSquare: RawUnexpectedNodesSyntax? = nil, + rightSquare: RawTokenSyntax, + _ unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .prefixOperatorExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .arrayExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeOperatorToken?.raw - layout[1] = operatorToken?.raw - layout[2] = unexpectedBetweenOperatorTokenAndPostfixExpression?.raw - layout[3] = postfixExpression.raw - layout[4] = unexpectedAfterPostfixExpression?.raw + layout[0] = unexpectedBeforeLeftSquare?.raw + layout[1] = leftSquare.raw + layout[2] = unexpectedBetweenLeftSquareAndElements?.raw + layout[3] = elements.raw + layout[4] = unexpectedBetweenElementsAndRightSquare?.raw + layout[5] = rightSquare.raw + layout[6] = unexpectedAfterRightSquare?.raw } self.init(raw: raw) } - public var unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var operatorToken: RawTokenSyntax? { - layoutView.children[1].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenOperatorTokenAndPostfixExpression: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var postfixExpression: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! - } - public var unexpectedAfterPostfixExpression: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawBinaryOperatorExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .binaryOperatorExpr - } - - 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( - _ unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? = nil, - operatorToken: RawTokenSyntax, - _ unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .binaryOperatorExpr, uninitializedCount: 3, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeOperatorToken?.raw - layout[1] = operatorToken.raw - layout[2] = unexpectedAfterOperatorToken?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeOperatorToken: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var operatorToken: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterOperatorToken: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawArrowExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .arrowExpr - } - - 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( - _ unexpectedBeforeAsyncKeyword: RawUnexpectedNodesSyntax? = nil, - asyncKeyword: RawTokenSyntax?, - _ unexpectedBetweenAsyncKeywordAndThrowsToken: RawUnexpectedNodesSyntax? = nil, - throwsToken: RawTokenSyntax?, - _ unexpectedBetweenThrowsTokenAndArrowToken: RawUnexpectedNodesSyntax? = nil, - arrowToken: RawTokenSyntax, - _ unexpectedAfterArrowToken: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .arrowExpr, uninitializedCount: 7, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeAsyncKeyword?.raw - layout[1] = asyncKeyword?.raw - layout[2] = unexpectedBetweenAsyncKeywordAndThrowsToken?.raw - layout[3] = throwsToken?.raw - layout[4] = unexpectedBetweenThrowsTokenAndArrowToken?.raw - layout[5] = arrowToken.raw - layout[6] = unexpectedAfterArrowToken?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeAsyncKeyword: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var asyncKeyword: RawTokenSyntax? { - layoutView.children[1].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenAsyncKeywordAndThrowsToken: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var throwsToken: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenThrowsTokenAndArrowToken: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var arrowToken: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterArrowToken: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawInfixOperatorExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .infixOperatorExpr - } - - 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( - _ unexpectedBeforeLeftOperand: RawUnexpectedNodesSyntax? = nil, - leftOperand: RawExprSyntax, - _ unexpectedBetweenLeftOperandAndOperatorOperand: RawUnexpectedNodesSyntax? = nil, - operatorOperand: RawExprSyntax, - _ unexpectedBetweenOperatorOperandAndRightOperand: RawUnexpectedNodesSyntax? = nil, - rightOperand: RawExprSyntax, - _ unexpectedAfterRightOperand: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .infixOperatorExpr, uninitializedCount: 7, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftOperand?.raw - layout[1] = leftOperand.raw - layout[2] = unexpectedBetweenLeftOperandAndOperatorOperand?.raw - layout[3] = operatorOperand.raw - layout[4] = unexpectedBetweenOperatorOperandAndRightOperand?.raw - layout[5] = rightOperand.raw - layout[6] = unexpectedAfterRightOperand?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeLeftOperand: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftOperand: RawExprSyntax { - layoutView.children[1].map(RawExprSyntax.init(raw:))! - } - public var unexpectedBetweenLeftOperandAndOperatorOperand: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var operatorOperand: RawExprSyntax { - layoutView.children[3].map(RawExprSyntax.init(raw:))! - } - public var unexpectedBetweenOperatorOperandAndRightOperand: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var rightOperand: RawExprSyntax { - layoutView.children[5].map(RawExprSyntax.init(raw:))! - } - public var unexpectedAfterRightOperand: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawFloatLiteralExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .floatLiteralExpr - } - - 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( - _ unexpectedBeforeFloatingDigits: RawUnexpectedNodesSyntax? = nil, - floatingDigits: RawTokenSyntax, - _ unexpectedAfterFloatingDigits: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .floatLiteralExpr, uninitializedCount: 3, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeFloatingDigits?.raw - layout[1] = floatingDigits.raw - layout[2] = unexpectedAfterFloatingDigits?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeFloatingDigits: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var floatingDigits: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterFloatingDigits: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawTupleExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .tupleExpr - } - - 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, - _ unexpectedBetweenLeftParenAndElementList: RawUnexpectedNodesSyntax? = nil, - elementList: RawTupleExprElementListSyntax, - _ unexpectedBetweenElementListAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .tupleExpr, uninitializedCount: 7, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftParen?.raw - layout[1] = leftParen.raw - layout[2] = unexpectedBetweenLeftParenAndElementList?.raw - layout[3] = elementList.raw - layout[4] = unexpectedBetweenElementListAndRightParen?.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 unexpectedBetweenLeftParenAndElementList: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var elementList: RawTupleExprElementListSyntax { - layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw:))! - } - 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 RawArrayExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .arrayExpr - } - - 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( - _ unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? = nil, - leftSquare: RawTokenSyntax, - _ unexpectedBetweenLeftSquareAndElements: RawUnexpectedNodesSyntax? = nil, - elements: RawArrayElementListSyntax, - _ unexpectedBetweenElementsAndRightSquare: RawUnexpectedNodesSyntax? = nil, - rightSquare: RawTokenSyntax, - _ unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .arrayExpr, uninitializedCount: 7, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftSquare?.raw - layout[1] = leftSquare.raw - layout[2] = unexpectedBetweenLeftSquareAndElements?.raw - layout[3] = elements.raw - layout[4] = unexpectedBetweenElementsAndRightSquare?.raw - layout[5] = rightSquare.raw - layout[6] = unexpectedAfterRightSquare?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } public var leftSquare: RawTokenSyntax { @@ -5105,266 +4755,16 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { } 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 == .keyPathComponent - } - - 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( - _ unexpectedBeforePeriod: RawUnexpectedNodesSyntax? = nil, - period: RawTokenSyntax?, - _ unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? = nil, - component: Component, - _ unexpectedAfterComponent: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .keyPathComponent, 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 - } - self.init(raw: raw) - } - - public var unexpectedBeforePeriod: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var period: RawTokenSyntax? { - layoutView.children[1].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var component: RawSyntax { - layoutView.children[3]! - } - public var unexpectedAfterComponent: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathPropertyComponent - } - - 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( - _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? = nil, - declNameArguments: RawDeclNameArgumentsSyntax?, - _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, - genericArgumentClause: RawGenericArgumentClauseSyntax?, - _ unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .keyPathPropertyComponent, uninitializedCount: 7, 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 - } - self.init(raw: raw) - } - - public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var identifier: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenIdentifierAndDeclNameArguments: 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 unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } -} - -@_spi(RawSyntax) -public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathSubscriptComponent - } - - 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( - _ unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? = nil, - leftBracket: RawTokenSyntax, - _ unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? = nil, - argumentList: RawTupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? = nil, - rightBracket: RawTokenSyntax, - _ unexpectedAfterRightBracket: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .keyPathSubscriptComponent, uninitializedCount: 7, 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 - } - self.init(raw: raw) - } - - public var unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftBracket: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftBracketAndArgumentList: 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 { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .keyPathOptionalComponent - } - - 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( - _ unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, - questionOrExclamationMark: RawTokenSyntax, - _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .keyPathOptionalComponent, uninitializedCount: 3, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeQuestionOrExclamationMark?.raw - layout[1] = questionOrExclamationMark.raw - layout[2] = unexpectedAfterQuestionOrExclamationMark?.raw + return + } + if let node = RawKeyPathOptionalComponentSyntax(other) { + self = .optional(node) + return + } + return nil } - self.init(raw: raw) - } - - public var unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var questionOrExclamationMark: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } -} -@_spi(RawSyntax) -public struct RawObjcNamePieceSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5372,7 +4772,7 @@ public struct RawObjcNamePieceSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .objcNamePiece + return raw.kind == .keyPathComponent } public var raw: RawSyntax @@ -5387,44 +4787,44 @@ public struct RawObjcNamePieceSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeName: RawUnexpectedNodesSyntax? = nil, - name: RawTokenSyntax, - _ unexpectedBetweenNameAndDot: RawUnexpectedNodesSyntax? = nil, - dot: RawTokenSyntax?, - _ unexpectedAfterDot: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforePeriod: RawUnexpectedNodesSyntax? = nil, + period: RawTokenSyntax?, + _ unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? = nil, + component: Component, + _ unexpectedAfterComponent: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .objcNamePiece, uninitializedCount: 5, arena: arena) { layout in + kind: .keyPathComponent, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeName?.raw - layout[1] = name.raw - layout[2] = unexpectedBetweenNameAndDot?.raw - layout[3] = dot?.raw - layout[4] = unexpectedAfterDot?.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 unexpectedBeforeName: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePeriod: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var name: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! + public var period: RawTokenSyntax? { + layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenNameAndDot: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenPeriodAndComponent: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var dot: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var component: RawSyntax { + layoutView.children[3]! } - public var unexpectedAfterDot: RawUnexpectedNodesSyntax? { + public var unexpectedAfterComponent: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawObjcNameSyntax: RawSyntaxNodeProtocol { +public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5432,7 +4832,7 @@ public struct RawObjcNameSyntax: RawSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .objcName + return raw.kind == .keyPathPropertyComponent } public var raw: RawSyntax @@ -5446,25 +4846,55 @@ public struct RawObjcNameSyntax: RawSyntaxNodeProtocol { self.init(raw: other.raw) } - public init(elements: [RawObjcNamePieceSyntax], arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, + identifier: RawTokenSyntax, + _ unexpectedBetweenIdentifierAndDeclNameArguments: RawUnexpectedNodesSyntax? = nil, + declNameArguments: RawDeclNameArgumentsSyntax?, + _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, + genericArgumentClause: RawGenericArgumentClauseSyntax?, + _ unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .objcName, 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: .keyPathPropertyComponent, uninitializedCount: 7, 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 } self.init(raw: raw) } - public var elements: [RawObjcNamePieceSyntax] { - layoutView.children.map { RawObjcNamePieceSyntax(raw: $0!) } + public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + public var identifier: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + public var unexpectedBetweenIdentifierAndDeclNameArguments: 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 unexpectedAfterGenericArgumentClause: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } @_spi(RawSyntax) -public struct RawObjcKeyPathExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5472,7 +4902,7 @@ public struct RawObjcKeyPathExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .objcKeyPathExpr + return raw.kind == .keyPathSubscriptComponent } public var raw: RawSyntax @@ -5487,64 +4917,54 @@ public struct RawObjcKeyPathExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforeKeyPath: RawUnexpectedNodesSyntax? = nil, - keyPath: RawTokenSyntax, - _ unexpectedBetweenKeyPathAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndName: RawUnexpectedNodesSyntax? = nil, - name: RawObjcNameSyntax, - _ unexpectedBetweenNameAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? = nil, + leftBracket: RawTokenSyntax, + _ unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? = nil, + argumentList: RawTupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? = nil, + rightBracket: RawTokenSyntax, + _ unexpectedAfterRightBracket: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .objcKeyPathExpr, uninitializedCount: 9, arena: arena) { layout in + kind: .keyPathSubscriptComponent, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeKeyPath?.raw - layout[1] = keyPath.raw - layout[2] = unexpectedBetweenKeyPathAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndName?.raw - layout[5] = name.raw - layout[6] = unexpectedBetweenNameAndRightParen?.raw - layout[7] = rightParen.raw - layout[8] = unexpectedAfterRightParen?.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 unexpectedBeforeKeyPath: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBracket: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var keyPath: RawTokenSyntax { + public var leftBracket: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenKeyPathAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBracketAndArgumentList: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! + public var argumentList: RawTupleExprElementListSyntax { + layoutView.children[3].map(RawTupleExprElementListSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndName: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentListAndRightBracket: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var name: RawObjcNameSyntax { - layoutView.children[5].map(RawObjcNameSyntax.init(raw:))! + public var rightBracket: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenNameAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedAfterRightBracket: 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 RawObjcSelectorExprSyntax: RawExprSyntaxNodeProtocol { +public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { @@ -5552,7 +4972,7 @@ public struct RawObjcSelectorExprSyntax: RawExprSyntaxNodeProtocol { } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .objcSelectorExpr + return raw.kind == .keyPathOptionalComponent } public var raw: RawSyntax @@ -5567,80 +4987,30 @@ public struct RawObjcSelectorExprSyntax: RawExprSyntaxNodeProtocol { } public init( - _ unexpectedBeforePoundSelector: RawUnexpectedNodesSyntax? = nil, - poundSelector: RawTokenSyntax, - _ unexpectedBetweenPoundSelectorAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndKind: RawUnexpectedNodesSyntax? = nil, - kind: RawTokenSyntax?, - _ unexpectedBetweenKindAndColon: RawUnexpectedNodesSyntax? = nil, - colon: RawTokenSyntax?, - _ unexpectedBetweenColonAndName: RawUnexpectedNodesSyntax? = nil, - name: RawExprSyntax, - _ unexpectedBetweenNameAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, + questionOrExclamationMark: RawTokenSyntax, + _ unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .objcSelectorExpr, uninitializedCount: 13, arena: arena) { layout in + kind: .keyPathOptionalComponent, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforePoundSelector?.raw - layout[1] = poundSelector.raw - layout[2] = unexpectedBetweenPoundSelectorAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndKind?.raw - layout[5] = kind?.raw - layout[6] = unexpectedBetweenKindAndColon?.raw - layout[7] = colon?.raw - layout[8] = unexpectedBetweenColonAndName?.raw - layout[9] = name.raw - layout[10] = unexpectedBetweenNameAndRightParen?.raw - layout[11] = rightParen.raw - layout[12] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforeQuestionOrExclamationMark?.raw + layout[1] = questionOrExclamationMark.raw + layout[2] = unexpectedAfterQuestionOrExclamationMark?.raw } self.init(raw: raw) } - public var unexpectedBeforePoundSelector: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var poundSelector: RawTokenSyntax { + public var questionOrExclamationMark: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenPoundSelectorAndLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedAfterQuestionOrExclamationMark: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftParenAndKind: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var kind: RawTokenSyntax? { - layoutView.children[5].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenKindAndColon: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var colon: RawTokenSyntax? { - layoutView.children[7].map(RawTokenSyntax.init(raw:)) - } - public var unexpectedBetweenColonAndName: RawUnexpectedNodesSyntax? { - layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var name: RawExprSyntax { - layoutView.children[9].map(RawExprSyntax.init(raw:))! - } - public var unexpectedBetweenNameAndRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var rightParen: RawTokenSyntax { - layoutView.children[11].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { - layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) @@ -5873,86 +5243,6 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { } } -@_spi(RawSyntax) -public struct RawObjectLiteralExprSyntax: RawExprSyntaxNodeProtocol { - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - return raw.layoutView! - } - - public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .objectLiteralExpr - } - - 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( - _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil, - identifier: RawTokenSyntax, - _ unexpectedBetweenIdentifierAndLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, - _ unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? = nil, - arguments: RawTupleExprElementListSyntax, - _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, - _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, - arena: __shared SyntaxArena - ) { - let raw = RawSyntax.makeLayout( - kind: .objectLiteralExpr, uninitializedCount: 9, arena: arena) { layout in - layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeIdentifier?.raw - layout[1] = identifier.raw - layout[2] = unexpectedBetweenIdentifierAndLeftParen?.raw - layout[3] = leftParen.raw - layout[4] = unexpectedBetweenLeftParenAndArguments?.raw - layout[5] = arguments.raw - layout[6] = unexpectedBetweenArgumentsAndRightParen?.raw - layout[7] = rightParen.raw - layout[8] = unexpectedAfterRightParen?.raw - } - self.init(raw: raw) - } - - public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? { - layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var identifier: RawTokenSyntax { - layoutView.children[1].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenIdentifierAndLeftParen: RawUnexpectedNodesSyntax? { - layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var leftParen: RawTokenSyntax { - layoutView.children[3].map(RawTokenSyntax.init(raw:))! - } - public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? { - layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) - } - public var arguments: RawTupleExprElementListSyntax { - layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))! - } - public var unexpectedBetweenArgumentsAndRightParen: 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 RawYieldExprListSyntax: RawSyntaxNodeProtocol { diff --git a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift index b1805e63dc7..315cf2419fb 100644 --- a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift @@ -166,12 +166,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 .poundColumnExpr: - assert(layout.count == 3) - 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)) - break case .tupleExprElementList: for (index, element) in layout.enumerated() { assertNoError(kind, index, verify(element, as: RawTupleExprElementSyntax.self)) @@ -287,42 +281,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, index, verify(element, as: RawExprSyntax.self)) } break - case .poundLineExpr: - assert(layout.count == 3) - 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)) - break - case .poundFileExpr: - assert(layout.count == 3) - 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)) - break - case .poundFileIDExpr: - assert(layout.count == 3) - 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)) - break - case .poundFilePathExpr: - assert(layout.count == 3) - 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)) - break - case .poundFunctionExpr: - assert(layout.count == 3) - 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)) - break - case .poundDsohandleExpr: - assert(layout.count == 3) - 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)) - break case .symbolicReferenceExpr: assert(layout.count == 5) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -779,47 +737,6 @@ 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 .objcNamePiece: - 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 .objcName: - for (index, element) in layout.enumerated() { - assertNoError(kind, index, verify(element, as: RawObjcNamePieceSyntax.self)) - } - break - case .objcKeyPathExpr: - assert(layout.count == 9) - 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)) - assertNoError(kind, 5, verify(layout[5], as: RawObjcNameSyntax.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)) - break - case .objcSelectorExpr: - assert(layout.count == 13) - 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)) - 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: RawTokenSyntax?.self)) - assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 9, verify(layout[9], as: RawExprSyntax.self)) - assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 11, verify(layout[11], as: RawTokenSyntax.self)) - assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) - break case .macroExpansionExpr: assert(layout.count == 17) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -854,18 +771,6 @@ 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 .objectLiteralExpr: - assert(layout.count == 9) - 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)) - assertNoError(kind, 5, verify(layout[5], as: RawTupleExprElementListSyntax.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)) - break case .yieldExprList: for (index, element) in layout.enumerated() { assertNoError(kind, index, verify(element, as: RawYieldExprListElementSyntax.self)) diff --git a/Sources/SwiftSyntax/gyb_generated/Misc.swift b/Sources/SwiftSyntax/gyb_generated/Misc.swift index 5290359a2a4..01248cd0f8e 100644 --- a/Sources/SwiftSyntax/gyb_generated/Misc.swift +++ b/Sources/SwiftSyntax/gyb_generated/Misc.swift @@ -33,7 +33,6 @@ extension Syntax { .node(CodeBlockSyntax.self), .node(UnexpectedNodesSyntax.self), .node(InOutExprSyntax.self), - .node(PoundColumnExprSyntax.self), .node(TupleExprElementListSyntax.self), .node(ArrayElementListSyntax.self), .node(DictionaryElementListSyntax.self), @@ -51,12 +50,6 @@ extension Syntax { .node(AssignmentExprSyntax.self), .node(SequenceExprSyntax.self), .node(ExprListSyntax.self), - .node(PoundLineExprSyntax.self), - .node(PoundFileExprSyntax.self), - .node(PoundFileIDExprSyntax.self), - .node(PoundFilePathExprSyntax.self), - .node(PoundFunctionExprSyntax.self), - .node(PoundDsohandleExprSyntax.self), .node(SymbolicReferenceExprSyntax.self), .node(PrefixOperatorExprSyntax.self), .node(BinaryOperatorExprSyntax.self), @@ -105,14 +98,9 @@ extension Syntax { .node(KeyPathPropertyComponentSyntax.self), .node(KeyPathSubscriptComponentSyntax.self), .node(KeyPathOptionalComponentSyntax.self), - .node(ObjcNamePieceSyntax.self), - .node(ObjcNameSyntax.self), - .node(ObjcKeyPathExprSyntax.self), - .node(ObjcSelectorExprSyntax.self), .node(MacroExpansionExprSyntax.self), .node(PostfixIfConfigExprSyntax.self), .node(EditorPlaceholderExprSyntax.self), - .node(ObjectLiteralExprSyntax.self), .node(YieldExprListSyntax.self), .node(YieldExprListElementSyntax.self), .node(TypeInitializerClauseSyntax.self), @@ -320,7 +308,6 @@ extension SyntaxKind { case .codeBlock: return CodeBlockSyntax.self case .unexpectedNodes: return UnexpectedNodesSyntax.self case .inOutExpr: return InOutExprSyntax.self - case .poundColumnExpr: return PoundColumnExprSyntax.self case .tupleExprElementList: return TupleExprElementListSyntax.self case .arrayElementList: return ArrayElementListSyntax.self case .dictionaryElementList: return DictionaryElementListSyntax.self @@ -338,12 +325,6 @@ extension SyntaxKind { case .assignmentExpr: return AssignmentExprSyntax.self case .sequenceExpr: return SequenceExprSyntax.self case .exprList: return ExprListSyntax.self - case .poundLineExpr: return PoundLineExprSyntax.self - case .poundFileExpr: return PoundFileExprSyntax.self - case .poundFileIDExpr: return PoundFileIDExprSyntax.self - case .poundFilePathExpr: return PoundFilePathExprSyntax.self - case .poundFunctionExpr: return PoundFunctionExprSyntax.self - case .poundDsohandleExpr: return PoundDsohandleExprSyntax.self case .symbolicReferenceExpr: return SymbolicReferenceExprSyntax.self case .prefixOperatorExpr: return PrefixOperatorExprSyntax.self case .binaryOperatorExpr: return BinaryOperatorExprSyntax.self @@ -392,14 +373,9 @@ extension SyntaxKind { case .keyPathPropertyComponent: return KeyPathPropertyComponentSyntax.self case .keyPathSubscriptComponent: return KeyPathSubscriptComponentSyntax.self case .keyPathOptionalComponent: return KeyPathOptionalComponentSyntax.self - case .objcNamePiece: return ObjcNamePieceSyntax.self - case .objcName: return ObjcNameSyntax.self - case .objcKeyPathExpr: return ObjcKeyPathExprSyntax.self - case .objcSelectorExpr: return ObjcSelectorExprSyntax.self case .macroExpansionExpr: return MacroExpansionExprSyntax.self case .postfixIfConfigExpr: return PostfixIfConfigExprSyntax.self case .editorPlaceholderExpr: return EditorPlaceholderExprSyntax.self - case .objectLiteralExpr: return ObjectLiteralExprSyntax.self case .yieldExprList: return YieldExprListSyntax.self case .yieldExprListElement: return YieldExprListElementSyntax.self case .typeInitializerClause: return TypeInitializerClauseSyntax.self @@ -623,8 +599,6 @@ extension SyntaxKind { return nil case .inOutExpr: return "inout expression" - case .poundColumnExpr: - return nil case .tupleExprElementList: return nil case .arrayElementList: @@ -659,18 +633,6 @@ extension SyntaxKind { return nil case .exprList: return nil - case .poundLineExpr: - return nil - case .poundFileExpr: - return nil - case .poundFileIDExpr: - return nil - case .poundFilePathExpr: - return nil - case .poundFunctionExpr: - return nil - case .poundDsohandleExpr: - return nil case .symbolicReferenceExpr: return nil case .prefixOperatorExpr: @@ -767,22 +729,12 @@ extension SyntaxKind { return "key path subscript component" case .keyPathOptionalComponent: return "key path optional component" - case .objcNamePiece: - return nil - case .objcName: - return nil - case .objcKeyPathExpr: - return "'#keyPath' expression" - case .objcSelectorExpr: - return "'#selector' expression" case .macroExpansionExpr: return "pound literal expression" case .postfixIfConfigExpr: return nil case .editorPlaceholderExpr: return "editor placeholder" - case .objectLiteralExpr: - return "object literal" case .yieldExprList: return "yield list" case .yieldExprListElement: diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift index 52eced46f4f..0f133698a6d 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift @@ -173,13 +173,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor { override open func visitPost(_ node: InOutExprSyntax) { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: PoundColumnExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: PoundColumnExprSyntax) { - visitAnyPost(node._syntaxNode) - } override open func visit(_ node: TupleExprElementListSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -299,48 +292,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor { override open func visitPost(_ node: ExprListSyntax) { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: PoundLineExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: PoundLineExprSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: PoundFileExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: PoundFileExprSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: PoundFileIDExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: PoundFileIDExprSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: PoundFilePathExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: PoundFilePathExprSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: PoundFunctionExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: PoundFunctionExprSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: PoundDsohandleExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: PoundDsohandleExprSyntax) { - visitAnyPost(node._syntaxNode) - } override open func visit(_ node: SymbolicReferenceExprSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -677,34 +628,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor { override open func visitPost(_ node: KeyPathOptionalComponentSyntax) { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: ObjcNamePieceSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: ObjcNamePieceSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: ObjcNameSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: ObjcNameSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: ObjcKeyPathExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: ObjcKeyPathExprSyntax) { - visitAnyPost(node._syntaxNode) - } - override open func visit(_ node: ObjcSelectorExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: ObjcSelectorExprSyntax) { - visitAnyPost(node._syntaxNode) - } override open func visit(_ node: MacroExpansionExprSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } @@ -726,13 +649,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor { override open func visitPost(_ node: EditorPlaceholderExprSyntax) { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: ObjectLiteralExprSyntax) -> SyntaxVisitorContinueKind { - return visitAny(node._syntaxNode) - } - - override open func visitPost(_ node: ObjectLiteralExprSyntax) { - visitAnyPost(node._syntaxNode) - } override open func visit(_ node: YieldExprListSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift index 64ca58db150..8128ebebfee 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift @@ -216,7 +216,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public init?(_ node: S) { switch node.raw.kind { - case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: + case .unknownExpr, .missingExpr, .inOutExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: self._syntaxNode = node._syntaxNode default: return nil @@ -230,7 +230,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { // Assert that the kind of the given data matches in debug builds. #if DEBUG switch data.raw.kind { - case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: + case .unknownExpr, .missingExpr, .inOutExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: break default: fatalError("Unable to create ExprSyntax from \(data.raw.kind)") @@ -271,7 +271,6 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { .node(UnknownExprSyntax.self), .node(MissingExprSyntax.self), .node(InOutExprSyntax.self), - .node(PoundColumnExprSyntax.self), .node(TryExprSyntax.self), .node(AwaitExprSyntax.self), .node(MoveExprSyntax.self), @@ -281,12 +280,6 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { .node(DiscardAssignmentExprSyntax.self), .node(AssignmentExprSyntax.self), .node(SequenceExprSyntax.self), - .node(PoundLineExprSyntax.self), - .node(PoundFileExprSyntax.self), - .node(PoundFileIDExprSyntax.self), - .node(PoundFilePathExprSyntax.self), - .node(PoundFunctionExprSyntax.self), - .node(PoundDsohandleExprSyntax.self), .node(SymbolicReferenceExprSyntax.self), .node(PrefixOperatorExprSyntax.self), .node(BinaryOperatorExprSyntax.self), @@ -317,12 +310,9 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { .node(StringLiteralExprSyntax.self), .node(RegexLiteralExprSyntax.self), .node(KeyPathExprSyntax.self), - .node(ObjcKeyPathExprSyntax.self), - .node(ObjcSelectorExprSyntax.self), .node(MacroExpansionExprSyntax.self), .node(PostfixIfConfigExprSyntax.self), .node(EditorPlaceholderExprSyntax.self), - .node(ObjectLiteralExprSyntax.self), ]) } diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift index d35acf66194..67faf539b47 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift @@ -3083,258 +3083,6 @@ extension KeyPathComponentListSyntax: BidirectionalCollection { } } -/// `ObjcNameSyntax` represents a collection of one or more -/// `ObjcNamePieceSyntax` nodes. ObjcNameSyntax behaves -/// as a regular Swift collection, and has accessors that return new -/// versions of the collection with different children. -public struct ObjcNameSyntax: SyntaxCollection, SyntaxHashable { - public typealias Element = ObjcNamePieceSyntax - - public let _syntaxNode: Syntax - - @_spi(RawSyntax) - public var layoutView: RawSyntaxLayoutView { - data.raw.layoutView! - } - - public init?(_ node: S) { - guard node.raw.kind == .objcName else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a Syntax node from the provided root and data. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .objcName) - self._syntaxNode = Syntax(data) - } - - public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcName, - from: children.map { $0.raw }, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { return raw.layoutView!.children.count } - - /// Creates a new `ObjcNameSyntax` by replacing the underlying layout with - /// a different set of raw syntax nodes. - /// - /// - Parameter layout: The new list of raw syntax nodes underlying this - /// collection. - /// - Returns: A new `ObjcNameSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ObjcNameSyntax { - let arena = SyntaxArena() - let newRaw = layoutView.replacingLayout(with: layout, arena: arena) - let newData = data.replacingSelf(newRaw, arena: arena) - return ObjcNameSyntax(newData) - } - - /// Creates a new `ObjcNameSyntax` by appending the provided syntax element - /// to the children. - /// - /// - Parameter syntax: The element to append. - /// - Returns: A new `ObjcNameSyntax` with that element appended to the end. - public func appending(_ syntax: Element) -> ObjcNameSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.append(syntax.raw) - return replacingLayout(newLayout) - } - - /// Creates a new `ObjcNameSyntax` by prepending the provided syntax element - /// to the children. - /// - /// - Parameter syntax: The element to prepend. - /// - Returns: A new `ObjcNameSyntax` with that element prepended to the - /// beginning. - public func prepending(_ syntax: Element) -> ObjcNameSyntax { - return inserting(syntax, at: 0) - } - - /// Creates a new `ObjcNameSyntax` by inserting the provided syntax element - /// at the provided index in the children. - /// - /// - Parameters: - /// - syntax: The element to insert. - /// - index: The index at which to insert the element in the collection. - /// - /// - Returns: A new `ObjcNameSyntax` with that element appended to the end. - public func inserting(_ syntax: Element, at index: Int) -> ObjcNameSyntax { - var newLayout = layoutView.formLayoutArray() - /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex...newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") - newLayout.insert(syntax.raw, at: index) - return replacingLayout(newLayout) - } - - /// Creates a new `ObjcNameSyntax` by replacing the syntax element - /// at the provided index. - /// - /// - Parameters: - /// - index: The index at which to replace the element in the collection. - /// - syntax: The element to replace with. - /// - /// - Returns: A new `ObjcNameSyntax` with the new element at the provided index. - public func replacing(childAt index: Int, with syntax: Element) -> ObjcNameSyntax { - var newLayout = layoutView.formLayoutArray() - /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex.. ObjcNameSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.remove(at: index) - return replacingLayout(newLayout) - } - - /// Creates a new `ObjcNameSyntax` by removing the first element. - /// - /// - Returns: A new `ObjcNameSyntax` with the first element removed. - public func removingFirst() -> ObjcNameSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.removeFirst() - return replacingLayout(newLayout) - } - - /// Creates a new `ObjcNameSyntax` by removing the last element. - /// - /// - Returns: A new `ObjcNameSyntax` with the last element removed. - public func removingLast() -> ObjcNameSyntax { - var newLayout = layoutView.formLayoutArray() - newLayout.removeLast() - return replacingLayout(newLayout) - } - - /// Returns a new `ObjcNameSyntax` with its leading trivia replaced - /// by the provided trivia. - public func withLeadingTrivia(_ leadingTrivia: Trivia) -> ObjcNameSyntax { - return ObjcNameSyntax(data.withLeadingTrivia(leadingTrivia, arena: SyntaxArena())) - } - - /// Returns a new `ObjcNameSyntax` with its trailing trivia replaced - /// by the provided trivia. - public func withTrailingTrivia(_ trailingTrivia: Trivia) -> ObjcNameSyntax { - return ObjcNameSyntax(data.withTrailingTrivia(trailingTrivia, arena: SyntaxArena())) - } - - /// Returns a new `ObjcNameSyntax` with its leading trivia removed. - public func withoutLeadingTrivia() -> ObjcNameSyntax { - return withLeadingTrivia([]) - } - - /// Returns a new `ObjcNameSyntax` with its trailing trivia removed. - public func withoutTrailingTrivia() -> ObjcNameSyntax { - return withTrailingTrivia([]) - } - - /// Returns a new `ObjcNameSyntax` with all trivia removed. - public func withoutTrivia() -> ObjcNameSyntax { - return withoutLeadingTrivia().withoutTrailingTrivia() - } - - /// The leading trivia (spaces, newlines, etc.) associated with this `ObjcNameSyntax`. - public var leadingTrivia: Trivia? { - get { - return raw.formLeadingTrivia() - } - set { - self = withLeadingTrivia(newValue ?? []) - } - } - - /// The trailing trivia (spaces, newlines, etc.) associated with this `ObjcNameSyntax`. - public var trailingTrivia: Trivia? { - get { - return raw.formTrailingTrivia() - } - set { - self = withTrailingTrivia(newValue ?? []) - } - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - return nil - } -} - -/// Conformance for `ObjcNameSyntax` to the `BidirectionalCollection` protocol. -extension ObjcNameSyntax: BidirectionalCollection { - public typealias Index = SyntaxChildrenIndex - - public struct Iterator: IteratorProtocol { - private let parent: Syntax - private var iterator: RawSyntaxChildren.Iterator - - init(parent: Syntax, rawChildren: RawSyntaxChildren) { - self.parent = parent - self.iterator = rawChildren.makeIterator() - } - - public mutating func next() -> Element? { - guard let (raw, info) = self.iterator.next() else { - return nil - } - let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) - let data = SyntaxData(absoluteRaw, parent: parent) - return Element(data) - } - } - - public func makeIterator() -> Iterator { - return Iterator(parent: Syntax(self), rawChildren: rawChildren) - } - - private var rawChildren: RawSyntaxChildren { - // We know children in a syntax collection cannot be missing. So we can - // use the low-level and faster RawSyntaxChildren collection instead of - // NonNilRawSyntaxChildren. - return RawSyntaxChildren(self.data.absoluteRaw) - } - - public var startIndex: SyntaxChildrenIndex { - return rawChildren.startIndex - } - public var endIndex: SyntaxChildrenIndex { - return rawChildren.endIndex - } - - public func index(after index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { - return rawChildren.index(after: index) - } - - public func index(before index: SyntaxChildrenIndex) -> SyntaxChildrenIndex { - return rawChildren.index(before: index) - } - - public func distance(from start: SyntaxChildrenIndex, to end: SyntaxChildrenIndex) - -> Int { - return rawChildren.distance(from: start, to: end) - } - - public subscript(position: SyntaxChildrenIndex) -> Element { - let (raw, info) = rawChildren[position] - let absoluteRaw = AbsoluteRawSyntax(raw: raw!, info: info) - let data = SyntaxData(absoluteRaw, parent: Syntax(self)) - return Element(data) - } -} - /// `YieldExprListSyntax` represents a collection of one or more /// `YieldExprListElementSyntax` nodes. YieldExprListSyntax behaves /// as a regular Swift collection, and has accessors that return new @@ -11887,11 +11635,6 @@ extension KeyPathComponentListSyntax: CustomReflectable { return Mirror(self, unlabeledChildren: self.map{ $0 }) } } -extension ObjcNameSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, unlabeledChildren: self.map{ $0 }) - } -} extension YieldExprListSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, unlabeledChildren: self.map{ $0 }) diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift index 10ee09905f1..c37821d83a8 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift @@ -33,7 +33,6 @@ public enum SyntaxEnum { case codeBlock(CodeBlockSyntax) case unexpectedNodes(UnexpectedNodesSyntax) case inOutExpr(InOutExprSyntax) - case poundColumnExpr(PoundColumnExprSyntax) case tupleExprElementList(TupleExprElementListSyntax) case arrayElementList(ArrayElementListSyntax) case dictionaryElementList(DictionaryElementListSyntax) @@ -51,12 +50,6 @@ public enum SyntaxEnum { case assignmentExpr(AssignmentExprSyntax) case sequenceExpr(SequenceExprSyntax) case exprList(ExprListSyntax) - case poundLineExpr(PoundLineExprSyntax) - case poundFileExpr(PoundFileExprSyntax) - case poundFileIDExpr(PoundFileIDExprSyntax) - case poundFilePathExpr(PoundFilePathExprSyntax) - case poundFunctionExpr(PoundFunctionExprSyntax) - case poundDsohandleExpr(PoundDsohandleExprSyntax) case symbolicReferenceExpr(SymbolicReferenceExprSyntax) case prefixOperatorExpr(PrefixOperatorExprSyntax) case binaryOperatorExpr(BinaryOperatorExprSyntax) @@ -105,14 +98,9 @@ public enum SyntaxEnum { case keyPathPropertyComponent(KeyPathPropertyComponentSyntax) case keyPathSubscriptComponent(KeyPathSubscriptComponentSyntax) case keyPathOptionalComponent(KeyPathOptionalComponentSyntax) - case objcNamePiece(ObjcNamePieceSyntax) - case objcName(ObjcNameSyntax) - case objcKeyPathExpr(ObjcKeyPathExprSyntax) - case objcSelectorExpr(ObjcSelectorExprSyntax) case macroExpansionExpr(MacroExpansionExprSyntax) case postfixIfConfigExpr(PostfixIfConfigExprSyntax) case editorPlaceholderExpr(EditorPlaceholderExprSyntax) - case objectLiteralExpr(ObjectLiteralExprSyntax) case yieldExprList(YieldExprListSyntax) case yieldExprListElement(YieldExprListElementSyntax) case typeInitializerClause(TypeInitializerClauseSyntax) @@ -337,8 +325,6 @@ public extension Syntax { return .unexpectedNodes(UnexpectedNodesSyntax(self)!) case .inOutExpr: return .inOutExpr(InOutExprSyntax(self)!) - case .poundColumnExpr: - return .poundColumnExpr(PoundColumnExprSyntax(self)!) case .tupleExprElementList: return .tupleExprElementList(TupleExprElementListSyntax(self)!) case .arrayElementList: @@ -373,18 +359,6 @@ public extension Syntax { return .sequenceExpr(SequenceExprSyntax(self)!) case .exprList: return .exprList(ExprListSyntax(self)!) - case .poundLineExpr: - return .poundLineExpr(PoundLineExprSyntax(self)!) - case .poundFileExpr: - return .poundFileExpr(PoundFileExprSyntax(self)!) - case .poundFileIDExpr: - return .poundFileIDExpr(PoundFileIDExprSyntax(self)!) - case .poundFilePathExpr: - return .poundFilePathExpr(PoundFilePathExprSyntax(self)!) - case .poundFunctionExpr: - return .poundFunctionExpr(PoundFunctionExprSyntax(self)!) - case .poundDsohandleExpr: - return .poundDsohandleExpr(PoundDsohandleExprSyntax(self)!) case .symbolicReferenceExpr: return .symbolicReferenceExpr(SymbolicReferenceExprSyntax(self)!) case .prefixOperatorExpr: @@ -481,22 +455,12 @@ public extension Syntax { return .keyPathSubscriptComponent(KeyPathSubscriptComponentSyntax(self)!) case .keyPathOptionalComponent: return .keyPathOptionalComponent(KeyPathOptionalComponentSyntax(self)!) - case .objcNamePiece: - return .objcNamePiece(ObjcNamePieceSyntax(self)!) - case .objcName: - return .objcName(ObjcNameSyntax(self)!) - case .objcKeyPathExpr: - return .objcKeyPathExpr(ObjcKeyPathExprSyntax(self)!) - case .objcSelectorExpr: - return .objcSelectorExpr(ObjcSelectorExprSyntax(self)!) case .macroExpansionExpr: return .macroExpansionExpr(MacroExpansionExprSyntax(self)!) case .postfixIfConfigExpr: return .postfixIfConfigExpr(PostfixIfConfigExprSyntax(self)!) case .editorPlaceholderExpr: return .editorPlaceholderExpr(EditorPlaceholderExprSyntax(self)!) - case .objectLiteralExpr: - return .objectLiteralExpr(ObjectLiteralExprSyntax(self)!) case .yieldExprList: return .yieldExprList(YieldExprListSyntax(self)!) case .yieldExprListElement: diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift index c0bc846d9fc..e056a89c265 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift @@ -318,33 +318,6 @@ public enum SyntaxFactory { return InOutExprSyntax(data) } } - @available(*, deprecated, message: "Use initializer on PoundColumnExprSyntax") - public static func makePoundColumnExpr(_ unexpectedBeforePoundColumn: UnexpectedNodesSyntax? = nil, poundColumn: TokenSyntax, _ unexpectedAfterPoundColumn: UnexpectedNodesSyntax? = nil) -> PoundColumnExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundColumn?.raw, - poundColumn.raw, - unexpectedAfterPoundColumn?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundColumnExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return PoundColumnExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on PoundColumnExprSyntax") - public static func makeBlankPoundColumnExpr(presence: SourcePresence = .present) -> PoundColumnExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .poundColumnExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundColumnKeyword, arena: arena), - nil, - ], arena: arena)) - return PoundColumnExprSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on TupleExprElementListSyntax") public static func makeTupleExprElementList( _ elements: [TupleExprElementSyntax]) -> TupleExprElementListSyntax { @@ -794,168 +767,6 @@ public enum SyntaxFactory { return ExprListSyntax(data) } } - @available(*, deprecated, message: "Use initializer on PoundLineExprSyntax") - public static func makePoundLineExpr(_ unexpectedBeforePoundLine: UnexpectedNodesSyntax? = nil, poundLine: TokenSyntax, _ unexpectedAfterPoundLine: UnexpectedNodesSyntax? = nil) -> PoundLineExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundLine?.raw, - poundLine.raw, - unexpectedAfterPoundLine?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundLineExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return PoundLineExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on PoundLineExprSyntax") - public static func makeBlankPoundLineExpr(presence: SourcePresence = .present) -> PoundLineExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .poundLineExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundLineKeyword, arena: arena), - nil, - ], arena: arena)) - return PoundLineExprSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on PoundFileExprSyntax") - public static func makePoundFileExpr(_ unexpectedBeforePoundFile: UnexpectedNodesSyntax? = nil, poundFile: TokenSyntax, _ unexpectedAfterPoundFile: UnexpectedNodesSyntax? = nil) -> PoundFileExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundFile?.raw, - poundFile.raw, - unexpectedAfterPoundFile?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFileExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return PoundFileExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on PoundFileExprSyntax") - public static func makeBlankPoundFileExpr(presence: SourcePresence = .present) -> PoundFileExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .poundFileExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundFileKeyword, arena: arena), - nil, - ], arena: arena)) - return PoundFileExprSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on PoundFileIDExprSyntax") - public static func makePoundFileIDExpr(_ unexpectedBeforePoundFileID: UnexpectedNodesSyntax? = nil, poundFileID: TokenSyntax, _ unexpectedAfterPoundFileID: UnexpectedNodesSyntax? = nil) -> PoundFileIDExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundFileID?.raw, - poundFileID.raw, - unexpectedAfterPoundFileID?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFileIDExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return PoundFileIDExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on PoundFileIDExprSyntax") - public static func makeBlankPoundFileIDExpr(presence: SourcePresence = .present) -> PoundFileIDExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .poundFileIDExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundFileIDKeyword, arena: arena), - nil, - ], arena: arena)) - return PoundFileIDExprSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on PoundFilePathExprSyntax") - public static func makePoundFilePathExpr(_ unexpectedBeforePoundFilePath: UnexpectedNodesSyntax? = nil, poundFilePath: TokenSyntax, _ unexpectedAfterPoundFilePath: UnexpectedNodesSyntax? = nil) -> PoundFilePathExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundFilePath?.raw, - poundFilePath.raw, - unexpectedAfterPoundFilePath?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFilePathExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return PoundFilePathExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on PoundFilePathExprSyntax") - public static func makeBlankPoundFilePathExpr(presence: SourcePresence = .present) -> PoundFilePathExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .poundFilePathExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundFilePathKeyword, arena: arena), - nil, - ], arena: arena)) - return PoundFilePathExprSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on PoundFunctionExprSyntax") - public static func makePoundFunctionExpr(_ unexpectedBeforePoundFunction: UnexpectedNodesSyntax? = nil, poundFunction: TokenSyntax, _ unexpectedAfterPoundFunction: UnexpectedNodesSyntax? = nil) -> PoundFunctionExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundFunction?.raw, - poundFunction.raw, - unexpectedAfterPoundFunction?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFunctionExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return PoundFunctionExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on PoundFunctionExprSyntax") - public static func makeBlankPoundFunctionExpr(presence: SourcePresence = .present) -> PoundFunctionExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .poundFunctionExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundFunctionKeyword, arena: arena), - nil, - ], arena: arena)) - return PoundFunctionExprSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on PoundDsohandleExprSyntax") - public static func makePoundDsohandleExpr(_ unexpectedBeforePoundDsohandle: UnexpectedNodesSyntax? = nil, poundDsohandle: TokenSyntax, _ unexpectedAfterPoundDsohandle: UnexpectedNodesSyntax? = nil) -> PoundDsohandleExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundDsohandle?.raw, - poundDsohandle.raw, - unexpectedAfterPoundDsohandle?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundDsohandleExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return PoundDsohandleExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on PoundDsohandleExprSyntax") - public static func makeBlankPoundDsohandleExpr(presence: SourcePresence = .present) -> PoundDsohandleExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .poundDsohandleExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundDsohandleKeyword, arena: arena), - nil, - ], arena: arena)) - return PoundDsohandleExprSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on SymbolicReferenceExprSyntax") public static func makeSymbolicReferenceExpr(_ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, identifier: TokenSyntax, _ unexpectedBetweenIdentifierAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, genericArgumentClause: GenericArgumentClauseSyntax?, _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil) -> SymbolicReferenceExprSyntax { let layout: [RawSyntax?] = [ @@ -2548,143 +2359,6 @@ public enum SyntaxFactory { return KeyPathOptionalComponentSyntax(data) } } - @available(*, deprecated, message: "Use initializer on ObjcNamePieceSyntax") - public static func makeObjcNamePiece(_ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, name: TokenSyntax, _ unexpectedBetweenNameAndDot: UnexpectedNodesSyntax? = nil, dot: TokenSyntax?, _ unexpectedAfterDot: UnexpectedNodesSyntax? = nil) -> ObjcNamePieceSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndDot?.raw, - dot?.raw, - unexpectedAfterDot?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcNamePiece, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return ObjcNamePieceSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on ObjcNamePieceSyntax") - public static func makeBlankObjcNamePiece(presence: SourcePresence = .present) -> ObjcNamePieceSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .objcNamePiece, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena), - nil, - nil, - nil, - ], arena: arena)) - return ObjcNamePieceSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on ObjcNameSyntax") - public static func makeObjcName( - _ elements: [ObjcNamePieceSyntax]) -> ObjcNameSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcName, - from: elements.map { $0.raw }, arena: arena) - let data = SyntaxData.forRoot(raw) - return ObjcNameSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on ObjcNameSyntax") - public static func makeBlankObjcName(presence: SourcePresence = .present) -> ObjcNameSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .objcName, - from: [ - ], arena: arena)) - return ObjcNameSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on ObjcKeyPathExprSyntax") - public static func makeObjcKeyPathExpr(_ unexpectedBeforeKeyPath: UnexpectedNodesSyntax? = nil, keyPath: TokenSyntax, _ unexpectedBetweenKeyPathAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax, _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, name: ObjcNameSyntax, _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax, _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil) -> ObjcKeyPathExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeKeyPath?.raw, - keyPath.raw, - unexpectedBetweenKeyPathAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcKeyPathExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return ObjcKeyPathExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on ObjcKeyPathExprSyntax") - public static func makeBlankObjcKeyPathExpr(presence: SourcePresence = .present) -> ObjcKeyPathExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .objcKeyPathExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundKeyPathKeyword, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.objcName, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena), - nil, - ], arena: arena)) - return ObjcKeyPathExprSyntax(data) - } - } - @available(*, deprecated, message: "Use initializer on ObjcSelectorExprSyntax") - public static func makeObjcSelectorExpr(_ unexpectedBeforePoundSelector: UnexpectedNodesSyntax? = nil, poundSelector: TokenSyntax, _ unexpectedBetweenPoundSelectorAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax, _ unexpectedBetweenLeftParenAndKind: UnexpectedNodesSyntax? = nil, kind: TokenSyntax?, _ unexpectedBetweenKindAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax?, _ unexpectedBetweenColonAndName: UnexpectedNodesSyntax? = nil, name: ExprSyntax, _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax, _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil) -> ObjcSelectorExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundSelector?.raw, - poundSelector.raw, - unexpectedBetweenPoundSelectorAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndKind?.raw, - kind?.raw, - unexpectedBetweenKindAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcSelectorExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return ObjcSelectorExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on ObjcSelectorExprSyntax") - public static func makeBlankObjcSelectorExpr(presence: SourcePresence = .present) -> ObjcSelectorExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .objcSelectorExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundSelectorKeyword, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena), - nil, - nil, - nil, - nil, - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena), - nil, - ], arena: arena)) - return ObjcSelectorExprSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on MacroExpansionExprSyntax") public static func makeMacroExpansionExpr(_ unexpectedBeforePoundToken: UnexpectedNodesSyntax? = nil, poundToken: TokenSyntax, _ unexpectedBetweenPoundTokenAndMacro: UnexpectedNodesSyntax? = nil, macro: TokenSyntax, _ unexpectedBetweenMacroAndGenericArguments: UnexpectedNodesSyntax? = nil, genericArguments: GenericArgumentClauseSyntax?, _ unexpectedBetweenGenericArgumentsAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax?, _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, argumentList: TupleExprElementListSyntax, _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax?, _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, trailingClosure: ClosureExprSyntax?, _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, additionalTrailingClosures: MultipleTrailingClosureElementListSyntax?, _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil) -> MacroExpansionExprSyntax { let layout: [RawSyntax?] = [ @@ -2798,45 +2472,6 @@ public enum SyntaxFactory { return EditorPlaceholderExprSyntax(data) } } - @available(*, deprecated, message: "Use initializer on ObjectLiteralExprSyntax") - public static func makeObjectLiteralExpr(_ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, identifier: TokenSyntax, _ unexpectedBetweenIdentifierAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax, _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, arguments: TupleExprElementListSyntax, _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax, _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil) -> ObjectLiteralExprSyntax { - let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, - ] - return withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objectLiteralExpr, - from: layout, arena: arena) - let data = SyntaxData.forRoot(raw) - return ObjectLiteralExprSyntax(data) - } - } - - @available(*, deprecated, message: "Use initializer on ObjectLiteralExprSyntax") - public static func makeBlankObjectLiteralExpr(presence: SourcePresence = .present) -> ObjectLiteralExprSyntax { - return withExtendedLifetime(SyntaxArena()) { arena in - let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .objectLiteralExpr, - from: [ - nil, - RawSyntax.makeMissingToken(kind: TokenKind.poundColorLiteralKeyword, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena), - nil, - RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena), - nil, - RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena), - nil, - ], arena: arena)) - return ObjectLiteralExprSyntax(data) - } - } @available(*, deprecated, message: "Use initializer on YieldExprListSyntax") public static func makeYieldExprList( _ elements: [YieldExprListElementSyntax]) -> YieldExprListSyntax { @@ -9581,51 +9216,6 @@ public enum SyntaxFactory { leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) } - @available(*, deprecated, message: "Use TokenSyntax.__file__KeywordKeyword instead") - public static func make__FILE__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.__file__Keyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.__line__KeywordKeyword instead") - public static func make__LINE__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.__line__Keyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.__column__KeywordKeyword instead") - public static func make__COLUMN__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.__column__Keyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.__function__KeywordKeyword instead") - public static func make__FUNCTION__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.__function__Keyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.__dso_handle__KeywordKeyword instead") - public static func make__DSO_HANDLE__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.__dso_handle__Keyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } @available(*, deprecated, message: "Use TokenSyntax.wildcardKeywordKeyword instead") public static func makeWildcardKeyword( leadingTrivia: Trivia = [], @@ -9878,87 +9468,6 @@ public enum SyntaxFactory { leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) } - @available(*, deprecated, message: "Use TokenSyntax.poundKeyPathKeywordKeyword instead") - public static func makePoundKeyPathKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundKeyPathKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundLineKeywordKeyword instead") - public static func makePoundLineKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundLineKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundSelectorKeywordKeyword instead") - public static func makePoundSelectorKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundSelectorKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundFileKeywordKeyword instead") - public static func makePoundFileKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundFileKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundFileIDKeywordKeyword instead") - public static func makePoundFileIDKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundFileIDKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundFilePathKeywordKeyword instead") - public static func makePoundFilePathKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundFilePathKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundColumnKeywordKeyword instead") - public static func makePoundColumnKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundColumnKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundFunctionKeywordKeyword instead") - public static func makePoundFunctionKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundFunctionKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundDsohandleKeywordKeyword instead") - public static func makePoundDsohandleKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundDsohandleKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } @available(*, deprecated, message: "Use TokenSyntax.poundAssertKeywordKeyword instead") public static func makePoundAssertKeyword( leadingTrivia: Trivia = [], @@ -10049,33 +9558,6 @@ public enum SyntaxFactory { leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) } - @available(*, deprecated, message: "Use TokenSyntax.poundFileLiteralKeywordKeyword instead") - public static func makePoundFileLiteralKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundFileLiteralKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundImageLiteralKeywordKeyword instead") - public static func makePoundImageLiteralKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundImageLiteralKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } - @available(*, deprecated, message: "Use TokenSyntax.poundColorLiteralKeywordKeyword instead") - public static func makePoundColorLiteralKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = .space - ) -> TokenSyntax { - return makeToken(.poundColorLiteralKeyword, presence: .present, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia) - } @available(*, deprecated, message: "Use TokenSyntax.poundHasSymbolKeywordKeyword instead") public static func makePoundHasSymbolKeyword( leadingTrivia: Trivia = [], diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift index 9a072943b94..3265d090c9e 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift @@ -33,7 +33,6 @@ public enum SyntaxKind { case codeBlock case unexpectedNodes case inOutExpr - case poundColumnExpr case tupleExprElementList case arrayElementList case dictionaryElementList @@ -51,12 +50,6 @@ public enum SyntaxKind { case assignmentExpr case sequenceExpr case exprList - case poundLineExpr - case poundFileExpr - case poundFileIDExpr - case poundFilePathExpr - case poundFunctionExpr - case poundDsohandleExpr case symbolicReferenceExpr case prefixOperatorExpr case binaryOperatorExpr @@ -105,14 +98,9 @@ public enum SyntaxKind { case keyPathPropertyComponent case keyPathSubscriptComponent case keyPathOptionalComponent - case objcNamePiece - case objcName - case objcKeyPathExpr - case objcSelectorExpr case macroExpansionExpr case postfixIfConfigExpr case editorPlaceholderExpr - case objectLiteralExpr case yieldExprList case yieldExprListElement case typeInitializerClause @@ -310,7 +298,6 @@ public enum SyntaxKind { case .closureParamList: return true case .multipleTrailingClosureElementList: return true case .keyPathComponentList: return true - case .objcName: return true case .yieldExprList: return true case .functionParameterList: return true case .ifConfigClauseList: return true diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift index 53a2569ff24..1bf3e983d1f 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift @@ -135,13 +135,6 @@ open class SyntaxRewriter { return ExprSyntax(visitChildren(node)) } - /// Visit a `PoundColumnExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: PoundColumnExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - /// Visit a `TupleExprElementListSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -261,48 +254,6 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(ExprListSyntax.self) } - /// Visit a `PoundLineExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: PoundLineExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - - /// Visit a `PoundFileExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: PoundFileExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - - /// Visit a `PoundFileIDExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: PoundFileIDExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - - /// Visit a `PoundFilePathExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: PoundFilePathExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - - /// Visit a `PoundFunctionExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: PoundFunctionExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - - /// Visit a `PoundDsohandleExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: PoundDsohandleExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - /// Visit a `SymbolicReferenceExprSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -639,34 +590,6 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)).cast(KeyPathOptionalComponentSyntax.self) } - /// Visit a `ObjcNamePieceSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: ObjcNamePieceSyntax) -> ObjcNamePieceSyntax { - return Syntax(visitChildren(node)).cast(ObjcNamePieceSyntax.self) - } - - /// Visit a `ObjcNameSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: ObjcNameSyntax) -> ObjcNameSyntax { - return Syntax(visitChildren(node)).cast(ObjcNameSyntax.self) - } - - /// Visit a `ObjcKeyPathExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: ObjcKeyPathExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - - /// Visit a `ObjcSelectorExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: ObjcSelectorExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - /// Visit a `MacroExpansionExprSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -688,13 +611,6 @@ open class SyntaxRewriter { return ExprSyntax(visitChildren(node)) } - /// Visit a `ObjectLiteralExprSyntax`. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ node: ObjectLiteralExprSyntax) -> ExprSyntax { - return ExprSyntax(visitChildren(node)) - } - /// Visit a `YieldExprListSyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2260,16 +2176,6 @@ open class SyntaxRewriter { return Syntax(visit(node)) } - /// Implementation detail of visit(_:). Do not call directly. - private func visitImplPoundColumnExprSyntax(_ data: SyntaxData) -> Syntax { - let node = PoundColumnExprSyntax(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 visitImplTupleExprElementListSyntax(_ data: SyntaxData) -> Syntax { let node = TupleExprElementListSyntax(data) @@ -2440,66 +2346,6 @@ open class SyntaxRewriter { return Syntax(visit(node)) } - /// Implementation detail of visit(_:). Do not call directly. - private func visitImplPoundLineExprSyntax(_ data: SyntaxData) -> Syntax { - let node = PoundLineExprSyntax(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 visitImplPoundFileExprSyntax(_ data: SyntaxData) -> Syntax { - let node = PoundFileExprSyntax(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 visitImplPoundFileIDExprSyntax(_ data: SyntaxData) -> Syntax { - let node = PoundFileIDExprSyntax(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 visitImplPoundFilePathExprSyntax(_ data: SyntaxData) -> Syntax { - let node = PoundFilePathExprSyntax(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 visitImplPoundFunctionExprSyntax(_ data: SyntaxData) -> Syntax { - let node = PoundFunctionExprSyntax(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 visitImplPoundDsohandleExprSyntax(_ data: SyntaxData) -> Syntax { - let node = PoundDsohandleExprSyntax(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 visitImplSymbolicReferenceExprSyntax(_ data: SyntaxData) -> Syntax { let node = SymbolicReferenceExprSyntax(data) @@ -2980,46 +2826,6 @@ open class SyntaxRewriter { return Syntax(visit(node)) } - /// Implementation detail of visit(_:). Do not call directly. - private func visitImplObjcNamePieceSyntax(_ data: SyntaxData) -> Syntax { - let node = ObjcNamePieceSyntax(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 visitImplObjcNameSyntax(_ data: SyntaxData) -> Syntax { - let node = ObjcNameSyntax(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 visitImplObjcKeyPathExprSyntax(_ data: SyntaxData) -> Syntax { - let node = ObjcKeyPathExprSyntax(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 visitImplObjcSelectorExprSyntax(_ data: SyntaxData) -> Syntax { - let node = ObjcSelectorExprSyntax(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 visitImplMacroExpansionExprSyntax(_ data: SyntaxData) -> Syntax { let node = MacroExpansionExprSyntax(data) @@ -3050,16 +2856,6 @@ open class SyntaxRewriter { return Syntax(visit(node)) } - /// Implementation detail of visit(_:). Do not call directly. - private func visitImplObjectLiteralExprSyntax(_ data: SyntaxData) -> Syntax { - let node = ObjectLiteralExprSyntax(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 visitImplYieldExprListSyntax(_ data: SyntaxData) -> Syntax { let node = YieldExprListSyntax(data) @@ -4964,8 +4760,6 @@ open class SyntaxRewriter { return visitImplUnexpectedNodesSyntax case .inOutExpr: return visitImplInOutExprSyntax - case .poundColumnExpr: - return visitImplPoundColumnExprSyntax case .tupleExprElementList: return visitImplTupleExprElementListSyntax case .arrayElementList: @@ -5000,18 +4794,6 @@ open class SyntaxRewriter { return visitImplSequenceExprSyntax case .exprList: return visitImplExprListSyntax - case .poundLineExpr: - return visitImplPoundLineExprSyntax - case .poundFileExpr: - return visitImplPoundFileExprSyntax - case .poundFileIDExpr: - return visitImplPoundFileIDExprSyntax - case .poundFilePathExpr: - return visitImplPoundFilePathExprSyntax - case .poundFunctionExpr: - return visitImplPoundFunctionExprSyntax - case .poundDsohandleExpr: - return visitImplPoundDsohandleExprSyntax case .symbolicReferenceExpr: return visitImplSymbolicReferenceExprSyntax case .prefixOperatorExpr: @@ -5108,22 +4890,12 @@ open class SyntaxRewriter { return visitImplKeyPathSubscriptComponentSyntax case .keyPathOptionalComponent: return visitImplKeyPathOptionalComponentSyntax - case .objcNamePiece: - return visitImplObjcNamePieceSyntax - case .objcName: - return visitImplObjcNameSyntax - case .objcKeyPathExpr: - return visitImplObjcKeyPathExprSyntax - case .objcSelectorExpr: - return visitImplObjcSelectorExprSyntax case .macroExpansionExpr: return visitImplMacroExpansionExprSyntax case .postfixIfConfigExpr: return visitImplPostfixIfConfigExprSyntax case .editorPlaceholderExpr: return visitImplEditorPlaceholderExprSyntax - case .objectLiteralExpr: - return visitImplObjectLiteralExprSyntax case .yieldExprList: return visitImplYieldExprListSyntax case .yieldExprListElement: @@ -5535,8 +5307,6 @@ open class SyntaxRewriter { return visitImplUnexpectedNodesSyntax(data) case .inOutExpr: return visitImplInOutExprSyntax(data) - case .poundColumnExpr: - return visitImplPoundColumnExprSyntax(data) case .tupleExprElementList: return visitImplTupleExprElementListSyntax(data) case .arrayElementList: @@ -5571,18 +5341,6 @@ open class SyntaxRewriter { return visitImplSequenceExprSyntax(data) case .exprList: return visitImplExprListSyntax(data) - case .poundLineExpr: - return visitImplPoundLineExprSyntax(data) - case .poundFileExpr: - return visitImplPoundFileExprSyntax(data) - case .poundFileIDExpr: - return visitImplPoundFileIDExprSyntax(data) - case .poundFilePathExpr: - return visitImplPoundFilePathExprSyntax(data) - case .poundFunctionExpr: - return visitImplPoundFunctionExprSyntax(data) - case .poundDsohandleExpr: - return visitImplPoundDsohandleExprSyntax(data) case .symbolicReferenceExpr: return visitImplSymbolicReferenceExprSyntax(data) case .prefixOperatorExpr: @@ -5679,22 +5437,12 @@ open class SyntaxRewriter { return visitImplKeyPathSubscriptComponentSyntax(data) case .keyPathOptionalComponent: return visitImplKeyPathOptionalComponentSyntax(data) - case .objcNamePiece: - return visitImplObjcNamePieceSyntax(data) - case .objcName: - return visitImplObjcNameSyntax(data) - case .objcKeyPathExpr: - return visitImplObjcKeyPathExprSyntax(data) - case .objcSelectorExpr: - return visitImplObjcSelectorExprSyntax(data) case .macroExpansionExpr: return visitImplMacroExpansionExprSyntax(data) case .postfixIfConfigExpr: return visitImplPostfixIfConfigExprSyntax(data) case .editorPlaceholderExpr: return visitImplEditorPlaceholderExprSyntax(data) - case .objectLiteralExpr: - return visitImplObjectLiteralExprSyntax(data) case .yieldExprList: return visitImplYieldExprListSyntax(data) case .yieldExprListElement: diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift index 6ec1c1e6951..2df5bdb2186 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift @@ -192,9 +192,6 @@ extension ClosureCaptureItemSyntax: WithTrailingCommaSyntax {} extension ClosureParamSyntax: WithTrailingCommaSyntax {} extension ClosureExprSyntax: BracedSyntax, WithStatementsSyntax {} extension ExpressionSegmentSyntax: ParenthesizedSyntax {} -extension ObjcKeyPathExprSyntax: ParenthesizedSyntax {} -extension ObjcSelectorExprSyntax: ParenthesizedSyntax {} -extension ObjectLiteralExprSyntax: ParenthesizedSyntax {} extension TypealiasDeclSyntax: IdentifiedDeclSyntax {} extension AssociatedtypeDeclSyntax: IdentifiedDeclSyntax {} extension ParameterClauseSyntax: ParenthesizedSyntax {} diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift index 331a9a0fc97..cc5f034b8f5 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift @@ -84,10 +84,6 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: InOutExprSyntax) -> ResultType - /// Visiting `PoundColumnExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: PoundColumnExprSyntax) -> ResultType /// Visiting `TupleExprElementListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -156,30 +152,6 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ExprListSyntax) -> ResultType - /// Visiting `PoundLineExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: PoundLineExprSyntax) -> ResultType - /// Visiting `PoundFileExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: PoundFileExprSyntax) -> ResultType - /// Visiting `PoundFileIDExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: PoundFileIDExprSyntax) -> ResultType - /// Visiting `PoundFilePathExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: PoundFilePathExprSyntax) -> ResultType - /// Visiting `PoundFunctionExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: PoundFunctionExprSyntax) -> ResultType - /// Visiting `PoundDsohandleExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: PoundDsohandleExprSyntax) -> ResultType /// Visiting `SymbolicReferenceExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -372,22 +344,6 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: KeyPathOptionalComponentSyntax) -> ResultType - /// Visiting `ObjcNamePieceSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: ObjcNamePieceSyntax) -> ResultType - /// Visiting `ObjcNameSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: ObjcNameSyntax) -> ResultType - /// Visiting `ObjcKeyPathExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: ObjcKeyPathExprSyntax) -> ResultType - /// Visiting `ObjcSelectorExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: ObjcSelectorExprSyntax) -> ResultType /// Visiting `MacroExpansionExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -400,10 +356,6 @@ public protocol SyntaxTransformVisitor { /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. func visit(_ node: EditorPlaceholderExprSyntax) -> ResultType - /// Visiting `ObjectLiteralExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: ObjectLiteralExprSyntax) -> ResultType /// Visiting `YieldExprListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -1239,12 +1191,6 @@ extension SyntaxTransformVisitor { public func visit(_ node: InOutExprSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `PoundColumnExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: PoundColumnExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `TupleExprElementListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -1347,42 +1293,6 @@ extension SyntaxTransformVisitor { public func visit(_ node: ExprListSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `PoundLineExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: PoundLineExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `PoundFileExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: PoundFileExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `PoundFileIDExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: PoundFileIDExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `PoundFilePathExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: PoundFilePathExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `PoundFunctionExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: PoundFunctionExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `PoundDsohandleExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: PoundDsohandleExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `SymbolicReferenceExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -1671,30 +1581,6 @@ extension SyntaxTransformVisitor { public func visit(_ node: KeyPathOptionalComponentSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `ObjcNamePieceSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: ObjcNamePieceSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `ObjcNameSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: ObjcNameSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `ObjcKeyPathExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: ObjcKeyPathExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } - /// Visiting `ObjcSelectorExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: ObjcSelectorExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `MacroExpansionExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -1713,12 +1599,6 @@ extension SyntaxTransformVisitor { public func visit(_ node: EditorPlaceholderExprSyntax) -> ResultType { visitAny(Syntax(node)) } - /// Visiting `ObjectLiteralExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: nil by default. - public func visit(_ node: ObjectLiteralExprSyntax) -> ResultType { - visitAny(Syntax(node)) - } /// Visiting `YieldExprListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -2850,8 +2730,6 @@ extension SyntaxTransformVisitor { return visit(derived) case .inOutExpr(let derived): return visit(derived) - case .poundColumnExpr(let derived): - return visit(derived) case .tupleExprElementList(let derived): return visit(derived) case .arrayElementList(let derived): @@ -2886,18 +2764,6 @@ extension SyntaxTransformVisitor { return visit(derived) case .exprList(let derived): return visit(derived) - case .poundLineExpr(let derived): - return visit(derived) - case .poundFileExpr(let derived): - return visit(derived) - case .poundFileIDExpr(let derived): - return visit(derived) - case .poundFilePathExpr(let derived): - return visit(derived) - case .poundFunctionExpr(let derived): - return visit(derived) - case .poundDsohandleExpr(let derived): - return visit(derived) case .symbolicReferenceExpr(let derived): return visit(derived) case .prefixOperatorExpr(let derived): @@ -2994,22 +2860,12 @@ extension SyntaxTransformVisitor { return visit(derived) case .keyPathOptionalComponent(let derived): return visit(derived) - case .objcNamePiece(let derived): - return visit(derived) - case .objcName(let derived): - return visit(derived) - case .objcKeyPathExpr(let derived): - return visit(derived) - case .objcSelectorExpr(let derived): - return visit(derived) case .macroExpansionExpr(let derived): return visit(derived) case .postfixIfConfigExpr(let derived): return visit(derived) case .editorPlaceholderExpr(let derived): return visit(derived) - case .objectLiteralExpr(let derived): - return visit(derived) case .yieldExprList(let derived): return visit(derived) case .yieldExprListElement(let derived): diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift index 2edbbdd3a2b..f43fbfb6095 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift @@ -201,16 +201,6 @@ open class SyntaxVisitor { /// The function called after visiting `InOutExprSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: InOutExprSyntax) {} - /// Visiting `PoundColumnExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: PoundColumnExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `PoundColumnExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: PoundColumnExprSyntax) {} /// Visiting `TupleExprElementListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -381,66 +371,6 @@ open class SyntaxVisitor { /// The function called after visiting `ExprListSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: ExprListSyntax) {} - /// Visiting `PoundLineExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: PoundLineExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `PoundLineExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: PoundLineExprSyntax) {} - /// Visiting `PoundFileExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: PoundFileExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `PoundFileExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: PoundFileExprSyntax) {} - /// Visiting `PoundFileIDExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: PoundFileIDExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `PoundFileIDExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: PoundFileIDExprSyntax) {} - /// Visiting `PoundFilePathExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: PoundFilePathExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `PoundFilePathExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: PoundFilePathExprSyntax) {} - /// Visiting `PoundFunctionExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: PoundFunctionExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `PoundFunctionExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: PoundFunctionExprSyntax) {} - /// Visiting `PoundDsohandleExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: PoundDsohandleExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `PoundDsohandleExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: PoundDsohandleExprSyntax) {} /// Visiting `SymbolicReferenceExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -921,46 +851,6 @@ open class SyntaxVisitor { /// The function called after visiting `KeyPathOptionalComponentSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: KeyPathOptionalComponentSyntax) {} - /// Visiting `ObjcNamePieceSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: ObjcNamePieceSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `ObjcNamePieceSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: ObjcNamePieceSyntax) {} - /// Visiting `ObjcNameSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: ObjcNameSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `ObjcNameSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: ObjcNameSyntax) {} - /// Visiting `ObjcKeyPathExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: ObjcKeyPathExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `ObjcKeyPathExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: ObjcKeyPathExprSyntax) {} - /// Visiting `ObjcSelectorExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: ObjcSelectorExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `ObjcSelectorExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: ObjcSelectorExprSyntax) {} /// Visiting `MacroExpansionExprSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -991,16 +881,6 @@ open class SyntaxVisitor { /// The function called after visiting `EditorPlaceholderExprSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: EditorPlaceholderExprSyntax) {} - /// Visiting `ObjectLiteralExprSyntax` specifically. - /// - Parameter node: the node we are visiting. - /// - Returns: how should we continue visiting. - open func visit(_ node: ObjectLiteralExprSyntax) -> SyntaxVisitorContinueKind { - return .visitChildren - } - - /// The function called after visiting `ObjectLiteralExprSyntax` and its descendents. - /// - node: the node we just finished visiting. - open func visitPost(_ node: ObjectLiteralExprSyntax) {} /// Visiting `YieldExprListSyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -3075,17 +2955,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplPoundColumnExprSyntax(_ data: SyntaxData) { - let node = PoundColumnExprSyntax(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 visitImplTupleExprElementListSyntax(_ data: SyntaxData) { let node = TupleExprElementListSyntax(data) @@ -3273,72 +3142,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplPoundLineExprSyntax(_ data: SyntaxData) { - let node = PoundLineExprSyntax(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 visitImplPoundFileExprSyntax(_ data: SyntaxData) { - let node = PoundFileExprSyntax(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 visitImplPoundFileIDExprSyntax(_ data: SyntaxData) { - let node = PoundFileIDExprSyntax(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 visitImplPoundFilePathExprSyntax(_ data: SyntaxData) { - let node = PoundFilePathExprSyntax(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 visitImplPoundFunctionExprSyntax(_ data: SyntaxData) { - let node = PoundFunctionExprSyntax(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 visitImplPoundDsohandleExprSyntax(_ data: SyntaxData) { - let node = PoundDsohandleExprSyntax(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 visitImplSymbolicReferenceExprSyntax(_ data: SyntaxData) { let node = SymbolicReferenceExprSyntax(data) @@ -3867,50 +3670,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplObjcNamePieceSyntax(_ data: SyntaxData) { - let node = ObjcNamePieceSyntax(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 visitImplObjcNameSyntax(_ data: SyntaxData) { - let node = ObjcNameSyntax(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 visitImplObjcKeyPathExprSyntax(_ data: SyntaxData) { - let node = ObjcKeyPathExprSyntax(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 visitImplObjcSelectorExprSyntax(_ data: SyntaxData) { - let node = ObjcSelectorExprSyntax(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 visitImplMacroExpansionExprSyntax(_ data: SyntaxData) { let node = MacroExpansionExprSyntax(data) @@ -3944,17 +3703,6 @@ open class SyntaxVisitor { visitPost(node) } - /// Implementation detail of doVisit(_:_:). Do not call directly. - private func visitImplObjectLiteralExprSyntax(_ data: SyntaxData) { - let node = ObjectLiteralExprSyntax(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 visitImplYieldExprListSyntax(_ data: SyntaxData) { let node = YieldExprListSyntax(data) @@ -6009,8 +5757,6 @@ open class SyntaxVisitor { visitImplUnexpectedNodesSyntax(data) case .inOutExpr: visitImplInOutExprSyntax(data) - case .poundColumnExpr: - visitImplPoundColumnExprSyntax(data) case .tupleExprElementList: visitImplTupleExprElementListSyntax(data) case .arrayElementList: @@ -6045,18 +5791,6 @@ open class SyntaxVisitor { visitImplSequenceExprSyntax(data) case .exprList: visitImplExprListSyntax(data) - case .poundLineExpr: - visitImplPoundLineExprSyntax(data) - case .poundFileExpr: - visitImplPoundFileExprSyntax(data) - case .poundFileIDExpr: - visitImplPoundFileIDExprSyntax(data) - case .poundFilePathExpr: - visitImplPoundFilePathExprSyntax(data) - case .poundFunctionExpr: - visitImplPoundFunctionExprSyntax(data) - case .poundDsohandleExpr: - visitImplPoundDsohandleExprSyntax(data) case .symbolicReferenceExpr: visitImplSymbolicReferenceExprSyntax(data) case .prefixOperatorExpr: @@ -6153,22 +5887,12 @@ open class SyntaxVisitor { visitImplKeyPathSubscriptComponentSyntax(data) case .keyPathOptionalComponent: visitImplKeyPathOptionalComponentSyntax(data) - case .objcNamePiece: - visitImplObjcNamePieceSyntax(data) - case .objcName: - visitImplObjcNameSyntax(data) - case .objcKeyPathExpr: - visitImplObjcKeyPathExprSyntax(data) - case .objcSelectorExpr: - visitImplObjcSelectorExprSyntax(data) case .macroExpansionExpr: visitImplMacroExpansionExprSyntax(data) case .postfixIfConfigExpr: visitImplPostfixIfConfigExprSyntax(data) case .editorPlaceholderExpr: visitImplEditorPlaceholderExprSyntax(data) - case .objectLiteralExpr: - visitImplObjectLiteralExprSyntax(data) case .yieldExprList: visitImplYieldExprListSyntax(data) case .yieldExprListElement: diff --git a/Sources/SwiftSyntax/gyb_generated/TokenKind.swift b/Sources/SwiftSyntax/gyb_generated/TokenKind.swift index 5ebc7758cd2..bc648174f38 100644 --- a/Sources/SwiftSyntax/gyb_generated/TokenKind.swift +++ b/Sources/SwiftSyntax/gyb_generated/TokenKind.swift @@ -69,11 +69,6 @@ public enum TokenKind: Hashable { case trueKeyword case tryKeyword case throwsKeyword - case __file__Keyword - case __line__Keyword - case __column__Keyword - case __function__Keyword - case __dso_handle__Keyword case wildcardKeyword case leftParen case rightParen @@ -102,15 +97,6 @@ public enum TokenKind: Hashable { case stringQuote case singleQuote case multilineStringQuote - case poundKeyPathKeyword - case poundLineKeyword - case poundSelectorKeyword - case poundFileKeyword - case poundFileIDKeyword - case poundFilePathKeyword - case poundColumnKeyword - case poundFunctionKeyword - case poundDsohandleKeyword case poundAssertKeyword case poundSourceLocationKeyword case poundWarningKeyword @@ -121,9 +107,6 @@ public enum TokenKind: Hashable { case poundEndifKeyword case poundAvailableKeyword case poundUnavailableKeyword - case poundFileLiteralKeyword - case poundImageLiteralKeyword - case poundColorLiteralKeyword case poundHasSymbolKeyword case integerLiteral(String) case floatingLiteral(String) @@ -252,36 +235,8 @@ public enum TokenKind: Hashable { self = .tryKeyword case "throws": self = .throwsKeyword - case "__FILE__": - self = .__file__Keyword - case "__LINE__": - self = .__line__Keyword - case "__COLUMN__": - self = .__column__Keyword - case "__FUNCTION__": - self = .__function__Keyword - case "__DSO_HANDLE__": - self = .__dso_handle__Keyword case "_": self = .wildcardKeyword - case "#keyPath": - self = .poundKeyPathKeyword - case "#line": - self = .poundLineKeyword - case "#selector": - self = .poundSelectorKeyword - case "#file": - self = .poundFileKeyword - case "#fileID": - self = .poundFileIDKeyword - case "#filePath": - self = .poundFilePathKeyword - case "#column": - self = .poundColumnKeyword - case "#function": - self = .poundFunctionKeyword - case "#dsohandle": - self = .poundDsohandleKeyword case "#assert": self = .poundAssertKeyword case "#sourceLocation": @@ -302,12 +257,6 @@ public enum TokenKind: Hashable { self = .poundAvailableKeyword case "#unavailable": self = .poundUnavailableKeyword - case "#fileLiteral": - self = .poundFileLiteralKeyword - case "#imageLiteral": - self = .poundImageLiteralKeyword - case "#colorLiteral": - self = .poundColorLiteralKeyword case "#_hasSymbol": self = .poundHasSymbolKeyword default: @@ -373,11 +322,6 @@ public enum TokenKind: Hashable { case .trueKeyword: return "true" case .tryKeyword: return "try" case .throwsKeyword: return "throws" - case .__file__Keyword: return "__FILE__" - case .__line__Keyword: return "__LINE__" - case .__column__Keyword: return "__COLUMN__" - case .__function__Keyword: return "__FUNCTION__" - case .__dso_handle__Keyword: return "__DSO_HANDLE__" case .wildcardKeyword: return "_" case .leftParen: return "(" case .rightParen: return ")" @@ -406,15 +350,6 @@ public enum TokenKind: Hashable { case .stringQuote: return "\"" case .singleQuote: return "\'" case .multilineStringQuote: return "\"\"\"" - case .poundKeyPathKeyword: return "#keyPath" - case .poundLineKeyword: return "#line" - case .poundSelectorKeyword: return "#selector" - case .poundFileKeyword: return "#file" - case .poundFileIDKeyword: return "#fileID" - case .poundFilePathKeyword: return "#filePath" - case .poundColumnKeyword: return "#column" - case .poundFunctionKeyword: return "#function" - case .poundDsohandleKeyword: return "#dsohandle" case .poundAssertKeyword: return "#assert" case .poundSourceLocationKeyword: return "#sourceLocation" case .poundWarningKeyword: return "#warning" @@ -425,9 +360,6 @@ public enum TokenKind: Hashable { case .poundEndifKeyword: return "#endif" case .poundAvailableKeyword: return "#available" case .poundUnavailableKeyword: return "#unavailable" - case .poundFileLiteralKeyword: return "#fileLiteral" - case .poundImageLiteralKeyword: return "#imageLiteral" - case .poundColorLiteralKeyword: return "#colorLiteral" case .poundHasSymbolKeyword: return "#_hasSymbol" case .integerLiteral(let text): return text case .floatingLiteral(let text): return text @@ -509,11 +441,6 @@ public enum TokenKind: Hashable { case .trueKeyword: return true case .tryKeyword: return true case .throwsKeyword: return true - case .__file__Keyword: return true - case .__line__Keyword: return true - case .__column__Keyword: return true - case .__function__Keyword: return true - case .__dso_handle__Keyword: return true case .wildcardKeyword: return true case .leftParen: return false case .rightParen: return false @@ -542,15 +469,6 @@ public enum TokenKind: Hashable { case .stringQuote: return false case .singleQuote: return false case .multilineStringQuote: return false - case .poundKeyPathKeyword: return true - case .poundLineKeyword: return true - case .poundSelectorKeyword: return true - case .poundFileKeyword: return true - case .poundFileIDKeyword: return true - case .poundFilePathKeyword: return true - case .poundColumnKeyword: return true - case .poundFunctionKeyword: return true - case .poundDsohandleKeyword: return true case .poundAssertKeyword: return true case .poundSourceLocationKeyword: return true case .poundWarningKeyword: return true @@ -561,9 +479,6 @@ public enum TokenKind: Hashable { case .poundEndifKeyword: return true case .poundAvailableKeyword: return true case .poundUnavailableKeyword: return true - case .poundFileLiteralKeyword: return true - case .poundImageLiteralKeyword: return true - case .poundColorLiteralKeyword: return true case .poundHasSymbolKeyword: return true case .integerLiteral: return false case .floatingLiteral: return false @@ -645,11 +560,6 @@ public enum TokenKind: Hashable { case .trueKeyword: return false case .tryKeyword: return false case .throwsKeyword: return false - case .__file__Keyword: return false - case .__line__Keyword: return false - case .__column__Keyword: return false - case .__function__Keyword: return false - case .__dso_handle__Keyword: return false case .wildcardKeyword: return false case .leftParen: return true case .rightParen: return true @@ -678,15 +588,6 @@ public enum TokenKind: Hashable { case .stringQuote: return true case .singleQuote: return true case .multilineStringQuote: return true - case .poundKeyPathKeyword: return false - case .poundLineKeyword: return false - case .poundSelectorKeyword: return false - case .poundFileKeyword: return false - case .poundFileIDKeyword: return false - case .poundFilePathKeyword: return false - case .poundColumnKeyword: return false - case .poundFunctionKeyword: return false - case .poundDsohandleKeyword: return false case .poundAssertKeyword: return false case .poundSourceLocationKeyword: return false case .poundWarningKeyword: return false @@ -697,9 +598,6 @@ public enum TokenKind: Hashable { case .poundEndifKeyword: return false case .poundAvailableKeyword: return false case .poundUnavailableKeyword: return false - case .poundFileLiteralKeyword: return false - case .poundImageLiteralKeyword: return false - case .poundColorLiteralKeyword: return false case .poundHasSymbolKeyword: return false case .integerLiteral: return false case .floatingLiteral: return false @@ -776,11 +674,6 @@ public enum TokenKind: Hashable { case .trueKeyword: return "kw_true" case .tryKeyword: return "kw_try" case .throwsKeyword: return "kw_throws" - case .__file__Keyword: return "kw___FILE__" - case .__line__Keyword: return "kw___LINE__" - case .__column__Keyword: return "kw___COLUMN__" - case .__function__Keyword: return "kw___FUNCTION__" - case .__dso_handle__Keyword: return "kw___DSO_HANDLE__" case .wildcardKeyword: return "kw__" case .leftParen: return "l_paren" case .rightParen: return "r_paren" @@ -809,15 +702,6 @@ public enum TokenKind: Hashable { case .stringQuote: return "string_quote" case .singleQuote: return "single_quote" case .multilineStringQuote: return "multiline_string_quote" - case .poundKeyPathKeyword: return "pound_keyPath" - case .poundLineKeyword: return "pound_line" - case .poundSelectorKeyword: return "pound_selector" - case .poundFileKeyword: return "pound_file" - case .poundFileIDKeyword: return "pound_fileID" - case .poundFilePathKeyword: return "pound_filePath" - case .poundColumnKeyword: return "pound_column" - case .poundFunctionKeyword: return "pound_function" - case .poundDsohandleKeyword: return "pound_dsohandle" case .poundAssertKeyword: return "pound_assert" case .poundSourceLocationKeyword: return "pound_sourceLocation" case .poundWarningKeyword: return "pound_warning" @@ -828,9 +712,6 @@ public enum TokenKind: Hashable { case .poundEndifKeyword: return "pound_endif" case .poundAvailableKeyword: return "pound_available" case .poundUnavailableKeyword: return "pound_unavailable" - case .poundFileLiteralKeyword: return "pound_fileLiteral" - case .poundImageLiteralKeyword: return "pound_imageLiteral" - case .poundColorLiteralKeyword: return "pound_colorLiteral" case .poundHasSymbolKeyword: return "pound__hasSymbol" case .integerLiteral(_): return "integer_literal" case .floatingLiteral(_): return "floating_literal" @@ -907,11 +788,6 @@ public enum TokenKind: Hashable { case .trueKeyword: return SourceLength(utf8Length: 4) case .tryKeyword: return SourceLength(utf8Length: 3) case .throwsKeyword: return SourceLength(utf8Length: 6) - case .__file__Keyword: return SourceLength(utf8Length: 8) - case .__line__Keyword: return SourceLength(utf8Length: 8) - case .__column__Keyword: return SourceLength(utf8Length: 10) - case .__function__Keyword: return SourceLength(utf8Length: 12) - case .__dso_handle__Keyword: return SourceLength(utf8Length: 14) case .wildcardKeyword: return SourceLength(utf8Length: 1) case .leftParen: return SourceLength(utf8Length: 1) case .rightParen: return SourceLength(utf8Length: 1) @@ -940,15 +816,6 @@ public enum TokenKind: Hashable { case .stringQuote: return SourceLength(utf8Length: 1) case .singleQuote: return SourceLength(utf8Length: 1) case .multilineStringQuote: return SourceLength(utf8Length: 3) - case .poundKeyPathKeyword: return SourceLength(utf8Length: 8) - case .poundLineKeyword: return SourceLength(utf8Length: 5) - case .poundSelectorKeyword: return SourceLength(utf8Length: 9) - case .poundFileKeyword: return SourceLength(utf8Length: 5) - case .poundFileIDKeyword: return SourceLength(utf8Length: 7) - case .poundFilePathKeyword: return SourceLength(utf8Length: 9) - case .poundColumnKeyword: return SourceLength(utf8Length: 7) - case .poundFunctionKeyword: return SourceLength(utf8Length: 9) - case .poundDsohandleKeyword: return SourceLength(utf8Length: 10) case .poundAssertKeyword: return SourceLength(utf8Length: 7) case .poundSourceLocationKeyword: return SourceLength(utf8Length: 15) case .poundWarningKeyword: return SourceLength(utf8Length: 8) @@ -959,9 +826,6 @@ public enum TokenKind: Hashable { case .poundEndifKeyword: return SourceLength(utf8Length: 6) case .poundAvailableKeyword: return SourceLength(utf8Length: 10) case .poundUnavailableKeyword: return SourceLength(utf8Length: 12) - case .poundFileLiteralKeyword: return SourceLength(utf8Length: 12) - case .poundImageLiteralKeyword: return SourceLength(utf8Length: 13) - case .poundColorLiteralKeyword: return SourceLength(utf8Length: 13) case .poundHasSymbolKeyword: return SourceLength(utf8Length: 11) case .integerLiteral(let text): return SourceLength(of: text) case .floatingLiteral(let text): return SourceLength(of: text) @@ -1040,11 +904,6 @@ extension TokenKind: Equatable { case (.trueKeyword, .trueKeyword): return true case (.tryKeyword, .tryKeyword): return true case (.throwsKeyword, .throwsKeyword): return true - case (.__file__Keyword, .__file__Keyword): return true - case (.__line__Keyword, .__line__Keyword): return true - case (.__column__Keyword, .__column__Keyword): return true - case (.__function__Keyword, .__function__Keyword): return true - case (.__dso_handle__Keyword, .__dso_handle__Keyword): return true case (.wildcardKeyword, .wildcardKeyword): return true case (.leftParen, .leftParen): return true case (.rightParen, .rightParen): return true @@ -1073,15 +932,6 @@ extension TokenKind: Equatable { case (.stringQuote, .stringQuote): return true case (.singleQuote, .singleQuote): return true case (.multilineStringQuote, .multilineStringQuote): return true - case (.poundKeyPathKeyword, .poundKeyPathKeyword): return true - case (.poundLineKeyword, .poundLineKeyword): return true - case (.poundSelectorKeyword, .poundSelectorKeyword): return true - case (.poundFileKeyword, .poundFileKeyword): return true - case (.poundFileIDKeyword, .poundFileIDKeyword): return true - case (.poundFilePathKeyword, .poundFilePathKeyword): return true - case (.poundColumnKeyword, .poundColumnKeyword): return true - case (.poundFunctionKeyword, .poundFunctionKeyword): return true - case (.poundDsohandleKeyword, .poundDsohandleKeyword): return true case (.poundAssertKeyword, .poundAssertKeyword): return true case (.poundSourceLocationKeyword, .poundSourceLocationKeyword): return true case (.poundWarningKeyword, .poundWarningKeyword): return true @@ -1092,9 +942,6 @@ extension TokenKind: Equatable { case (.poundEndifKeyword, .poundEndifKeyword): return true case (.poundAvailableKeyword, .poundAvailableKeyword): return true case (.poundUnavailableKeyword, .poundUnavailableKeyword): return true - case (.poundFileLiteralKeyword, .poundFileLiteralKeyword): return true - case (.poundImageLiteralKeyword, .poundImageLiteralKeyword): return true - case (.poundColorLiteralKeyword, .poundColorLiteralKeyword): return true case (.poundHasSymbolKeyword, .poundHasSymbolKeyword): return true case (.integerLiteral(let lhsText), .integerLiteral(let rhsText)): return lhsText == rhsText @@ -1188,11 +1035,6 @@ public enum RawTokenKind: Equatable, Hashable { case trueKeyword case tryKeyword case throwsKeyword - case __file__Keyword - case __line__Keyword - case __column__Keyword - case __function__Keyword - case __dso_handle__Keyword case wildcardKeyword case leftParen case rightParen @@ -1221,15 +1063,6 @@ public enum RawTokenKind: Equatable, Hashable { case stringQuote case singleQuote case multilineStringQuote - case poundKeyPathKeyword - case poundLineKeyword - case poundSelectorKeyword - case poundFileKeyword - case poundFileIDKeyword - case poundFilePathKeyword - case poundColumnKeyword - case poundFunctionKeyword - case poundDsohandleKeyword case poundAssertKeyword case poundSourceLocationKeyword case poundWarningKeyword @@ -1240,9 +1073,6 @@ public enum RawTokenKind: Equatable, Hashable { case poundEndifKeyword case poundAvailableKeyword case poundUnavailableKeyword - case poundFileLiteralKeyword - case poundImageLiteralKeyword - case poundColorLiteralKeyword case poundHasSymbolKeyword case integerLiteral case floatingLiteral @@ -1318,11 +1148,6 @@ public enum RawTokenKind: Equatable, Hashable { case .trueKeyword: return "true" case .tryKeyword: return "try" case .throwsKeyword: return "throws" - case .__file__Keyword: return "__FILE__" - case .__line__Keyword: return "__LINE__" - case .__column__Keyword: return "__COLUMN__" - case .__function__Keyword: return "__FUNCTION__" - case .__dso_handle__Keyword: return "__DSO_HANDLE__" case .wildcardKeyword: return "_" case .leftParen: return "(" case .rightParen: return ")" @@ -1351,15 +1176,6 @@ public enum RawTokenKind: Equatable, Hashable { case .stringQuote: return "\"" case .singleQuote: return "\'" case .multilineStringQuote: return "\"\"\"" - case .poundKeyPathKeyword: return "#keyPath" - case .poundLineKeyword: return "#line" - case .poundSelectorKeyword: return "#selector" - case .poundFileKeyword: return "#file" - case .poundFileIDKeyword: return "#fileID" - case .poundFilePathKeyword: return "#filePath" - case .poundColumnKeyword: return "#column" - case .poundFunctionKeyword: return "#function" - case .poundDsohandleKeyword: return "#dsohandle" case .poundAssertKeyword: return "#assert" case .poundSourceLocationKeyword: return "#sourceLocation" case .poundWarningKeyword: return "#warning" @@ -1370,9 +1186,6 @@ public enum RawTokenKind: Equatable, Hashable { case .poundEndifKeyword: return "#endif" case .poundAvailableKeyword: return "#available" case .poundUnavailableKeyword: return "#unavailable" - case .poundFileLiteralKeyword: return "#fileLiteral" - case .poundImageLiteralKeyword: return "#imageLiteral" - case .poundColorLiteralKeyword: return "#colorLiteral" case .poundHasSymbolKeyword: return "#_hasSymbol" case .stringInterpolationAnchor: return ")" case .yield: return "yield" @@ -1436,11 +1249,6 @@ public enum RawTokenKind: Equatable, Hashable { case .trueKeyword: return "true" case .tryKeyword: return "try" case .throwsKeyword: return "throws" - case .__file__Keyword: return "__FILE__" - case .__line__Keyword: return "__LINE__" - case .__column__Keyword: return "__COLUMN__" - case .__function__Keyword: return "__FUNCTION__" - case .__dso_handle__Keyword: return "__DSO_HANDLE__" case .wildcardKeyword: return "_" case .leftParen: return "(" case .rightParen: return ")" @@ -1469,15 +1277,6 @@ public enum RawTokenKind: Equatable, Hashable { case .stringQuote: return "\"" case .singleQuote: return "\'" case .multilineStringQuote: return "\"\"\"" - case .poundKeyPathKeyword: return "#keyPath" - case .poundLineKeyword: return "#line" - case .poundSelectorKeyword: return "#selector" - case .poundFileKeyword: return "#file" - case .poundFileIDKeyword: return "#fileID" - case .poundFilePathKeyword: return "#filePath" - case .poundColumnKeyword: return "#column" - case .poundFunctionKeyword: return "#function" - case .poundDsohandleKeyword: return "#dsohandle" case .poundAssertKeyword: return "#assert" case .poundSourceLocationKeyword: return "#sourceLocation" case .poundWarningKeyword: return "#warning" @@ -1488,9 +1287,6 @@ public enum RawTokenKind: Equatable, Hashable { case .poundEndifKeyword: return "#endif" case .poundAvailableKeyword: return "#available" case .poundUnavailableKeyword: return "#unavailable" - case .poundFileLiteralKeyword: return "file reference" - case .poundImageLiteralKeyword: return "image" - case .poundColorLiteralKeyword: return "color" case .poundHasSymbolKeyword: return "#_hasSymbol" case .integerLiteral: return "integer literal" case .floatingLiteral: return "floating literal" @@ -1572,11 +1368,6 @@ public enum RawTokenKind: Equatable, Hashable { case .trueKeyword: return true case .tryKeyword: return true case .throwsKeyword: return true - case .__file__Keyword: return true - case .__line__Keyword: return true - case .__column__Keyword: return true - case .__function__Keyword: return true - case .__dso_handle__Keyword: return true case .wildcardKeyword: return true case .leftParen: return false case .rightParen: return false @@ -1605,15 +1396,6 @@ public enum RawTokenKind: Equatable, Hashable { case .stringQuote: return false case .singleQuote: return false case .multilineStringQuote: return false - case .poundKeyPathKeyword: return true - case .poundLineKeyword: return true - case .poundSelectorKeyword: return true - case .poundFileKeyword: return true - case .poundFileIDKeyword: return true - case .poundFilePathKeyword: return true - case .poundColumnKeyword: return true - case .poundFunctionKeyword: return true - case .poundDsohandleKeyword: return true case .poundAssertKeyword: return true case .poundSourceLocationKeyword: return true case .poundWarningKeyword: return true @@ -1624,9 +1406,6 @@ public enum RawTokenKind: Equatable, Hashable { case .poundEndifKeyword: return true case .poundAvailableKeyword: return true case .poundUnavailableKeyword: return true - case .poundFileLiteralKeyword: return true - case .poundImageLiteralKeyword: return true - case .poundColorLiteralKeyword: return true case .poundHasSymbolKeyword: return true case .integerLiteral: return false case .floatingLiteral: return false @@ -1708,11 +1487,6 @@ public enum RawTokenKind: Equatable, Hashable { case .trueKeyword: return false case .tryKeyword: return false case .throwsKeyword: return false - case .__file__Keyword: return false - case .__line__Keyword: return false - case .__column__Keyword: return false - case .__function__Keyword: return false - case .__dso_handle__Keyword: return false case .wildcardKeyword: return false case .leftParen: return true case .rightParen: return true @@ -1741,15 +1515,6 @@ public enum RawTokenKind: Equatable, Hashable { case .stringQuote: return true case .singleQuote: return true case .multilineStringQuote: return true - case .poundKeyPathKeyword: return false - case .poundLineKeyword: return false - case .poundSelectorKeyword: return false - case .poundFileKeyword: return false - case .poundFileIDKeyword: return false - case .poundFilePathKeyword: return false - case .poundColumnKeyword: return false - case .poundFunctionKeyword: return false - case .poundDsohandleKeyword: return false case .poundAssertKeyword: return false case .poundSourceLocationKeyword: return false case .poundWarningKeyword: return false @@ -1760,9 +1525,6 @@ public enum RawTokenKind: Equatable, Hashable { case .poundEndifKeyword: return false case .poundAvailableKeyword: return false case .poundUnavailableKeyword: return false - case .poundFileLiteralKeyword: return false - case .poundImageLiteralKeyword: return false - case .poundColorLiteralKeyword: return false case .poundHasSymbolKeyword: return false case .integerLiteral: return false case .floatingLiteral: return false @@ -1836,8 +1598,6 @@ public enum RawTokenKind: Equatable, Hashable { case "throw": self = .throwKeyword case "false": self = .falseKeyword case "super": self = .superKeyword - case "#line": self = .poundLineKeyword - case "#file": self = .poundFileKeyword case "#else": self = .poundElseKeyword default: return nil } @@ -1860,8 +1620,6 @@ public enum RawTokenKind: Equatable, Hashable { switch text { case "private": self = .privateKeyword case "default": self = .defaultKeyword - case "#fileID": self = .poundFileIDKeyword - case "#column": self = .poundColumnKeyword case "#assert": self = .poundAssertKeyword case "#elseif": self = .poundElseifKeyword default: return nil @@ -1873,9 +1631,6 @@ public enum RawTokenKind: Equatable, Hashable { case "internal": self = .internalKeyword case "continue": self = .continueKeyword case "rethrows": self = .rethrowsKeyword - case "__FILE__": self = .__file__Keyword - case "__LINE__": self = .__line__Keyword - case "#keyPath": self = .poundKeyPathKeyword case "#warning": self = .poundWarningKeyword default: return nil } @@ -1884,15 +1639,10 @@ public enum RawTokenKind: Equatable, Hashable { case "extension": self = .extensionKeyword case "subscript": self = .subscriptKeyword case "typealias": self = .typealiasKeyword - case "#selector": self = .poundSelectorKeyword - case "#filePath": self = .poundFilePathKeyword - case "#function": self = .poundFunctionKeyword default: return nil } case 10: switch text { - case "__COLUMN__": self = .__column__Keyword - case "#dsohandle": self = .poundDsohandleKeyword case "#available": self = .poundAvailableKeyword default: return nil } @@ -1905,21 +1655,12 @@ public enum RawTokenKind: Equatable, Hashable { } case 12: switch text { - case "__FUNCTION__": self = .__function__Keyword case "#unavailable": self = .poundUnavailableKeyword - case "#fileLiteral": self = .poundFileLiteralKeyword - default: return nil - } - case 13: - switch text { - case "#imageLiteral": self = .poundImageLiteralKeyword - case "#colorLiteral": self = .poundColorLiteralKeyword default: return nil } case 14: switch text { case "associatedtype": self = .associatedtypeKeyword - case "__DSO_HANDLE__": self = .__dso_handle__Keyword default: return nil } case 15: @@ -2098,21 +1839,6 @@ extension TokenKind { case .throwsKeyword: assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) return .throwsKeyword - case .__file__Keyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .__file__Keyword - case .__line__Keyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .__line__Keyword - case .__column__Keyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .__column__Keyword - case .__function__Keyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .__function__Keyword - case .__dso_handle__Keyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .__dso_handle__Keyword case .wildcardKeyword: assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) return .wildcardKeyword @@ -2197,33 +1923,6 @@ extension TokenKind { case .multilineStringQuote: assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) return .multilineStringQuote - case .poundKeyPathKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundKeyPathKeyword - case .poundLineKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundLineKeyword - case .poundSelectorKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundSelectorKeyword - case .poundFileKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundFileKeyword - case .poundFileIDKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundFileIDKeyword - case .poundFilePathKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundFilePathKeyword - case .poundColumnKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundColumnKeyword - case .poundFunctionKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundFunctionKeyword - case .poundDsohandleKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundDsohandleKeyword case .poundAssertKeyword: assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) return .poundAssertKeyword @@ -2254,15 +1953,6 @@ extension TokenKind { case .poundUnavailableKeyword: assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) return .poundUnavailableKeyword - case .poundFileLiteralKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundFileLiteralKeyword - case .poundImageLiteralKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundImageLiteralKeyword - case .poundColorLiteralKeyword: - assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) - return .poundColorLiteralKeyword case .poundHasSymbolKeyword: assert(text.isEmpty || rawKind.defaultText.map(String.init) == text) return .poundHasSymbolKeyword @@ -2362,11 +2052,6 @@ extension TokenKind { case .trueKeyword: return (.trueKeyword, nil) case .tryKeyword: return (.tryKeyword, nil) case .throwsKeyword: return (.throwsKeyword, nil) - case .__file__Keyword: return (.__file__Keyword, nil) - case .__line__Keyword: return (.__line__Keyword, nil) - case .__column__Keyword: return (.__column__Keyword, nil) - case .__function__Keyword: return (.__function__Keyword, nil) - case .__dso_handle__Keyword: return (.__dso_handle__Keyword, nil) case .wildcardKeyword: return (.wildcardKeyword, nil) case .leftParen: return (.leftParen, nil) case .rightParen: return (.rightParen, nil) @@ -2395,15 +2080,6 @@ extension TokenKind { case .stringQuote: return (.stringQuote, nil) case .singleQuote: return (.singleQuote, nil) case .multilineStringQuote: return (.multilineStringQuote, nil) - case .poundKeyPathKeyword: return (.poundKeyPathKeyword, nil) - case .poundLineKeyword: return (.poundLineKeyword, nil) - case .poundSelectorKeyword: return (.poundSelectorKeyword, nil) - case .poundFileKeyword: return (.poundFileKeyword, nil) - case .poundFileIDKeyword: return (.poundFileIDKeyword, nil) - case .poundFilePathKeyword: return (.poundFilePathKeyword, nil) - case .poundColumnKeyword: return (.poundColumnKeyword, nil) - case .poundFunctionKeyword: return (.poundFunctionKeyword, nil) - case .poundDsohandleKeyword: return (.poundDsohandleKeyword, nil) case .poundAssertKeyword: return (.poundAssertKeyword, nil) case .poundSourceLocationKeyword: return (.poundSourceLocationKeyword, nil) case .poundWarningKeyword: return (.poundWarningKeyword, nil) @@ -2414,9 +2090,6 @@ extension TokenKind { case .poundEndifKeyword: return (.poundEndifKeyword, nil) case .poundAvailableKeyword: return (.poundAvailableKeyword, nil) case .poundUnavailableKeyword: return (.poundUnavailableKeyword, nil) - case .poundFileLiteralKeyword: return (.poundFileLiteralKeyword, nil) - case .poundImageLiteralKeyword: return (.poundImageLiteralKeyword, nil) - case .poundColorLiteralKeyword: return (.poundColorLiteralKeyword, nil) case .poundHasSymbolKeyword: return (.poundHasSymbolKeyword, nil) case .integerLiteral(let str): return (.integerLiteral, str) case .floatingLiteral(let str): return (.floatingLiteral, str) diff --git a/Sources/SwiftSyntax/gyb_generated/Tokens.swift b/Sources/SwiftSyntax/gyb_generated/Tokens.swift index bfeca965815..68cf8f01bee 100644 --- a/Sources/SwiftSyntax/gyb_generated/Tokens.swift +++ b/Sources/SwiftSyntax/gyb_generated/Tokens.swift @@ -658,66 +658,6 @@ extension TokenSyntax { presence: presence ) } - public static func __file__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .__file__Keyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func __line__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .__line__Keyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func __column__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .__column__Keyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func __function__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .__function__Keyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func __dso_handle__Keyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .__dso_handle__Keyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } public static func wildcardKeyword( leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], @@ -1054,114 +994,6 @@ extension TokenSyntax { presence: presence ) } - public static func poundKeyPathKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundKeyPathKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundLineKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundLineKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundSelectorKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundSelectorKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundFileKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundFileKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundFileIDKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundFileIDKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundFilePathKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundFilePathKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundColumnKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundColumnKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundFunctionKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundFunctionKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundDsohandleKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundDsohandleKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } public static func poundAssertKeyword( leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], @@ -1282,42 +1114,6 @@ extension TokenSyntax { presence: presence ) } - public static func poundFileLiteralKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundFileLiteralKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundImageLiteralKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundImageLiteralKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } - public static func poundColorLiteralKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present - ) -> TokenSyntax { - return TokenSyntax( - .poundColorLiteralKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - ) - } public static func poundHasSymbolKeyword( leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift index 5817c0deb67..d93c446b5b7 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift @@ -296,136 +296,6 @@ extension InOutExprSyntax: CustomReflectable { } } -// MARK: - PoundColumnExprSyntax - -public struct PoundColumnExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .poundColumnExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `PoundColumnExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .poundColumnExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforePoundColumn: UnexpectedNodesSyntax? = nil, - poundColumn: TokenSyntax, - _ unexpectedAfterPoundColumn: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundColumn?.raw, - poundColumn.raw, - unexpectedAfterPoundColumn?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundColumnExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforePoundColumn: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforePoundColumn(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforePoundColumn` replaced. - /// - param newChild: The new `unexpectedBeforePoundColumn` to replace the node's - /// current `unexpectedBeforePoundColumn`, if present. - public func withUnexpectedBeforePoundColumn(_ newChild: UnexpectedNodesSyntax?) -> PoundColumnExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundColumnExprSyntax(newData) - } - - public var poundColumn: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withPoundColumn(value) - } - } - - /// Returns a copy of the receiver with its `poundColumn` replaced. - /// - param newChild: The new `poundColumn` to replace the node's - /// current `poundColumn`, if present. - public func withPoundColumn(_ newChild: TokenSyntax?) -> PoundColumnExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundColumnKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundColumnExprSyntax(newData) - } - - public var unexpectedAfterPoundColumn: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterPoundColumn(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterPoundColumn` replaced. - /// - param newChild: The new `unexpectedAfterPoundColumn` to replace the node's - /// current `unexpectedAfterPoundColumn`, if present. - public func withUnexpectedAfterPoundColumn(_ newChild: UnexpectedNodesSyntax?) -> PoundColumnExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundColumnExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforePoundColumn, - \Self.poundColumn, - \Self.unexpectedAfterPoundColumn, - ]) - } - - 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 PoundColumnExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforePoundColumn": unexpectedBeforePoundColumn.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundColumn": Syntax(poundColumn).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPoundColumn": unexpectedAfterPoundColumn.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - // MARK: - TryExprSyntax public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { @@ -1882,239 +1752,157 @@ extension SequenceExprSyntax: CustomReflectable { } } -// MARK: - PoundLineExprSyntax +// MARK: - SymbolicReferenceExprSyntax -public struct PoundLineExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct SymbolicReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundLineExpr else { return nil } + guard node.raw.kind == .symbolicReferenceExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PoundLineExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `SymbolicReferenceExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .poundLineExpr) + assert(data.raw.kind == .symbolicReferenceExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforePoundLine: UnexpectedNodesSyntax? = nil, - poundLine: TokenSyntax, - _ unexpectedAfterPoundLine: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax?, + _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePoundLine?.raw, - poundLine.raw, - unexpectedAfterPoundLine?.raw, + unexpectedBeforeIdentifier?.raw, + identifier.raw, + unexpectedBetweenIdentifierAndGenericArgumentClause?.raw, + genericArgumentClause?.raw, + unexpectedAfterGenericArgumentClause?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundLineExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.symbolicReferenceExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePoundLine: UnexpectedNodesSyntax? { + public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundLine(value) + self = withUnexpectedBeforeIdentifier(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundLine` replaced. - /// - param newChild: The new `unexpectedBeforePoundLine` to replace the node's - /// current `unexpectedBeforePoundLine`, if present. - public func withUnexpectedBeforePoundLine(_ newChild: UnexpectedNodesSyntax?) -> PoundLineExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeIdentifier` replaced. + /// - param newChild: The new `unexpectedBeforeIdentifier` to replace the node's + /// current `unexpectedBeforeIdentifier`, if present. + public func withUnexpectedBeforeIdentifier(_ newChild: UnexpectedNodesSyntax?) -> SymbolicReferenceExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundLineExprSyntax(newData) + return SymbolicReferenceExprSyntax(newData) } - public var poundLine: TokenSyntax { + public var identifier: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withPoundLine(value) + self = withIdentifier(value) } } - /// Returns a copy of the receiver with its `poundLine` replaced. - /// - param newChild: The new `poundLine` to replace the node's - /// current `poundLine`, if present. - public func withPoundLine(_ newChild: TokenSyntax?) -> PoundLineExprSyntax { + /// Returns a copy of the receiver with its `identifier` replaced. + /// - param newChild: The new `identifier` to replace the node's + /// current `identifier`, if present. + public func withIdentifier(_ newChild: TokenSyntax?) -> SymbolicReferenceExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundLineKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundLineExprSyntax(newData) + return SymbolicReferenceExprSyntax(newData) } - public var unexpectedAfterPoundLine: UnexpectedNodesSyntax? { + public var unexpectedBetweenIdentifierAndGenericArgumentClause: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPoundLine(value) + self = withUnexpectedBetweenIdentifierAndGenericArgumentClause(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPoundLine` replaced. - /// - param newChild: The new `unexpectedAfterPoundLine` to replace the node's - /// current `unexpectedAfterPoundLine`, if present. - public func withUnexpectedAfterPoundLine(_ newChild: UnexpectedNodesSyntax?) -> PoundLineExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenIdentifierAndGenericArgumentClause` replaced. + /// - param newChild: The new `unexpectedBetweenIdentifierAndGenericArgumentClause` to replace the node's + /// current `unexpectedBetweenIdentifierAndGenericArgumentClause`, if present. + public func withUnexpectedBetweenIdentifierAndGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SymbolicReferenceExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundLineExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforePoundLine, - \Self.poundLine, - \Self.unexpectedAfterPoundLine, - ]) - } - - 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 PoundLineExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforePoundLine": unexpectedBeforePoundLine.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundLine": Syntax(poundLine).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPoundLine": unexpectedAfterPoundLine.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - PoundFileExprSyntax - -public struct PoundFileExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .poundFileExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `PoundFileExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .poundFileExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforePoundFile: UnexpectedNodesSyntax? = nil, - poundFile: TokenSyntax, - _ unexpectedAfterPoundFile: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundFile?.raw, - poundFile.raw, - unexpectedAfterPoundFile?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFileExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) + return SymbolicReferenceExprSyntax(newData) } - public var unexpectedBeforePoundFile: UnexpectedNodesSyntax? { + public var genericArgumentClause: GenericArgumentClauseSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) + return GenericArgumentClauseSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundFile(value) + self = withGenericArgumentClause(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundFile` replaced. - /// - param newChild: The new `unexpectedBeforePoundFile` to replace the node's - /// current `unexpectedBeforePoundFile`, if present. - public func withUnexpectedBeforePoundFile(_ newChild: UnexpectedNodesSyntax?) -> PoundFileExprSyntax { + /// Returns a copy of the receiver with its `genericArgumentClause` replaced. + /// - param newChild: The new `genericArgumentClause` to replace the node's + /// current `genericArgumentClause`, if present. + public func withGenericArgumentClause(_ newChild: GenericArgumentClauseSyntax?) -> SymbolicReferenceExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundFileExprSyntax(newData) - } - - public var poundFile: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withPoundFile(value) - } - } - - /// Returns a copy of the receiver with its `poundFile` replaced. - /// - param newChild: The new `poundFile` to replace the node's - /// current `poundFile`, if present. - public func withPoundFile(_ newChild: TokenSyntax?) -> PoundFileExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundFileKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundFileExprSyntax(newData) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return SymbolicReferenceExprSyntax(newData) } - public var unexpectedAfterPoundFile: UnexpectedNodesSyntax? { + public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPoundFile(value) + self = withUnexpectedAfterGenericArgumentClause(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPoundFile` replaced. - /// - param newChild: The new `unexpectedAfterPoundFile` to replace the node's - /// current `unexpectedAfterPoundFile`, if present. - public func withUnexpectedAfterPoundFile(_ newChild: UnexpectedNodesSyntax?) -> PoundFileExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterGenericArgumentClause` replaced. + /// - param newChild: The new `unexpectedAfterGenericArgumentClause` to replace the node's + /// current `unexpectedAfterGenericArgumentClause`, if present. + public func withUnexpectedAfterGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SymbolicReferenceExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundFileExprSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return SymbolicReferenceExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundFile, - \Self.poundFile, - \Self.unexpectedAfterPoundFile, + \Self.unexpectedBeforeIdentifier, + \Self.identifier, + \Self.unexpectedBetweenIdentifierAndGenericArgumentClause, + \Self.genericArgumentClause, + \Self.unexpectedAfterGenericArgumentClause, ]) } @@ -2126,125 +1914,179 @@ public struct PoundFileExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 2: return nil + case 3: + return nil + case 4: + return nil default: fatalError("Invalid index") } } } -extension PoundFileExprSyntax: CustomReflectable { +extension SymbolicReferenceExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundFile": unexpectedBeforePoundFile.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundFile": Syntax(poundFile).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPoundFile": unexpectedAfterPoundFile.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeIdentifier": unexpectedBeforeIdentifier.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "identifier": Syntax(identifier).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenIdentifierAndGenericArgumentClause": unexpectedBetweenIdentifierAndGenericArgumentClause.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: - PoundFileIDExprSyntax +// MARK: - PrefixOperatorExprSyntax -public struct PoundFileIDExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundFileIDExpr else { return nil } + guard node.raw.kind == .prefixOperatorExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PoundFileIDExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `PrefixOperatorExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .poundFileIDExpr) + assert(data.raw.kind == .prefixOperatorExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforePoundFileID: UnexpectedNodesSyntax? = nil, - poundFileID: TokenSyntax, - _ unexpectedAfterPoundFileID: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, + operatorToken: TokenSyntax?, + _ unexpectedBetweenOperatorTokenAndPostfixExpression: UnexpectedNodesSyntax? = nil, + postfixExpression: ExprSyntax, + _ unexpectedAfterPostfixExpression: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePoundFileID?.raw, - poundFileID.raw, - unexpectedAfterPoundFileID?.raw, + unexpectedBeforeOperatorToken?.raw, + operatorToken?.raw, + unexpectedBetweenOperatorTokenAndPostfixExpression?.raw, + postfixExpression.raw, + unexpectedAfterPostfixExpression?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFileIDExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.prefixOperatorExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePoundFileID: UnexpectedNodesSyntax? { + public var unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundFileID(value) + self = withUnexpectedBeforeOperatorToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundFileID` replaced. - /// - param newChild: The new `unexpectedBeforePoundFileID` to replace the node's - /// current `unexpectedBeforePoundFileID`, if present. - public func withUnexpectedBeforePoundFileID(_ newChild: UnexpectedNodesSyntax?) -> PoundFileIDExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeOperatorToken` replaced. + /// - param newChild: The new `unexpectedBeforeOperatorToken` to replace the node's + /// current `unexpectedBeforeOperatorToken`, if present. + public func withUnexpectedBeforeOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> PrefixOperatorExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundFileIDExprSyntax(newData) + return PrefixOperatorExprSyntax(newData) } - public var poundFileID: TokenSyntax { + public var operatorToken: TokenSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withPoundFileID(value) + self = withOperatorToken(value) } } - /// Returns a copy of the receiver with its `poundFileID` replaced. - /// - param newChild: The new `poundFileID` to replace the node's - /// current `poundFileID`, if present. - public func withPoundFileID(_ newChild: TokenSyntax?) -> PoundFileIDExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundFileIDKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundFileIDExprSyntax(newData) - } + /// Returns a copy of the receiver with its `operatorToken` replaced. + /// - param newChild: The new `operatorToken` to replace the node's + /// current `operatorToken`, if present. + public func withOperatorToken(_ newChild: TokenSyntax?) -> PrefixOperatorExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return PrefixOperatorExprSyntax(newData) + } - public var unexpectedAfterPoundFileID: UnexpectedNodesSyntax? { + public var unexpectedBetweenOperatorTokenAndPostfixExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPoundFileID(value) + self = withUnexpectedBetweenOperatorTokenAndPostfixExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPoundFileID` replaced. - /// - param newChild: The new `unexpectedAfterPoundFileID` to replace the node's - /// current `unexpectedAfterPoundFileID`, if present. - public func withUnexpectedAfterPoundFileID(_ newChild: UnexpectedNodesSyntax?) -> PoundFileIDExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenOperatorTokenAndPostfixExpression` replaced. + /// - param newChild: The new `unexpectedBetweenOperatorTokenAndPostfixExpression` to replace the node's + /// current `unexpectedBetweenOperatorTokenAndPostfixExpression`, if present. + public func withUnexpectedBetweenOperatorTokenAndPostfixExpression(_ newChild: UnexpectedNodesSyntax?) -> PrefixOperatorExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundFileIDExprSyntax(newData) + return PrefixOperatorExprSyntax(newData) + } + + public var postfixExpression: ExprSyntax { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + return ExprSyntax(childData!) + } + set(value) { + self = withPostfixExpression(value) + } + } + + /// Returns a copy of the receiver with its `postfixExpression` replaced. + /// - param newChild: The new `postfixExpression` to replace the node's + /// current `postfixExpression`, if present. + public func withPostfixExpression(_ newChild: ExprSyntax?) -> PrefixOperatorExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return PrefixOperatorExprSyntax(newData) + } + + public var unexpectedAfterPostfixExpression: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterPostfixExpression(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterPostfixExpression` replaced. + /// - param newChild: The new `unexpectedAfterPostfixExpression` to replace the node's + /// current `unexpectedAfterPostfixExpression`, if present. + public func withUnexpectedAfterPostfixExpression(_ newChild: UnexpectedNodesSyntax?) -> PrefixOperatorExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return PrefixOperatorExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundFileID, - \Self.poundFileID, - \Self.unexpectedAfterPoundFileID, + \Self.unexpectedBeforeOperatorToken, + \Self.operatorToken, + \Self.unexpectedBetweenOperatorTokenAndPostfixExpression, + \Self.postfixExpression, + \Self.unexpectedAfterPostfixExpression, ]) } @@ -2256,125 +2098,131 @@ public struct PoundFileIDExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 2: return nil + case 3: + return nil + case 4: + return nil default: fatalError("Invalid index") } } } -extension PoundFileIDExprSyntax: CustomReflectable { +extension PrefixOperatorExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundFileID": unexpectedBeforePoundFileID.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundFileID": Syntax(poundFileID).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPoundFileID": unexpectedAfterPoundFileID.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeOperatorToken": unexpectedBeforeOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "operatorToken": operatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenOperatorTokenAndPostfixExpression": unexpectedBetweenOperatorTokenAndPostfixExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "postfixExpression": Syntax(postfixExpression).asProtocol(SyntaxProtocol.self), + "unexpectedAfterPostfixExpression": unexpectedAfterPostfixExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - PoundFilePathExprSyntax +// MARK: - BinaryOperatorExprSyntax -public struct PoundFilePathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundFilePathExpr else { return nil } + guard node.raw.kind == .binaryOperatorExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PoundFilePathExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `BinaryOperatorExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .poundFilePathExpr) + assert(data.raw.kind == .binaryOperatorExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforePoundFilePath: UnexpectedNodesSyntax? = nil, - poundFilePath: TokenSyntax, - _ unexpectedAfterPoundFilePath: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, + operatorToken: TokenSyntax, + _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePoundFilePath?.raw, - poundFilePath.raw, - unexpectedAfterPoundFilePath?.raw, + unexpectedBeforeOperatorToken?.raw, + operatorToken.raw, + unexpectedAfterOperatorToken?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFilePathExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.binaryOperatorExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePoundFilePath: UnexpectedNodesSyntax? { + public var unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundFilePath(value) + self = withUnexpectedBeforeOperatorToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundFilePath` replaced. - /// - param newChild: The new `unexpectedBeforePoundFilePath` to replace the node's - /// current `unexpectedBeforePoundFilePath`, if present. - public func withUnexpectedBeforePoundFilePath(_ newChild: UnexpectedNodesSyntax?) -> PoundFilePathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeOperatorToken` replaced. + /// - param newChild: The new `unexpectedBeforeOperatorToken` to replace the node's + /// current `unexpectedBeforeOperatorToken`, if present. + public func withUnexpectedBeforeOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> BinaryOperatorExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundFilePathExprSyntax(newData) + return BinaryOperatorExprSyntax(newData) } - public var poundFilePath: TokenSyntax { + public var operatorToken: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withPoundFilePath(value) + self = withOperatorToken(value) } } - /// Returns a copy of the receiver with its `poundFilePath` replaced. - /// - param newChild: The new `poundFilePath` to replace the node's - /// current `poundFilePath`, if present. - public func withPoundFilePath(_ newChild: TokenSyntax?) -> PoundFilePathExprSyntax { + /// Returns a copy of the receiver with its `operatorToken` replaced. + /// - param newChild: The new `operatorToken` to replace the node's + /// current `operatorToken`, if present. + public func withOperatorToken(_ newChild: TokenSyntax?) -> BinaryOperatorExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundFilePathKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundFilePathExprSyntax(newData) + return BinaryOperatorExprSyntax(newData) } - public var unexpectedAfterPoundFilePath: UnexpectedNodesSyntax? { + public var unexpectedAfterOperatorToken: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPoundFilePath(value) + self = withUnexpectedAfterOperatorToken(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPoundFilePath` replaced. - /// - param newChild: The new `unexpectedAfterPoundFilePath` to replace the node's - /// current `unexpectedAfterPoundFilePath`, if present. - public func withUnexpectedAfterPoundFilePath(_ newChild: UnexpectedNodesSyntax?) -> PoundFilePathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterOperatorToken` replaced. + /// - param newChild: The new `unexpectedAfterOperatorToken` to replace the node's + /// current `unexpectedAfterOperatorToken`, if present. + public func withUnexpectedAfterOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> BinaryOperatorExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundFilePathExprSyntax(newData) + return BinaryOperatorExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundFilePath, - \Self.poundFilePath, - \Self.unexpectedAfterPoundFilePath, + \Self.unexpectedBeforeOperatorToken, + \Self.operatorToken, + \Self.unexpectedAfterOperatorToken, ]) } @@ -2392,427 +2240,451 @@ public struct PoundFilePathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension PoundFilePathExprSyntax: CustomReflectable { +extension BinaryOperatorExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundFilePath": unexpectedBeforePoundFilePath.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundFilePath": Syntax(poundFilePath).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPoundFilePath": unexpectedAfterPoundFilePath.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeOperatorToken": unexpectedBeforeOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "operatorToken": Syntax(operatorToken).asProtocol(SyntaxProtocol.self), + "unexpectedAfterOperatorToken": unexpectedAfterOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - PoundFunctionExprSyntax +// MARK: - ArrowExprSyntax -public struct PoundFunctionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundFunctionExpr else { return nil } + guard node.raw.kind == .arrowExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PoundFunctionExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ArrowExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .poundFunctionExpr) + assert(data.raw.kind == .arrowExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforePoundFunction: UnexpectedNodesSyntax? = nil, - poundFunction: TokenSyntax, - _ unexpectedAfterPoundFunction: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeAsyncKeyword: UnexpectedNodesSyntax? = nil, + asyncKeyword: TokenSyntax?, + _ unexpectedBetweenAsyncKeywordAndThrowsToken: UnexpectedNodesSyntax? = nil, + throwsToken: TokenSyntax?, + _ unexpectedBetweenThrowsTokenAndArrowToken: UnexpectedNodesSyntax? = nil, + arrowToken: TokenSyntax, + _ unexpectedAfterArrowToken: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePoundFunction?.raw, - poundFunction.raw, - unexpectedAfterPoundFunction?.raw, + unexpectedBeforeAsyncKeyword?.raw, + asyncKeyword?.raw, + unexpectedBetweenAsyncKeywordAndThrowsToken?.raw, + throwsToken?.raw, + unexpectedBetweenThrowsTokenAndArrowToken?.raw, + arrowToken.raw, + unexpectedAfterArrowToken?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundFunctionExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.arrowExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePoundFunction: UnexpectedNodesSyntax? { + public var unexpectedBeforeAsyncKeyword: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundFunction(value) + self = withUnexpectedBeforeAsyncKeyword(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundFunction` replaced. - /// - param newChild: The new `unexpectedBeforePoundFunction` to replace the node's - /// current `unexpectedBeforePoundFunction`, if present. - public func withUnexpectedBeforePoundFunction(_ newChild: UnexpectedNodesSyntax?) -> PoundFunctionExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAsyncKeyword` replaced. + /// - param newChild: The new `unexpectedBeforeAsyncKeyword` to replace the node's + /// current `unexpectedBeforeAsyncKeyword`, if present. + public func withUnexpectedBeforeAsyncKeyword(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundFunctionExprSyntax(newData) + return ArrowExprSyntax(newData) } - public var poundFunction: TokenSyntax { + public var asyncKeyword: TokenSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withPoundFunction(value) + self = withAsyncKeyword(value) } } - /// Returns a copy of the receiver with its `poundFunction` replaced. - /// - param newChild: The new `poundFunction` to replace the node's - /// current `poundFunction`, if present. - public func withPoundFunction(_ newChild: TokenSyntax?) -> PoundFunctionExprSyntax { + /// Returns a copy of the receiver with its `asyncKeyword` replaced. + /// - param newChild: The new `asyncKeyword` to replace the node's + /// current `asyncKeyword`, if present. + public func withAsyncKeyword(_ newChild: TokenSyntax?) -> ArrowExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundFunctionKeyword, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundFunctionExprSyntax(newData) + return ArrowExprSyntax(newData) } - public var unexpectedAfterPoundFunction: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncKeywordAndThrowsToken: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPoundFunction(value) + self = withUnexpectedBetweenAsyncKeywordAndThrowsToken(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPoundFunction` replaced. - /// - param newChild: The new `unexpectedAfterPoundFunction` to replace the node's - /// current `unexpectedAfterPoundFunction`, if present. - public func withUnexpectedAfterPoundFunction(_ newChild: UnexpectedNodesSyntax?) -> PoundFunctionExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAsyncKeywordAndThrowsToken` replaced. + /// - param newChild: The new `unexpectedBetweenAsyncKeywordAndThrowsToken` to replace the node's + /// current `unexpectedBetweenAsyncKeywordAndThrowsToken`, if present. + public func withUnexpectedBetweenAsyncKeywordAndThrowsToken(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundFunctionExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforePoundFunction, - \Self.poundFunction, - \Self.unexpectedAfterPoundFunction, - ]) + return ArrowExprSyntax(newData) } - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - default: - fatalError("Invalid index") + public var throwsToken: TokenSyntax? { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withThrowsToken(value) } - } -} - -extension PoundFunctionExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforePoundFunction": unexpectedBeforePoundFunction.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundFunction": Syntax(poundFunction).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPoundFunction": unexpectedAfterPoundFunction.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - PoundDsohandleExprSyntax - -public struct PoundDsohandleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .poundDsohandleExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `PoundDsohandleExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .poundDsohandleExpr) - self._syntaxNode = Syntax(data) } - public init( - _ unexpectedBeforePoundDsohandle: UnexpectedNodesSyntax? = nil, - poundDsohandle: TokenSyntax, - _ unexpectedAfterPoundDsohandle: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforePoundDsohandle?.raw, - poundDsohandle.raw, - unexpectedAfterPoundDsohandle?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.poundDsohandleExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) + /// Returns a copy of the receiver with its `throwsToken` replaced. + /// - param newChild: The new `throwsToken` to replace the node's + /// current `throwsToken`, if present. + public func withThrowsToken(_ newChild: TokenSyntax?) -> ArrowExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return ArrowExprSyntax(newData) } - public var unexpectedBeforePoundDsohandle: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsTokenAndArrowToken: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundDsohandle(value) + self = withUnexpectedBetweenThrowsTokenAndArrowToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundDsohandle` replaced. - /// - param newChild: The new `unexpectedBeforePoundDsohandle` to replace the node's - /// current `unexpectedBeforePoundDsohandle`, if present. - public func withUnexpectedBeforePoundDsohandle(_ newChild: UnexpectedNodesSyntax?) -> PoundDsohandleExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenThrowsTokenAndArrowToken` replaced. + /// - param newChild: The new `unexpectedBetweenThrowsTokenAndArrowToken` to replace the node's + /// current `unexpectedBetweenThrowsTokenAndArrowToken`, if present. + public func withUnexpectedBetweenThrowsTokenAndArrowToken(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PoundDsohandleExprSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return ArrowExprSyntax(newData) } - public var poundDsohandle: TokenSyntax { + public var arrowToken: TokenSyntax { get { - let childData = data.child(at: 1, parent: Syntax(self)) + let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withPoundDsohandle(value) + self = withArrowToken(value) } } - /// Returns a copy of the receiver with its `poundDsohandle` replaced. - /// - param newChild: The new `poundDsohandle` to replace the node's - /// current `poundDsohandle`, if present. - public func withPoundDsohandle(_ newChild: TokenSyntax?) -> PoundDsohandleExprSyntax { + /// Returns a copy of the receiver with its `arrowToken` replaced. + /// - param newChild: The new `arrowToken` to replace the node's + /// current `arrowToken`, if present. + public func withArrowToken(_ newChild: TokenSyntax?) -> ArrowExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundDsohandleKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PoundDsohandleExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.arrow, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return ArrowExprSyntax(newData) } - public var unexpectedAfterPoundDsohandle: UnexpectedNodesSyntax? { + public var unexpectedAfterArrowToken: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPoundDsohandle(value) + self = withUnexpectedAfterArrowToken(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPoundDsohandle` replaced. - /// - param newChild: The new `unexpectedAfterPoundDsohandle` to replace the node's - /// current `unexpectedAfterPoundDsohandle`, if present. - public func withUnexpectedAfterPoundDsohandle(_ newChild: UnexpectedNodesSyntax?) -> PoundDsohandleExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterArrowToken` replaced. + /// - param newChild: The new `unexpectedAfterArrowToken` to replace the node's + /// current `unexpectedAfterArrowToken`, if present. + public func withUnexpectedAfterArrowToken(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PoundDsohandleExprSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return ArrowExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundDsohandle, - \Self.poundDsohandle, - \Self.unexpectedAfterPoundDsohandle, - ]) - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: + \Self.unexpectedBeforeAsyncKeyword, + \Self.asyncKeyword, + \Self.unexpectedBetweenAsyncKeywordAndThrowsToken, + \Self.throwsToken, + \Self.unexpectedBetweenThrowsTokenAndArrowToken, + \Self.arrowToken, + \Self.unexpectedAfterArrowToken, + ]) + } + + 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 PoundDsohandleExprSyntax: CustomReflectable { +extension ArrowExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundDsohandle": unexpectedBeforePoundDsohandle.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundDsohandle": Syntax(poundDsohandle).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPoundDsohandle": unexpectedAfterPoundDsohandle.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeAsyncKeyword": unexpectedBeforeAsyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "asyncKeyword": asyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenAsyncKeywordAndThrowsToken": unexpectedBetweenAsyncKeywordAndThrowsToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "throwsToken": throwsToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenThrowsTokenAndArrowToken": unexpectedBetweenThrowsTokenAndArrowToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "arrowToken": Syntax(arrowToken).asProtocol(SyntaxProtocol.self), + "unexpectedAfterArrowToken": unexpectedAfterArrowToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - SymbolicReferenceExprSyntax +// MARK: - InfixOperatorExprSyntax -public struct SymbolicReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .symbolicReferenceExpr else { return nil } + guard node.raw.kind == .infixOperatorExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SymbolicReferenceExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `InfixOperatorExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .symbolicReferenceExpr) + assert(data.raw.kind == .infixOperatorExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, - genericArgumentClause: GenericArgumentClauseSyntax?, - _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeLeftOperand: UnexpectedNodesSyntax? = nil, + leftOperand: ExprSyntax, + _ unexpectedBetweenLeftOperandAndOperatorOperand: UnexpectedNodesSyntax? = nil, + operatorOperand: ExprSyntax, + _ unexpectedBetweenOperatorOperandAndRightOperand: UnexpectedNodesSyntax? = nil, + rightOperand: ExprSyntax, + _ unexpectedAfterRightOperand: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedAfterGenericArgumentClause?.raw, + unexpectedBeforeLeftOperand?.raw, + leftOperand.raw, + unexpectedBetweenLeftOperandAndOperatorOperand?.raw, + operatorOperand.raw, + unexpectedBetweenOperatorOperandAndRightOperand?.raw, + rightOperand.raw, + unexpectedAfterRightOperand?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.symbolicReferenceExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.infixOperatorExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftOperand: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeIdentifier(value) + self = withUnexpectedBeforeLeftOperand(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeIdentifier` replaced. - /// - param newChild: The new `unexpectedBeforeIdentifier` to replace the node's - /// current `unexpectedBeforeIdentifier`, if present. - public func withUnexpectedBeforeIdentifier(_ newChild: UnexpectedNodesSyntax?) -> SymbolicReferenceExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftOperand` replaced. + /// - param newChild: The new `unexpectedBeforeLeftOperand` to replace the node's + /// current `unexpectedBeforeLeftOperand`, if present. + public func withUnexpectedBeforeLeftOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SymbolicReferenceExprSyntax(newData) + return InfixOperatorExprSyntax(newData) } - public var identifier: TokenSyntax { + public var leftOperand: ExprSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withIdentifier(value) + self = withLeftOperand(value) } } - /// Returns a copy of the receiver with its `identifier` replaced. - /// - param newChild: The new `identifier` to replace the node's - /// current `identifier`, if present. - public func withIdentifier(_ newChild: TokenSyntax?) -> SymbolicReferenceExprSyntax { + /// Returns a copy of the receiver with its `leftOperand` replaced. + /// - param newChild: The new `leftOperand` to replace the node's + /// current `leftOperand`, if present. + public func withLeftOperand(_ newChild: ExprSyntax?) -> InfixOperatorExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SymbolicReferenceExprSyntax(newData) + return InfixOperatorExprSyntax(newData) } - public var unexpectedBetweenIdentifierAndGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftOperandAndOperatorOperand: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenIdentifierAndGenericArgumentClause(value) + self = withUnexpectedBetweenLeftOperandAndOperatorOperand(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenIdentifierAndGenericArgumentClause` replaced. - /// - param newChild: The new `unexpectedBetweenIdentifierAndGenericArgumentClause` to replace the node's - /// current `unexpectedBetweenIdentifierAndGenericArgumentClause`, if present. - public func withUnexpectedBetweenIdentifierAndGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SymbolicReferenceExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftOperandAndOperatorOperand` replaced. + /// - param newChild: The new `unexpectedBetweenLeftOperandAndOperatorOperand` to replace the node's + /// current `unexpectedBetweenLeftOperandAndOperatorOperand`, if present. + public func withUnexpectedBetweenLeftOperandAndOperatorOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SymbolicReferenceExprSyntax(newData) + return InfixOperatorExprSyntax(newData) } - public var genericArgumentClause: GenericArgumentClauseSyntax? { + public var operatorOperand: ExprSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return GenericArgumentClauseSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withGenericArgumentClause(value) + self = withOperatorOperand(value) } } - /// Returns a copy of the receiver with its `genericArgumentClause` replaced. - /// - param newChild: The new `genericArgumentClause` to replace the node's - /// current `genericArgumentClause`, if present. - public func withGenericArgumentClause(_ newChild: GenericArgumentClauseSyntax?) -> SymbolicReferenceExprSyntax { + /// Returns a copy of the receiver with its `operatorOperand` replaced. + /// - param newChild: The new `operatorOperand` to replace the node's + /// current `operatorOperand`, if present. + public func withOperatorOperand(_ newChild: ExprSyntax?) -> InfixOperatorExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SymbolicReferenceExprSyntax(newData) + return InfixOperatorExprSyntax(newData) } - public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenOperatorOperandAndRightOperand: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterGenericArgumentClause(value) + self = withUnexpectedBetweenOperatorOperandAndRightOperand(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterGenericArgumentClause` replaced. - /// - param newChild: The new `unexpectedAfterGenericArgumentClause` to replace the node's - /// current `unexpectedAfterGenericArgumentClause`, if present. - public func withUnexpectedAfterGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SymbolicReferenceExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenOperatorOperandAndRightOperand` replaced. + /// - param newChild: The new `unexpectedBetweenOperatorOperandAndRightOperand` to replace the node's + /// current `unexpectedBetweenOperatorOperandAndRightOperand`, if present. + public func withUnexpectedBetweenOperatorOperandAndRightOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SymbolicReferenceExprSyntax(newData) + return InfixOperatorExprSyntax(newData) + } + + public var rightOperand: ExprSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return ExprSyntax(childData!) + } + set(value) { + self = withRightOperand(value) + } + } + + /// Returns a copy of the receiver with its `rightOperand` replaced. + /// - param newChild: The new `rightOperand` to replace the node's + /// current `rightOperand`, if present. + public func withRightOperand(_ newChild: ExprSyntax?) -> InfixOperatorExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return InfixOperatorExprSyntax(newData) + } + + public var unexpectedAfterRightOperand: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterRightOperand(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterRightOperand` replaced. + /// - param newChild: The new `unexpectedAfterRightOperand` to replace the node's + /// current `unexpectedAfterRightOperand`, if present. + public func withUnexpectedAfterRightOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return InfixOperatorExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIdentifier, - \Self.identifier, - \Self.unexpectedBetweenIdentifierAndGenericArgumentClause, - \Self.genericArgumentClause, - \Self.unexpectedAfterGenericArgumentClause, + \Self.unexpectedBeforeLeftOperand, + \Self.leftOperand, + \Self.unexpectedBetweenLeftOperandAndOperatorOperand, + \Self.operatorOperand, + \Self.unexpectedBetweenOperatorOperandAndRightOperand, + \Self.rightOperand, + \Self.unexpectedAfterRightOperand, ]) } @@ -2828,175 +2700,133 @@ public struct SymbolicReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 4: return nil + case 5: + return nil + case 6: + return nil default: fatalError("Invalid index") } } } -extension SymbolicReferenceExprSyntax: CustomReflectable { +extension InfixOperatorExprSyntax: 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), - "unexpectedBetweenIdentifierAndGenericArgumentClause": unexpectedBetweenIdentifierAndGenericArgumentClause.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, + "unexpectedBeforeLeftOperand": unexpectedBeforeLeftOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftOperand": Syntax(leftOperand).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftOperandAndOperatorOperand": unexpectedBetweenLeftOperandAndOperatorOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "operatorOperand": Syntax(operatorOperand).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenOperatorOperandAndRightOperand": unexpectedBetweenOperatorOperandAndRightOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightOperand": Syntax(rightOperand).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightOperand": unexpectedAfterRightOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - PrefixOperatorExprSyntax +// MARK: - FloatLiteralExprSyntax -public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .prefixOperatorExpr else { return nil } + guard node.raw.kind == .floatLiteralExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `PrefixOperatorExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `FloatLiteralExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .prefixOperatorExpr) + assert(data.raw.kind == .floatLiteralExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, - operatorToken: TokenSyntax?, - _ unexpectedBetweenOperatorTokenAndPostfixExpression: UnexpectedNodesSyntax? = nil, - postfixExpression: ExprSyntax, - _ unexpectedAfterPostfixExpression: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? = nil, + floatingDigits: TokenSyntax, + _ unexpectedAfterFloatingDigits: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeOperatorToken?.raw, - operatorToken?.raw, - unexpectedBetweenOperatorTokenAndPostfixExpression?.raw, - postfixExpression.raw, - unexpectedAfterPostfixExpression?.raw, + unexpectedBeforeFloatingDigits?.raw, + floatingDigits.raw, + unexpectedAfterFloatingDigits?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.prefixOperatorExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.floatLiteralExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? { + public var unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeOperatorToken(value) + self = withUnexpectedBeforeFloatingDigits(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeOperatorToken` replaced. - /// - param newChild: The new `unexpectedBeforeOperatorToken` to replace the node's - /// current `unexpectedBeforeOperatorToken`, if present. - public func withUnexpectedBeforeOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> PrefixOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeFloatingDigits` replaced. + /// - param newChild: The new `unexpectedBeforeFloatingDigits` to replace the node's + /// current `unexpectedBeforeFloatingDigits`, if present. + public func withUnexpectedBeforeFloatingDigits(_ newChild: UnexpectedNodesSyntax?) -> FloatLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PrefixOperatorExprSyntax(newData) + return FloatLiteralExprSyntax(newData) } - public var operatorToken: TokenSyntax? { + public var floatingDigits: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withOperatorToken(value) + self = withFloatingDigits(value) } } - /// Returns a copy of the receiver with its `operatorToken` replaced. - /// - param newChild: The new `operatorToken` to replace the node's - /// current `operatorToken`, if present. - public func withOperatorToken(_ newChild: TokenSyntax?) -> PrefixOperatorExprSyntax { + /// Returns a copy of the receiver with its `floatingDigits` replaced. + /// - param newChild: The new `floatingDigits` to replace the node's + /// current `floatingDigits`, if present. + public func withFloatingDigits(_ newChild: TokenSyntax?) -> FloatLiteralExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.floatingLiteral(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PrefixOperatorExprSyntax(newData) + return FloatLiteralExprSyntax(newData) } - public var unexpectedBetweenOperatorTokenAndPostfixExpression: UnexpectedNodesSyntax? { + public var unexpectedAfterFloatingDigits: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenOperatorTokenAndPostfixExpression(value) + self = withUnexpectedAfterFloatingDigits(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenOperatorTokenAndPostfixExpression` replaced. - /// - param newChild: The new `unexpectedBetweenOperatorTokenAndPostfixExpression` to replace the node's - /// current `unexpectedBetweenOperatorTokenAndPostfixExpression`, if present. - public func withUnexpectedBetweenOperatorTokenAndPostfixExpression(_ newChild: UnexpectedNodesSyntax?) -> PrefixOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterFloatingDigits` replaced. + /// - param newChild: The new `unexpectedAfterFloatingDigits` to replace the node's + /// current `unexpectedAfterFloatingDigits`, if present. + public func withUnexpectedAfterFloatingDigits(_ newChild: UnexpectedNodesSyntax?) -> FloatLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PrefixOperatorExprSyntax(newData) - } - - public var postfixExpression: ExprSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withPostfixExpression(value) - } - } - - /// Returns a copy of the receiver with its `postfixExpression` replaced. - /// - param newChild: The new `postfixExpression` to replace the node's - /// current `postfixExpression`, if present. - public func withPostfixExpression(_ newChild: ExprSyntax?) -> PrefixOperatorExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PrefixOperatorExprSyntax(newData) - } - - public var unexpectedAfterPostfixExpression: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterPostfixExpression(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterPostfixExpression` replaced. - /// - param newChild: The new `unexpectedAfterPostfixExpression` to replace the node's - /// current `unexpectedAfterPostfixExpression`, if present. - public func withUnexpectedAfterPostfixExpression(_ newChild: UnexpectedNodesSyntax?) -> PrefixOperatorExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PrefixOperatorExprSyntax(newData) + return FloatLiteralExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeOperatorToken, - \Self.operatorToken, - \Self.unexpectedBetweenOperatorTokenAndPostfixExpression, - \Self.postfixExpression, - \Self.unexpectedAfterPostfixExpression, + \Self.unexpectedBeforeFloatingDigits, + \Self.floatingDigits, + \Self.unexpectedAfterFloatingDigits, ]) } @@ -3008,357 +2838,238 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 2: return nil - case 3: - return nil - case 4: - return nil default: fatalError("Invalid index") } } } -extension PrefixOperatorExprSyntax: CustomReflectable { +extension FloatLiteralExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeOperatorToken": unexpectedBeforeOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "operatorToken": operatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenOperatorTokenAndPostfixExpression": unexpectedBetweenOperatorTokenAndPostfixExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "postfixExpression": Syntax(postfixExpression).asProtocol(SyntaxProtocol.self), - "unexpectedAfterPostfixExpression": unexpectedAfterPostfixExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeFloatingDigits": unexpectedBeforeFloatingDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "floatingDigits": Syntax(floatingDigits).asProtocol(SyntaxProtocol.self), + "unexpectedAfterFloatingDigits": unexpectedAfterFloatingDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - BinaryOperatorExprSyntax +// MARK: - TupleExprSyntax -public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .binaryOperatorExpr else { return nil } + guard node.raw.kind == .tupleExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `BinaryOperatorExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `TupleExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .binaryOperatorExpr) + assert(data.raw.kind == .tupleExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, - operatorToken: TokenSyntax, - _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax, + _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, + elementList: TupleExprElementListSyntax, + _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax, + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeOperatorToken?.raw, - operatorToken.raw, - unexpectedAfterOperatorToken?.raw, + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndElementList?.raw, + elementList.raw, + unexpectedBetweenElementListAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.binaryOperatorExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.tupleExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeOperatorToken(value) + self = withUnexpectedBeforeLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeOperatorToken` replaced. - /// - param newChild: The new `unexpectedBeforeOperatorToken` to replace the node's - /// current `unexpectedBeforeOperatorToken`, if present. - public func withUnexpectedBeforeOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> BinaryOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. + /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's + /// current `unexpectedBeforeLeftParen`, if present. + public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return BinaryOperatorExprSyntax(newData) + return TupleExprSyntax(newData) } - public var operatorToken: TokenSyntax { + public var leftParen: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withOperatorToken(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `operatorToken` replaced. - /// - param newChild: The new `operatorToken` to replace the node's - /// current `operatorToken`, if present. - public func withOperatorToken(_ newChild: TokenSyntax?) -> BinaryOperatorExprSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax?) -> TupleExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return BinaryOperatorExprSyntax(newData) + return TupleExprSyntax(newData) } - public var unexpectedAfterOperatorToken: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterOperatorToken(value) + self = withUnexpectedBetweenLeftParenAndElementList(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterOperatorToken` replaced. - /// - param newChild: The new `unexpectedAfterOperatorToken` to replace the node's - /// current `unexpectedAfterOperatorToken`, if present. - public func withUnexpectedAfterOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> BinaryOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndElementList` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndElementList` to replace the node's + /// current `unexpectedBetweenLeftParenAndElementList`, if present. + public func withUnexpectedBetweenLeftParenAndElementList(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return BinaryOperatorExprSyntax(newData) + return TupleExprSyntax(newData) } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeOperatorToken, - \Self.operatorToken, - \Self.unexpectedAfterOperatorToken, - ]) + public var elementList: TupleExprElementListSyntax { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + return TupleExprElementListSyntax(childData!) + } + set(value) { + self = withElementList(value) + } } - 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") + /// 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: TupleExprElementSyntax) -> TupleExprSyntax { + 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 TupleExprSyntax(newData) } -} -extension BinaryOperatorExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeOperatorToken": unexpectedBeforeOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "operatorToken": Syntax(operatorToken).asProtocol(SyntaxProtocol.self), - "unexpectedAfterOperatorToken": unexpectedAfterOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) + /// Returns a copy of the receiver with its `elementList` replaced. + /// - param newChild: The new `elementList` to replace the node's + /// current `elementList`, if present. + public func withElementList(_ newChild: TupleExprElementListSyntax?) -> TupleExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return TupleExprSyntax(newData) } -} -// MARK: - ArrowExprSyntax - -public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax + public var unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenElementListAndRightParen(value) + } + } - public init?(_ node: S) { - guard node.raw.kind == .arrowExpr else { return nil } - self._syntaxNode = node._syntaxNode + /// Returns a copy of the receiver with its `unexpectedBetweenElementListAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenElementListAndRightParen` to replace the node's + /// current `unexpectedBetweenElementListAndRightParen`, if present. + public func withUnexpectedBetweenElementListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return TupleExprSyntax(newData) } - /// Creates a `ArrowExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .arrowExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeAsyncKeyword: UnexpectedNodesSyntax? = nil, - asyncKeyword: TokenSyntax?, - _ unexpectedBetweenAsyncKeywordAndThrowsToken: UnexpectedNodesSyntax? = nil, - throwsToken: TokenSyntax?, - _ unexpectedBetweenThrowsTokenAndArrowToken: UnexpectedNodesSyntax? = nil, - arrowToken: TokenSyntax, - _ unexpectedAfterArrowToken: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeAsyncKeyword?.raw, - asyncKeyword?.raw, - unexpectedBetweenAsyncKeywordAndThrowsToken?.raw, - throwsToken?.raw, - unexpectedBetweenThrowsTokenAndArrowToken?.raw, - arrowToken.raw, - unexpectedAfterArrowToken?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.arrowExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeAsyncKeyword: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeAsyncKeyword(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeAsyncKeyword` replaced. - /// - param newChild: The new `unexpectedBeforeAsyncKeyword` to replace the node's - /// current `unexpectedBeforeAsyncKeyword`, if present. - public func withUnexpectedBeforeAsyncKeyword(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ArrowExprSyntax(newData) - } - - public var asyncKeyword: TokenSyntax? { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withAsyncKeyword(value) - } - } - - /// Returns a copy of the receiver with its `asyncKeyword` replaced. - /// - param newChild: The new `asyncKeyword` to replace the node's - /// current `asyncKeyword`, if present. - public func withAsyncKeyword(_ newChild: TokenSyntax?) -> ArrowExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ArrowExprSyntax(newData) - } - - public var unexpectedBetweenAsyncKeywordAndThrowsToken: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenAsyncKeywordAndThrowsToken(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenAsyncKeywordAndThrowsToken` replaced. - /// - param newChild: The new `unexpectedBetweenAsyncKeywordAndThrowsToken` to replace the node's - /// current `unexpectedBetweenAsyncKeywordAndThrowsToken`, if present. - public func withUnexpectedBetweenAsyncKeywordAndThrowsToken(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ArrowExprSyntax(newData) - } - - public var throwsToken: TokenSyntax? { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withThrowsToken(value) - } - } - - /// Returns a copy of the receiver with its `throwsToken` replaced. - /// - param newChild: The new `throwsToken` to replace the node's - /// current `throwsToken`, if present. - public func withThrowsToken(_ newChild: TokenSyntax?) -> ArrowExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ArrowExprSyntax(newData) - } - - public var unexpectedBetweenThrowsTokenAndArrowToken: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenThrowsTokenAndArrowToken(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenThrowsTokenAndArrowToken` replaced. - /// - param newChild: The new `unexpectedBetweenThrowsTokenAndArrowToken` to replace the node's - /// current `unexpectedBetweenThrowsTokenAndArrowToken`, if present. - public func withUnexpectedBetweenThrowsTokenAndArrowToken(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ArrowExprSyntax(newData) - } - - public var arrowToken: TokenSyntax { + public var rightParen: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withArrowToken(value) + self = withRightParen(value) } } - /// Returns a copy of the receiver with its `arrowToken` replaced. - /// - param newChild: The new `arrowToken` to replace the node's - /// current `arrowToken`, if present. - public func withArrowToken(_ newChild: TokenSyntax?) -> ArrowExprSyntax { + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax?) -> TupleExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.arrow, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ArrowExprSyntax(newData) + return TupleExprSyntax(newData) } - public var unexpectedAfterArrowToken: UnexpectedNodesSyntax? { + public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterArrowToken(value) + self = withUnexpectedAfterRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterArrowToken` replaced. - /// - param newChild: The new `unexpectedAfterArrowToken` to replace the node's - /// current `unexpectedAfterArrowToken`, if present. - public func withUnexpectedAfterArrowToken(_ newChild: UnexpectedNodesSyntax?) -> ArrowExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. + /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's + /// current `unexpectedAfterRightParen`, if present. + public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ArrowExprSyntax(newData) + return TupleExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAsyncKeyword, - \Self.asyncKeyword, - \Self.unexpectedBetweenAsyncKeywordAndThrowsToken, - \Self.throwsToken, - \Self.unexpectedBetweenThrowsTokenAndArrowToken, - \Self.arrowToken, - \Self.unexpectedAfterArrowToken, + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndElementList, + \Self.elementList, + \Self.unexpectedBetweenElementListAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen, ]) } @@ -3384,217 +3095,236 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension ArrowExprSyntax: CustomReflectable { +extension TupleExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAsyncKeyword": unexpectedBeforeAsyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "asyncKeyword": asyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenAsyncKeywordAndThrowsToken": unexpectedBetweenAsyncKeywordAndThrowsToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "throwsToken": throwsToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenThrowsTokenAndArrowToken": unexpectedBetweenThrowsTokenAndArrowToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "arrowToken": Syntax(arrowToken).asProtocol(SyntaxProtocol.self), - "unexpectedAfterArrowToken": unexpectedAfterArrowToken.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: - InfixOperatorExprSyntax +// MARK: - ArrayExprSyntax -public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .infixOperatorExpr else { return nil } + guard node.raw.kind == .arrayExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `InfixOperatorExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ArrayExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .infixOperatorExpr) + assert(data.raw.kind == .arrayExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeLeftOperand: UnexpectedNodesSyntax? = nil, - leftOperand: ExprSyntax, - _ unexpectedBetweenLeftOperandAndOperatorOperand: UnexpectedNodesSyntax? = nil, - operatorOperand: ExprSyntax, - _ unexpectedBetweenOperatorOperandAndRightOperand: UnexpectedNodesSyntax? = nil, - rightOperand: ExprSyntax, - _ unexpectedAfterRightOperand: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax, + _ unexpectedBetweenLeftSquareAndElements: UnexpectedNodesSyntax? = nil, + elements: ArrayElementListSyntax, + _ unexpectedBetweenElementsAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax, + _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeftOperand?.raw, - leftOperand.raw, - unexpectedBetweenLeftOperandAndOperatorOperand?.raw, - operatorOperand.raw, - unexpectedBetweenOperatorOperandAndRightOperand?.raw, - rightOperand.raw, - unexpectedAfterRightOperand?.raw, + unexpectedBeforeLeftSquare?.raw, + leftSquare.raw, + unexpectedBetweenLeftSquareAndElements?.raw, + elements.raw, + unexpectedBetweenElementsAndRightSquare?.raw, + rightSquare.raw, + unexpectedAfterRightSquare?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.infixOperatorExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.arrayExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftOperand: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftOperand(value) + self = withUnexpectedBeforeLeftSquare(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftOperand` replaced. - /// - param newChild: The new `unexpectedBeforeLeftOperand` to replace the node's - /// current `unexpectedBeforeLeftOperand`, if present. - public func withUnexpectedBeforeLeftOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftSquare` replaced. + /// - param newChild: The new `unexpectedBeforeLeftSquare` to replace the node's + /// current `unexpectedBeforeLeftSquare`, if present. + public func withUnexpectedBeforeLeftSquare(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return InfixOperatorExprSyntax(newData) + return ArrayExprSyntax(newData) } - public var leftOperand: ExprSyntax { + public var leftSquare: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return ExprSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withLeftOperand(value) + self = withLeftSquare(value) } } - /// Returns a copy of the receiver with its `leftOperand` replaced. - /// - param newChild: The new `leftOperand` to replace the node's - /// current `leftOperand`, if present. - public func withLeftOperand(_ newChild: ExprSyntax?) -> InfixOperatorExprSyntax { + /// Returns a copy of the receiver with its `leftSquare` replaced. + /// - param newChild: The new `leftSquare` to replace the node's + /// current `leftSquare`, if present. + public func withLeftSquare(_ newChild: TokenSyntax?) -> ArrayExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return InfixOperatorExprSyntax(newData) + return ArrayExprSyntax(newData) } - public var unexpectedBetweenLeftOperandAndOperatorOperand: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftSquareAndElements: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftOperandAndOperatorOperand(value) + self = withUnexpectedBetweenLeftSquareAndElements(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftOperandAndOperatorOperand` replaced. - /// - param newChild: The new `unexpectedBetweenLeftOperandAndOperatorOperand` to replace the node's - /// current `unexpectedBetweenLeftOperandAndOperatorOperand`, if present. - public func withUnexpectedBetweenLeftOperandAndOperatorOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftSquareAndElements` replaced. + /// - param newChild: The new `unexpectedBetweenLeftSquareAndElements` to replace the node's + /// current `unexpectedBetweenLeftSquareAndElements`, if present. + public func withUnexpectedBetweenLeftSquareAndElements(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return InfixOperatorExprSyntax(newData) + return ArrayExprSyntax(newData) } - public var operatorOperand: ExprSyntax { + public var elements: ArrayElementListSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return ExprSyntax(childData!) + return ArrayElementListSyntax(childData!) } set(value) { - self = withOperatorOperand(value) + self = withElements(value) } } - /// Returns a copy of the receiver with its `operatorOperand` replaced. - /// - param newChild: The new `operatorOperand` to replace the node's - /// current `operatorOperand`, if present. - public func withOperatorOperand(_ newChild: ExprSyntax?) -> InfixOperatorExprSyntax { + /// Adds the provided `Element` to the node's `elements` + /// collection. + /// - param element: The new `Element` to add to the node's + /// `elements` collection. + /// - returns: A copy of the receiver with the provided `Element` + /// appended to its `elements` collection. + public func addElement(_ element: ArrayElementSyntax) -> ArrayExprSyntax { + var collection: RawSyntax let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + if let col = raw.layoutView!.children[3] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.arrayElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 3, with: collection, arena: arena) + return ArrayExprSyntax(newData) + } + + /// Returns a copy of the receiver with its `elements` replaced. + /// - param newChild: The new `elements` to replace the node's + /// current `elements`, if present. + public func withElements(_ newChild: ArrayElementListSyntax?) -> ArrayExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.arrayElementList, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return InfixOperatorExprSyntax(newData) + return ArrayExprSyntax(newData) } - public var unexpectedBetweenOperatorOperandAndRightOperand: UnexpectedNodesSyntax? { + public var unexpectedBetweenElementsAndRightSquare: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenOperatorOperandAndRightOperand(value) + self = withUnexpectedBetweenElementsAndRightSquare(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenOperatorOperandAndRightOperand` replaced. - /// - param newChild: The new `unexpectedBetweenOperatorOperandAndRightOperand` to replace the node's - /// current `unexpectedBetweenOperatorOperandAndRightOperand`, if present. - public func withUnexpectedBetweenOperatorOperandAndRightOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenElementsAndRightSquare` replaced. + /// - param newChild: The new `unexpectedBetweenElementsAndRightSquare` to replace the node's + /// current `unexpectedBetweenElementsAndRightSquare`, if present. + public func withUnexpectedBetweenElementsAndRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return InfixOperatorExprSyntax(newData) + return ArrayExprSyntax(newData) } - public var rightOperand: ExprSyntax { + public var rightSquare: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return ExprSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withRightOperand(value) + self = withRightSquare(value) } } - /// Returns a copy of the receiver with its `rightOperand` replaced. - /// - param newChild: The new `rightOperand` to replace the node's - /// current `rightOperand`, if present. - public func withRightOperand(_ newChild: ExprSyntax?) -> InfixOperatorExprSyntax { + /// Returns a copy of the receiver with its `rightSquare` replaced. + /// - param newChild: The new `rightSquare` to replace the node's + /// current `rightSquare`, if present. + public func withRightSquare(_ newChild: TokenSyntax?) -> ArrayExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return InfixOperatorExprSyntax(newData) + return ArrayExprSyntax(newData) } - public var unexpectedAfterRightOperand: UnexpectedNodesSyntax? { + public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightOperand(value) + self = withUnexpectedAfterRightSquare(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightOperand` replaced. - /// - param newChild: The new `unexpectedAfterRightOperand` to replace the node's - /// current `unexpectedAfterRightOperand`, if present. - public func withUnexpectedAfterRightOperand(_ newChild: UnexpectedNodesSyntax?) -> InfixOperatorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightSquare` replaced. + /// - param newChild: The new `unexpectedAfterRightSquare` to replace the node's + /// current `unexpectedAfterRightSquare`, if present. + public func withUnexpectedAfterRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return InfixOperatorExprSyntax(newData) + return ArrayExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftOperand, - \Self.leftOperand, - \Self.unexpectedBetweenLeftOperandAndOperatorOperand, - \Self.operatorOperand, - \Self.unexpectedBetweenOperatorOperandAndRightOperand, - \Self.rightOperand, - \Self.unexpectedAfterRightOperand, + \Self.unexpectedBeforeLeftSquare, + \Self.leftSquare, + \Self.unexpectedBetweenLeftSquareAndElements, + \Self.elements, + \Self.unexpectedBetweenElementsAndRightSquare, + \Self.rightSquare, + \Self.unexpectedAfterRightSquare, ]) } @@ -3620,366 +3350,253 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension InfixOperatorExprSyntax: CustomReflectable { +extension ArrayExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeLeftOperand": unexpectedBeforeLeftOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftOperand": Syntax(leftOperand).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftOperandAndOperatorOperand": unexpectedBetweenLeftOperandAndOperatorOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "operatorOperand": Syntax(operatorOperand).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOperatorOperandAndRightOperand": unexpectedBetweenOperatorOperandAndRightOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightOperand": Syntax(rightOperand).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightOperand": unexpectedAfterRightOperand.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeLeftSquare": unexpectedBeforeLeftSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftSquare": Syntax(leftSquare).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftSquareAndElements": unexpectedBetweenLeftSquareAndElements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "elements": Syntax(elements).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenElementsAndRightSquare": unexpectedBetweenElementsAndRightSquare.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: - FloatLiteralExprSyntax +// MARK: - DictionaryExprSyntax + +public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public enum Content: SyntaxChildChoices { + case `colon`(TokenSyntax) + case `elements`(DictionaryElementListSyntax) + public var _syntaxNode: Syntax { + switch self { + case .colon(let node): return node._syntaxNode + case .elements(let node): return node._syntaxNode + } + } + init(_ data: SyntaxData) { self.init(Syntax(data))! } + public init(_ node: TokenSyntax) { + self = .colon(node) + } + public init(_ node: DictionaryElementListSyntax) { + self = .elements(node) + } + public init?(_ node: S) { + if let node = node.as(TokenSyntax.self) { + self = .colon(node) + return + } + if let node = node.as(DictionaryElementListSyntax.self) { + self = .elements(node) + return + } + return nil + } + + public static var structure: SyntaxNodeStructure { + return .choices([ + .node(TokenSyntax.self), + .node(DictionaryElementListSyntax.self), + ]) + } + } -public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .floatLiteralExpr else { return nil } + guard node.raw.kind == .dictionaryExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `FloatLiteralExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `DictionaryExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .floatLiteralExpr) + assert(data.raw.kind == .dictionaryExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? = nil, - floatingDigits: TokenSyntax, - _ unexpectedAfterFloatingDigits: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax, + _ unexpectedBetweenLeftSquareAndContent: UnexpectedNodesSyntax? = nil, + content: Content, + _ unexpectedBetweenContentAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax, + _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeFloatingDigits?.raw, - floatingDigits.raw, - unexpectedAfterFloatingDigits?.raw, + unexpectedBeforeLeftSquare?.raw, + leftSquare.raw, + unexpectedBetweenLeftSquareAndContent?.raw, + content.raw, + unexpectedBetweenContentAndRightSquare?.raw, + rightSquare.raw, + unexpectedAfterRightSquare?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.floatLiteralExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.dictionaryExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeFloatingDigits(value) + self = withUnexpectedBeforeLeftSquare(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeFloatingDigits` replaced. - /// - param newChild: The new `unexpectedBeforeFloatingDigits` to replace the node's - /// current `unexpectedBeforeFloatingDigits`, if present. - public func withUnexpectedBeforeFloatingDigits(_ newChild: UnexpectedNodesSyntax?) -> FloatLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftSquare` replaced. + /// - param newChild: The new `unexpectedBeforeLeftSquare` to replace the node's + /// current `unexpectedBeforeLeftSquare`, if present. + public func withUnexpectedBeforeLeftSquare(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return FloatLiteralExprSyntax(newData) + return DictionaryExprSyntax(newData) } - public var floatingDigits: TokenSyntax { + public var leftSquare: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withFloatingDigits(value) + self = withLeftSquare(value) } } - /// Returns a copy of the receiver with its `floatingDigits` replaced. - /// - param newChild: The new `floatingDigits` to replace the node's - /// current `floatingDigits`, if present. - public func withFloatingDigits(_ newChild: TokenSyntax?) -> FloatLiteralExprSyntax { + /// Returns a copy of the receiver with its `leftSquare` replaced. + /// - param newChild: The new `leftSquare` to replace the node's + /// current `leftSquare`, if present. + public func withLeftSquare(_ newChild: TokenSyntax?) -> DictionaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.floatingLiteral(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return FloatLiteralExprSyntax(newData) + return DictionaryExprSyntax(newData) } - public var unexpectedAfterFloatingDigits: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftSquareAndContent: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterFloatingDigits(value) + self = withUnexpectedBetweenLeftSquareAndContent(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterFloatingDigits` replaced. - /// - param newChild: The new `unexpectedAfterFloatingDigits` to replace the node's - /// current `unexpectedAfterFloatingDigits`, if present. - public func withUnexpectedAfterFloatingDigits(_ newChild: UnexpectedNodesSyntax?) -> FloatLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftSquareAndContent` replaced. + /// - param newChild: The new `unexpectedBetweenLeftSquareAndContent` to replace the node's + /// current `unexpectedBetweenLeftSquareAndContent`, if present. + public func withUnexpectedBetweenLeftSquareAndContent(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return FloatLiteralExprSyntax(newData) + return DictionaryExprSyntax(newData) } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeFloatingDigits, - \Self.floatingDigits, - \Self.unexpectedAfterFloatingDigits, - ]) - } - - 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 FloatLiteralExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeFloatingDigits": unexpectedBeforeFloatingDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "floatingDigits": Syntax(floatingDigits).asProtocol(SyntaxProtocol.self), - "unexpectedAfterFloatingDigits": unexpectedAfterFloatingDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - TupleExprSyntax - -public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .tupleExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `TupleExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .tupleExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax, - _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, - elementList: TupleExprElementListSyntax, - _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElementList?.raw, - elementList.raw, - unexpectedBetweenElementListAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.tupleExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeLeftParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeLeftParen` replaced. - /// - param newChild: The new `unexpectedBeforeLeftParen` to replace the node's - /// current `unexpectedBeforeLeftParen`, if present. - public func withUnexpectedBeforeLeftParen(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return TupleExprSyntax(newData) - } - - public var leftParen: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withLeftParen(value) - } - } - - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax?) -> TupleExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TupleExprSyntax(newData) - } - - public var unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLeftParenAndElementList(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndElementList` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndElementList` to replace the node's - /// current `unexpectedBetweenLeftParenAndElementList`, if present. - public func withUnexpectedBetweenLeftParenAndElementList(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return TupleExprSyntax(newData) - } - - public var elementList: TupleExprElementListSyntax { + public var content: Content { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TupleExprElementListSyntax(childData!) + return Content(childData!) } set(value) { - self = withElementList(value) - } - } - - /// Adds the provided `Element` to the node's `elementList` - /// collection. - /// - param element: The new `Element` to add to the node's - /// `elementList` collection. - /// - returns: A copy of the receiver with the provided `Element` - /// appended to its `elementList` collection. - public func addElement(_ element: TupleExprElementSyntax) -> TupleExprSyntax { - 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 = withContent(value) } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return TupleExprSyntax(newData) } - /// Returns a copy of the receiver with its `elementList` replaced. - /// - param newChild: The new `elementList` to replace the node's - /// current `elementList`, if present. - public func withElementList(_ newChild: TupleExprElementListSyntax?) -> TupleExprSyntax { + /// Returns a copy of the receiver with its `content` replaced. + /// - param newChild: The new `content` to replace the node's + /// current `content`, if present. + public func withContent(_ newChild: Content?) -> DictionaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.unknown, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return TupleExprSyntax(newData) + return DictionaryExprSyntax(newData) } - public var unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenContentAndRightSquare: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenElementListAndRightParen(value) + self = withUnexpectedBetweenContentAndRightSquare(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenElementListAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenElementListAndRightParen` to replace the node's - /// current `unexpectedBetweenElementListAndRightParen`, if present. - public func withUnexpectedBetweenElementListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenContentAndRightSquare` replaced. + /// - param newChild: The new `unexpectedBetweenContentAndRightSquare` to replace the node's + /// current `unexpectedBetweenContentAndRightSquare`, if present. + public func withUnexpectedBetweenContentAndRightSquare(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return TupleExprSyntax(newData) + return DictionaryExprSyntax(newData) } - public var rightParen: TokenSyntax { + public var rightSquare: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withRightSquare(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax?) -> TupleExprSyntax { + /// Returns a copy of the receiver with its `rightSquare` replaced. + /// - param newChild: The new `rightSquare` to replace the node's + /// current `rightSquare`, if present. + public func withRightSquare(_ newChild: TokenSyntax?) -> DictionaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return TupleExprSyntax(newData) + return DictionaryExprSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedAfterRightSquare(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> TupleExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightSquare` replaced. + /// - param newChild: The new `unexpectedAfterRightSquare` to replace the node's + /// current `unexpectedAfterRightSquare`, if present. + public func withUnexpectedAfterRightSquare(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return TupleExprSyntax(newData) + return DictionaryExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndElementList, - \Self.elementList, - \Self.unexpectedBetweenElementListAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeLeftSquare, + \Self.leftSquare, + \Self.unexpectedBetweenLeftSquareAndContent, + \Self.content, + \Self.unexpectedBetweenContentAndRightSquare, + \Self.rightSquare, + \Self.unexpectedAfterRightSquare, ]) } @@ -4005,236 +3622,253 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension TupleExprSyntax: CustomReflectable { +extension DictionaryExprSyntax: 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, + "unexpectedBeforeLeftSquare": unexpectedBeforeLeftSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftSquare": Syntax(leftSquare).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenLeftSquareAndContent": unexpectedBetweenLeftSquareAndContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "content": Syntax(content).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenContentAndRightSquare": unexpectedBetweenContentAndRightSquare.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: - ArrayExprSyntax +// MARK: - IntegerLiteralExprSyntax -public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .arrayExpr else { return nil } + guard node.raw.kind == .integerLiteralExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ArrayExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `IntegerLiteralExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .arrayExpr) + assert(data.raw.kind == .integerLiteralExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, - leftSquare: TokenSyntax, - _ unexpectedBetweenLeftSquareAndElements: UnexpectedNodesSyntax? = nil, - elements: ArrayElementListSyntax, - _ unexpectedBetweenElementsAndRightSquare: UnexpectedNodesSyntax? = nil, - rightSquare: TokenSyntax, - _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeDigits: UnexpectedNodesSyntax? = nil, + digits: TokenSyntax, + _ unexpectedAfterDigits: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndElements?.raw, - elements.raw, - unexpectedBetweenElementsAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw, + unexpectedBeforeDigits?.raw, + digits.raw, + unexpectedAfterDigits?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.arrayExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.integerLiteralExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { + public var unexpectedBeforeDigits: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftSquare(value) + self = withUnexpectedBeforeDigits(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftSquare` replaced. - /// - param newChild: The new `unexpectedBeforeLeftSquare` to replace the node's - /// current `unexpectedBeforeLeftSquare`, if present. - public func withUnexpectedBeforeLeftSquare(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeDigits` replaced. + /// - param newChild: The new `unexpectedBeforeDigits` to replace the node's + /// current `unexpectedBeforeDigits`, if present. + public func withUnexpectedBeforeDigits(_ newChild: UnexpectedNodesSyntax?) -> IntegerLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ArrayExprSyntax(newData) + return IntegerLiteralExprSyntax(newData) } - public var leftSquare: TokenSyntax { + public var digits: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftSquare(value) + self = withDigits(value) } } - /// Returns a copy of the receiver with its `leftSquare` replaced. - /// - param newChild: The new `leftSquare` to replace the node's - /// current `leftSquare`, if present. - public func withLeftSquare(_ newChild: TokenSyntax?) -> ArrayExprSyntax { + /// Returns a copy of the receiver with its `digits` replaced. + /// - param newChild: The new `digits` to replace the node's + /// current `digits`, if present. + public func withDigits(_ newChild: TokenSyntax?) -> IntegerLiteralExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.integerLiteral(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ArrayExprSyntax(newData) + return IntegerLiteralExprSyntax(newData) } - public var unexpectedBetweenLeftSquareAndElements: UnexpectedNodesSyntax? { + public var unexpectedAfterDigits: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftSquareAndElements(value) + self = withUnexpectedAfterDigits(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftSquareAndElements` replaced. - /// - param newChild: The new `unexpectedBetweenLeftSquareAndElements` to replace the node's - /// current `unexpectedBetweenLeftSquareAndElements`, if present. - public func withUnexpectedBetweenLeftSquareAndElements(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterDigits` replaced. + /// - param newChild: The new `unexpectedAfterDigits` to replace the node's + /// current `unexpectedAfterDigits`, if present. + public func withUnexpectedAfterDigits(_ newChild: UnexpectedNodesSyntax?) -> IntegerLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ArrayExprSyntax(newData) + return IntegerLiteralExprSyntax(newData) } - public var elements: ArrayElementListSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return ArrayElementListSyntax(childData!) - } - set(value) { - self = withElements(value) - } + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeDigits, + \Self.digits, + \Self.unexpectedAfterDigits, + ]) } - /// Adds the provided `Element` to the node's `elements` - /// collection. - /// - param element: The new `Element` to add to the node's - /// `elements` collection. - /// - returns: A copy of the receiver with the provided `Element` - /// appended to its `elements` collection. - public func addElement(_ element: ArrayElementSyntax) -> ArrayExprSyntax { - 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.arrayElementList, - from: [element.raw], arena: arena) + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + default: + fatalError("Invalid index") } - let newData = data.replacingChild(at: 3, with: collection, arena: arena) - return ArrayExprSyntax(newData) } +} - /// Returns a copy of the receiver with its `elements` replaced. - /// - param newChild: The new `elements` to replace the node's - /// current `elements`, if present. - public func withElements(_ newChild: ArrayElementListSyntax?) -> ArrayExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.arrayElementList, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ArrayExprSyntax(newData) +extension IntegerLiteralExprSyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "unexpectedBeforeDigits": unexpectedBeforeDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "digits": Syntax(digits).asProtocol(SyntaxProtocol.self), + "unexpectedAfterDigits": unexpectedAfterDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) } +} - public var unexpectedBetweenElementsAndRightSquare: UnexpectedNodesSyntax? { +// MARK: - BooleanLiteralExprSyntax + +public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .booleanLiteralExpr else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `BooleanLiteralExprSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .booleanLiteralExpr) + self._syntaxNode = Syntax(data) + } + + public init( + _ unexpectedBeforeBooleanLiteral: UnexpectedNodesSyntax? = nil, + booleanLiteral: TokenSyntax, + _ unexpectedAfterBooleanLiteral: UnexpectedNodesSyntax? = nil + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeBooleanLiteral?.raw, + booleanLiteral.raw, + unexpectedAfterBooleanLiteral?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.booleanLiteralExpr, + from: layout, arena: arena) + return SyntaxData.forRoot(raw) + } + self.init(data) + } + + public var unexpectedBeforeBooleanLiteral: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenElementsAndRightSquare(value) + self = withUnexpectedBeforeBooleanLiteral(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenElementsAndRightSquare` replaced. - /// - param newChild: The new `unexpectedBetweenElementsAndRightSquare` to replace the node's - /// current `unexpectedBetweenElementsAndRightSquare`, if present. - public func withUnexpectedBetweenElementsAndRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeBooleanLiteral` replaced. + /// - param newChild: The new `unexpectedBeforeBooleanLiteral` to replace the node's + /// current `unexpectedBeforeBooleanLiteral`, if present. + public func withUnexpectedBeforeBooleanLiteral(_ newChild: UnexpectedNodesSyntax?) -> BooleanLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ArrayExprSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return BooleanLiteralExprSyntax(newData) } - public var rightSquare: TokenSyntax { + public var booleanLiteral: TokenSyntax { get { - let childData = data.child(at: 5, parent: Syntax(self)) + let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withRightSquare(value) + self = withBooleanLiteral(value) } } - /// Returns a copy of the receiver with its `rightSquare` replaced. - /// - param newChild: The new `rightSquare` to replace the node's - /// current `rightSquare`, if present. - public func withRightSquare(_ newChild: TokenSyntax?) -> ArrayExprSyntax { + /// Returns a copy of the receiver with its `booleanLiteral` replaced. + /// - param newChild: The new `booleanLiteral` to replace the node's + /// current `booleanLiteral`, if present. + public func withBooleanLiteral(_ newChild: TokenSyntax?) -> BooleanLiteralExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ArrayExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.trueKeyword, arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return BooleanLiteralExprSyntax(newData) } - public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { + public var unexpectedAfterBooleanLiteral: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightSquare(value) + self = withUnexpectedAfterBooleanLiteral(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightSquare` replaced. - /// - param newChild: The new `unexpectedAfterRightSquare` to replace the node's - /// current `unexpectedAfterRightSquare`, if present. - public func withUnexpectedAfterRightSquare(_ newChild: UnexpectedNodesSyntax?) -> ArrayExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterBooleanLiteral` replaced. + /// - param newChild: The new `unexpectedAfterBooleanLiteral` to replace the node's + /// current `unexpectedAfterBooleanLiteral`, if present. + public func withUnexpectedAfterBooleanLiteral(_ newChild: UnexpectedNodesSyntax?) -> BooleanLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ArrayExprSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return BooleanLiteralExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftSquare, - \Self.leftSquare, - \Self.unexpectedBetweenLeftSquareAndElements, - \Self.elements, - \Self.unexpectedBetweenElementsAndRightSquare, - \Self.rightSquare, - \Self.unexpectedAfterRightSquare, + \Self.unexpectedBeforeBooleanLiteral, + \Self.booleanLiteral, + \Self.unexpectedAfterBooleanLiteral, ]) } @@ -4246,267 +3880,219 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, 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 ArrayExprSyntax: CustomReflectable { +extension BooleanLiteralExprSyntax: 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), - "unexpectedBetweenLeftSquareAndElements": unexpectedBetweenLeftSquareAndElements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "elements": Syntax(elements).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenElementsAndRightSquare": unexpectedBetweenElementsAndRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightSquare": Syntax(rightSquare).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightSquare": unexpectedAfterRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeBooleanLiteral": unexpectedBeforeBooleanLiteral.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "booleanLiteral": Syntax(booleanLiteral).asProtocol(SyntaxProtocol.self), + "unexpectedAfterBooleanLiteral": unexpectedAfterBooleanLiteral.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - DictionaryExprSyntax - -public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public enum Content: SyntaxChildChoices { - case `colon`(TokenSyntax) - case `elements`(DictionaryElementListSyntax) - public var _syntaxNode: Syntax { - switch self { - case .colon(let node): return node._syntaxNode - case .elements(let node): return node._syntaxNode - } - } - init(_ data: SyntaxData) { self.init(Syntax(data))! } - public init(_ node: TokenSyntax) { - self = .colon(node) - } - public init(_ node: DictionaryElementListSyntax) { - self = .elements(node) - } - public init?(_ node: S) { - if let node = node.as(TokenSyntax.self) { - self = .colon(node) - return - } - if let node = node.as(DictionaryElementListSyntax.self) { - self = .elements(node) - return - } - return nil - } - - public static var structure: SyntaxNodeStructure { - return .choices([ - .node(TokenSyntax.self), - .node(DictionaryElementListSyntax.self), - ]) - } - } +// MARK: - UnresolvedTernaryExprSyntax +public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dictionaryExpr else { return nil } + guard node.raw.kind == .unresolvedTernaryExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `DictionaryExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnresolvedTernaryExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .dictionaryExpr) + assert(data.raw.kind == .unresolvedTernaryExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, - leftSquare: TokenSyntax, - _ unexpectedBetweenLeftSquareAndContent: UnexpectedNodesSyntax? = nil, - content: Content, - _ unexpectedBetweenContentAndRightSquare: UnexpectedNodesSyntax? = nil, - rightSquare: TokenSyntax, - _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? = nil, + questionMark: TokenSyntax, + _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, + firstChoice: ExprSyntax, + _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, + colonMark: TokenSyntax, + _ unexpectedAfterColonMark: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndContent?.raw, - content.raw, - unexpectedBetweenContentAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw, + unexpectedBeforeQuestionMark?.raw, + questionMark.raw, + unexpectedBetweenQuestionMarkAndFirstChoice?.raw, + firstChoice.raw, + unexpectedBetweenFirstChoiceAndColonMark?.raw, + colonMark.raw, + unexpectedAfterColonMark?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.dictionaryExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedTernaryExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { + public var unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftSquare(value) + self = withUnexpectedBeforeQuestionMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftSquare` replaced. - /// - param newChild: The new `unexpectedBeforeLeftSquare` to replace the node's - /// current `unexpectedBeforeLeftSquare`, if present. - public func withUnexpectedBeforeLeftSquare(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeQuestionMark` replaced. + /// - param newChild: The new `unexpectedBeforeQuestionMark` to replace the node's + /// current `unexpectedBeforeQuestionMark`, if present. + public func withUnexpectedBeforeQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return DictionaryExprSyntax(newData) + return UnresolvedTernaryExprSyntax(newData) } - public var leftSquare: TokenSyntax { + public var questionMark: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withLeftSquare(value) + self = withQuestionMark(value) } } - /// Returns a copy of the receiver with its `leftSquare` replaced. - /// - param newChild: The new `leftSquare` to replace the node's - /// current `leftSquare`, if present. - public func withLeftSquare(_ newChild: TokenSyntax?) -> DictionaryExprSyntax { + /// Returns a copy of the receiver with its `questionMark` replaced. + /// - param newChild: The new `questionMark` to replace the node's + /// current `questionMark`, if present. + public func withQuestionMark(_ newChild: TokenSyntax?) -> UnresolvedTernaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.infixQuestionMark, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return DictionaryExprSyntax(newData) + return UnresolvedTernaryExprSyntax(newData) } - public var unexpectedBetweenLeftSquareAndContent: UnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftSquareAndContent(value) + self = withUnexpectedBetweenQuestionMarkAndFirstChoice(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftSquareAndContent` replaced. - /// - param newChild: The new `unexpectedBetweenLeftSquareAndContent` to replace the node's - /// current `unexpectedBetweenLeftSquareAndContent`, if present. - public func withUnexpectedBetweenLeftSquareAndContent(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenQuestionMarkAndFirstChoice` replaced. + /// - param newChild: The new `unexpectedBetweenQuestionMarkAndFirstChoice` to replace the node's + /// current `unexpectedBetweenQuestionMarkAndFirstChoice`, if present. + public func withUnexpectedBetweenQuestionMarkAndFirstChoice(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return DictionaryExprSyntax(newData) + return UnresolvedTernaryExprSyntax(newData) } - public var content: Content { + public var firstChoice: ExprSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return Content(childData!) + return ExprSyntax(childData!) } set(value) { - self = withContent(value) + self = withFirstChoice(value) } } - /// Returns a copy of the receiver with its `content` replaced. - /// - param newChild: The new `content` to replace the node's - /// current `content`, if present. - public func withContent(_ newChild: Content?) -> DictionaryExprSyntax { + /// Returns a copy of the receiver with its `firstChoice` replaced. + /// - param newChild: The new `firstChoice` to replace the node's + /// current `firstChoice`, if present. + public func withFirstChoice(_ newChild: ExprSyntax?) -> UnresolvedTernaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.unknown, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return DictionaryExprSyntax(newData) + return UnresolvedTernaryExprSyntax(newData) } - public var unexpectedBetweenContentAndRightSquare: UnexpectedNodesSyntax? { + public var unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenContentAndRightSquare(value) + self = withUnexpectedBetweenFirstChoiceAndColonMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenContentAndRightSquare` replaced. - /// - param newChild: The new `unexpectedBetweenContentAndRightSquare` to replace the node's - /// current `unexpectedBetweenContentAndRightSquare`, if present. - public func withUnexpectedBetweenContentAndRightSquare(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenFirstChoiceAndColonMark` replaced. + /// - param newChild: The new `unexpectedBetweenFirstChoiceAndColonMark` to replace the node's + /// current `unexpectedBetweenFirstChoiceAndColonMark`, if present. + public func withUnexpectedBetweenFirstChoiceAndColonMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return DictionaryExprSyntax(newData) + return UnresolvedTernaryExprSyntax(newData) } - public var rightSquare: TokenSyntax { + public var colonMark: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withRightSquare(value) + self = withColonMark(value) } } - /// Returns a copy of the receiver with its `rightSquare` replaced. - /// - param newChild: The new `rightSquare` to replace the node's - /// current `rightSquare`, if present. - public func withRightSquare(_ newChild: TokenSyntax?) -> DictionaryExprSyntax { + /// Returns a copy of the receiver with its `colonMark` replaced. + /// - param newChild: The new `colonMark` to replace the node's + /// current `colonMark`, if present. + public func withColonMark(_ newChild: TokenSyntax?) -> UnresolvedTernaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return DictionaryExprSyntax(newData) + return UnresolvedTernaryExprSyntax(newData) } - public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { + public var unexpectedAfterColonMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightSquare(value) + self = withUnexpectedAfterColonMark(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightSquare` replaced. - /// - param newChild: The new `unexpectedAfterRightSquare` to replace the node's - /// current `unexpectedAfterRightSquare`, if present. - public func withUnexpectedAfterRightSquare(_ newChild: UnexpectedNodesSyntax?) -> DictionaryExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterColonMark` replaced. + /// - param newChild: The new `unexpectedAfterColonMark` to replace the node's + /// current `unexpectedAfterColonMark`, if present. + public func withUnexpectedAfterColonMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return DictionaryExprSyntax(newData) + return UnresolvedTernaryExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftSquare, - \Self.leftSquare, - \Self.unexpectedBetweenLeftSquareAndContent, - \Self.content, - \Self.unexpectedBetweenContentAndRightSquare, - \Self.rightSquare, - \Self.unexpectedAfterRightSquare, + \Self.unexpectedBeforeQuestionMark, + \Self.questionMark, + \Self.unexpectedBetweenQuestionMarkAndFirstChoice, + \Self.firstChoice, + \Self.unexpectedBetweenFirstChoiceAndColonMark, + \Self.colonMark, + \Self.unexpectedAfterColonMark, ]) } @@ -4532,1252 +4118,311 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension DictionaryExprSyntax: CustomReflectable { +extension UnresolvedTernaryExprSyntax: 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), - "unexpectedBetweenLeftSquareAndContent": unexpectedBetweenLeftSquareAndContent.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "content": Syntax(content).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenContentAndRightSquare": unexpectedBetweenContentAndRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightSquare": Syntax(rightSquare).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightSquare": unexpectedAfterRightSquare.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeQuestionMark": unexpectedBeforeQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "questionMark": Syntax(questionMark).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenQuestionMarkAndFirstChoice": unexpectedBetweenQuestionMarkAndFirstChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "firstChoice": Syntax(firstChoice).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenFirstChoiceAndColonMark": unexpectedBetweenFirstChoiceAndColonMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colonMark": Syntax(colonMark).asProtocol(SyntaxProtocol.self), + "unexpectedAfterColonMark": unexpectedAfterColonMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - IntegerLiteralExprSyntax +// MARK: - TernaryExprSyntax -public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .integerLiteralExpr else { return nil } + guard node.raw.kind == .ternaryExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `IntegerLiteralExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `TernaryExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .integerLiteralExpr) + assert(data.raw.kind == .ternaryExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeDigits: UnexpectedNodesSyntax? = nil, - digits: TokenSyntax, - _ unexpectedAfterDigits: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeConditionExpression: UnexpectedNodesSyntax? = nil, + conditionExpression: ExprSyntax, + _ unexpectedBetweenConditionExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, + questionMark: TokenSyntax, + _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, + firstChoice: ExprSyntax, + _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, + colonMark: TokenSyntax, + _ unexpectedBetweenColonMarkAndSecondChoice: UnexpectedNodesSyntax? = nil, + secondChoice: ExprSyntax, + _ unexpectedAfterSecondChoice: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeDigits?.raw, - digits.raw, - unexpectedAfterDigits?.raw, + unexpectedBeforeConditionExpression?.raw, + conditionExpression.raw, + unexpectedBetweenConditionExpressionAndQuestionMark?.raw, + questionMark.raw, + unexpectedBetweenQuestionMarkAndFirstChoice?.raw, + firstChoice.raw, + unexpectedBetweenFirstChoiceAndColonMark?.raw, + colonMark.raw, + unexpectedBetweenColonMarkAndSecondChoice?.raw, + secondChoice.raw, + unexpectedAfterSecondChoice?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.integerLiteralExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.ternaryExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeDigits: UnexpectedNodesSyntax? { + public var unexpectedBeforeConditionExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeDigits(value) + self = withUnexpectedBeforeConditionExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeDigits` replaced. - /// - param newChild: The new `unexpectedBeforeDigits` to replace the node's - /// current `unexpectedBeforeDigits`, if present. - public func withUnexpectedBeforeDigits(_ newChild: UnexpectedNodesSyntax?) -> IntegerLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeConditionExpression` replaced. + /// - param newChild: The new `unexpectedBeforeConditionExpression` to replace the node's + /// current `unexpectedBeforeConditionExpression`, if present. + public func withUnexpectedBeforeConditionExpression(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return IntegerLiteralExprSyntax(newData) + return TernaryExprSyntax(newData) } - public var digits: TokenSyntax { + public var conditionExpression: ExprSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withDigits(value) - } - } - - /// Returns a copy of the receiver with its `digits` replaced. - /// - param newChild: The new `digits` to replace the node's - /// current `digits`, if present. - public func withDigits(_ newChild: TokenSyntax?) -> IntegerLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.integerLiteral(""), arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return IntegerLiteralExprSyntax(newData) - } - - public var unexpectedAfterDigits: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterDigits(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterDigits` replaced. - /// - param newChild: The new `unexpectedAfterDigits` to replace the node's - /// current `unexpectedAfterDigits`, if present. - public func withUnexpectedAfterDigits(_ newChild: UnexpectedNodesSyntax?) -> IntegerLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return IntegerLiteralExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeDigits, - \Self.digits, - \Self.unexpectedAfterDigits, - ]) - } - - 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 IntegerLiteralExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeDigits": unexpectedBeforeDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "digits": Syntax(digits).asProtocol(SyntaxProtocol.self), - "unexpectedAfterDigits": unexpectedAfterDigits.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - BooleanLiteralExprSyntax - -public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .booleanLiteralExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `BooleanLiteralExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .booleanLiteralExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeBooleanLiteral: UnexpectedNodesSyntax? = nil, - booleanLiteral: TokenSyntax, - _ unexpectedAfterBooleanLiteral: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeBooleanLiteral?.raw, - booleanLiteral.raw, - unexpectedAfterBooleanLiteral?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.booleanLiteralExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeBooleanLiteral: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeBooleanLiteral(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeBooleanLiteral` replaced. - /// - param newChild: The new `unexpectedBeforeBooleanLiteral` to replace the node's - /// current `unexpectedBeforeBooleanLiteral`, if present. - public func withUnexpectedBeforeBooleanLiteral(_ newChild: UnexpectedNodesSyntax?) -> BooleanLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return BooleanLiteralExprSyntax(newData) - } - - public var booleanLiteral: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withBooleanLiteral(value) - } - } - - /// Returns a copy of the receiver with its `booleanLiteral` replaced. - /// - param newChild: The new `booleanLiteral` to replace the node's - /// current `booleanLiteral`, if present. - public func withBooleanLiteral(_ newChild: TokenSyntax?) -> BooleanLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.trueKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return BooleanLiteralExprSyntax(newData) - } - - public var unexpectedAfterBooleanLiteral: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterBooleanLiteral(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterBooleanLiteral` replaced. - /// - param newChild: The new `unexpectedAfterBooleanLiteral` to replace the node's - /// current `unexpectedAfterBooleanLiteral`, if present. - public func withUnexpectedAfterBooleanLiteral(_ newChild: UnexpectedNodesSyntax?) -> BooleanLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return BooleanLiteralExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeBooleanLiteral, - \Self.booleanLiteral, - \Self.unexpectedAfterBooleanLiteral, - ]) - } - - 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 BooleanLiteralExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeBooleanLiteral": unexpectedBeforeBooleanLiteral.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "booleanLiteral": Syntax(booleanLiteral).asProtocol(SyntaxProtocol.self), - "unexpectedAfterBooleanLiteral": unexpectedAfterBooleanLiteral.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - UnresolvedTernaryExprSyntax - -public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .unresolvedTernaryExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `UnresolvedTernaryExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .unresolvedTernaryExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? = nil, - questionMark: TokenSyntax, - _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, - firstChoice: ExprSyntax, - _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, - colonMark: TokenSyntax, - _ unexpectedAfterColonMark: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeQuestionMark?.raw, - questionMark.raw, - unexpectedBetweenQuestionMarkAndFirstChoice?.raw, - firstChoice.raw, - unexpectedBetweenFirstChoiceAndColonMark?.raw, - colonMark.raw, - unexpectedAfterColonMark?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedTernaryExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeQuestionMark(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeQuestionMark` replaced. - /// - param newChild: The new `unexpectedBeforeQuestionMark` to replace the node's - /// current `unexpectedBeforeQuestionMark`, if present. - public func withUnexpectedBeforeQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return UnresolvedTernaryExprSyntax(newData) - } - - public var questionMark: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withQuestionMark(value) - } - } - - /// Returns a copy of the receiver with its `questionMark` replaced. - /// - param newChild: The new `questionMark` to replace the node's - /// current `questionMark`, if present. - public func withQuestionMark(_ newChild: TokenSyntax?) -> UnresolvedTernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.infixQuestionMark, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return UnresolvedTernaryExprSyntax(newData) - } - - public var unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenQuestionMarkAndFirstChoice(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenQuestionMarkAndFirstChoice` replaced. - /// - param newChild: The new `unexpectedBetweenQuestionMarkAndFirstChoice` to replace the node's - /// current `unexpectedBetweenQuestionMarkAndFirstChoice`, if present. - public func withUnexpectedBetweenQuestionMarkAndFirstChoice(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return UnresolvedTernaryExprSyntax(newData) - } - - public var firstChoice: ExprSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withFirstChoice(value) - } - } - - /// Returns a copy of the receiver with its `firstChoice` replaced. - /// - param newChild: The new `firstChoice` to replace the node's - /// current `firstChoice`, if present. - public func withFirstChoice(_ newChild: ExprSyntax?) -> UnresolvedTernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return UnresolvedTernaryExprSyntax(newData) - } - - public var unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenFirstChoiceAndColonMark(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenFirstChoiceAndColonMark` replaced. - /// - param newChild: The new `unexpectedBetweenFirstChoiceAndColonMark` to replace the node's - /// current `unexpectedBetweenFirstChoiceAndColonMark`, if present. - public func withUnexpectedBetweenFirstChoiceAndColonMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return UnresolvedTernaryExprSyntax(newData) - } - - public var colonMark: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withColonMark(value) - } - } - - /// Returns a copy of the receiver with its `colonMark` replaced. - /// - param newChild: The new `colonMark` to replace the node's - /// current `colonMark`, if present. - public func withColonMark(_ newChild: TokenSyntax?) -> UnresolvedTernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return UnresolvedTernaryExprSyntax(newData) - } - - public var unexpectedAfterColonMark: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterColonMark(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterColonMark` replaced. - /// - param newChild: The new `unexpectedAfterColonMark` to replace the node's - /// current `unexpectedAfterColonMark`, if present. - public func withUnexpectedAfterColonMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedTernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return UnresolvedTernaryExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeQuestionMark, - \Self.questionMark, - \Self.unexpectedBetweenQuestionMarkAndFirstChoice, - \Self.firstChoice, - \Self.unexpectedBetweenFirstChoiceAndColonMark, - \Self.colonMark, - \Self.unexpectedAfterColonMark, - ]) - } - - 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 UnresolvedTernaryExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeQuestionMark": unexpectedBeforeQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "questionMark": Syntax(questionMark).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenQuestionMarkAndFirstChoice": unexpectedBetweenQuestionMarkAndFirstChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "firstChoice": Syntax(firstChoice).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenFirstChoiceAndColonMark": unexpectedBetweenFirstChoiceAndColonMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colonMark": Syntax(colonMark).asProtocol(SyntaxProtocol.self), - "unexpectedAfterColonMark": unexpectedAfterColonMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - TernaryExprSyntax - -public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .ternaryExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `TernaryExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .ternaryExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeConditionExpression: UnexpectedNodesSyntax? = nil, - conditionExpression: ExprSyntax, - _ unexpectedBetweenConditionExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, - questionMark: TokenSyntax, - _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, - firstChoice: ExprSyntax, - _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, - colonMark: TokenSyntax, - _ unexpectedBetweenColonMarkAndSecondChoice: UnexpectedNodesSyntax? = nil, - secondChoice: ExprSyntax, - _ unexpectedAfterSecondChoice: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeConditionExpression?.raw, - conditionExpression.raw, - unexpectedBetweenConditionExpressionAndQuestionMark?.raw, - questionMark.raw, - unexpectedBetweenQuestionMarkAndFirstChoice?.raw, - firstChoice.raw, - unexpectedBetweenFirstChoiceAndColonMark?.raw, - colonMark.raw, - unexpectedBetweenColonMarkAndSecondChoice?.raw, - secondChoice.raw, - unexpectedAfterSecondChoice?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.ternaryExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeConditionExpression: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeConditionExpression(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeConditionExpression` replaced. - /// - param newChild: The new `unexpectedBeforeConditionExpression` to replace the node's - /// current `unexpectedBeforeConditionExpression`, if present. - public func withUnexpectedBeforeConditionExpression(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var conditionExpression: ExprSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withConditionExpression(value) - } - } - - /// Returns a copy of the receiver with its `conditionExpression` replaced. - /// - param newChild: The new `conditionExpression` to replace the node's - /// current `conditionExpression`, if present. - public func withConditionExpression(_ newChild: ExprSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var unexpectedBetweenConditionExpressionAndQuestionMark: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenConditionExpressionAndQuestionMark(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenConditionExpressionAndQuestionMark` replaced. - /// - param newChild: The new `unexpectedBetweenConditionExpressionAndQuestionMark` to replace the node's - /// current `unexpectedBetweenConditionExpressionAndQuestionMark`, if present. - public func withUnexpectedBetweenConditionExpressionAndQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var questionMark: TokenSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withQuestionMark(value) - } - } - - /// Returns a copy of the receiver with its `questionMark` replaced. - /// - param newChild: The new `questionMark` to replace the node's - /// current `questionMark`, if present. - public func withQuestionMark(_ newChild: TokenSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.infixQuestionMark, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenQuestionMarkAndFirstChoice(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenQuestionMarkAndFirstChoice` replaced. - /// - param newChild: The new `unexpectedBetweenQuestionMarkAndFirstChoice` to replace the node's - /// current `unexpectedBetweenQuestionMarkAndFirstChoice`, if present. - public func withUnexpectedBetweenQuestionMarkAndFirstChoice(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var firstChoice: ExprSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withFirstChoice(value) - } - } - - /// Returns a copy of the receiver with its `firstChoice` replaced. - /// - param newChild: The new `firstChoice` to replace the node's - /// current `firstChoice`, if present. - public func withFirstChoice(_ newChild: ExprSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenFirstChoiceAndColonMark(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenFirstChoiceAndColonMark` replaced. - /// - param newChild: The new `unexpectedBetweenFirstChoiceAndColonMark` to replace the node's - /// current `unexpectedBetweenFirstChoiceAndColonMark`, if present. - public func withUnexpectedBetweenFirstChoiceAndColonMark(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var colonMark: TokenSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withColonMark(value) - } - } - - /// Returns a copy of the receiver with its `colonMark` replaced. - /// - param newChild: The new `colonMark` to replace the node's - /// current `colonMark`, if present. - public func withColonMark(_ newChild: TokenSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var unexpectedBetweenColonMarkAndSecondChoice: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenColonMarkAndSecondChoice(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenColonMarkAndSecondChoice` replaced. - /// - param newChild: The new `unexpectedBetweenColonMarkAndSecondChoice` to replace the node's - /// current `unexpectedBetweenColonMarkAndSecondChoice`, if present. - public func withUnexpectedBetweenColonMarkAndSecondChoice(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var secondChoice: ExprSyntax { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withSecondChoice(value) - } - } - - /// Returns a copy of the receiver with its `secondChoice` replaced. - /// - param newChild: The new `secondChoice` to replace the node's - /// current `secondChoice`, if present. - public func withSecondChoice(_ newChild: ExprSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public var unexpectedAfterSecondChoice: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 10, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterSecondChoice(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterSecondChoice` replaced. - /// - param newChild: The new `unexpectedAfterSecondChoice` to replace the node's - /// current `unexpectedAfterSecondChoice`, if present. - public func withUnexpectedAfterSecondChoice(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return TernaryExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeConditionExpression, - \Self.conditionExpression, - \Self.unexpectedBetweenConditionExpressionAndQuestionMark, - \Self.questionMark, - \Self.unexpectedBetweenQuestionMarkAndFirstChoice, - \Self.firstChoice, - \Self.unexpectedBetweenFirstChoiceAndColonMark, - \Self.colonMark, - \Self.unexpectedBetweenColonMarkAndSecondChoice, - \Self.secondChoice, - \Self.unexpectedAfterSecondChoice, - ]) - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return "condition" - case 2: - return nil - case 3: - return nil - case 4: - return nil - case 5: - return "first choice" - case 6: - return nil - case 7: - return nil - case 8: - return nil - case 9: - return "second choice" - case 10: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension TernaryExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeConditionExpression": unexpectedBeforeConditionExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "conditionExpression": Syntax(conditionExpression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenConditionExpressionAndQuestionMark": unexpectedBetweenConditionExpressionAndQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "questionMark": Syntax(questionMark).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenQuestionMarkAndFirstChoice": unexpectedBetweenQuestionMarkAndFirstChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "firstChoice": Syntax(firstChoice).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenFirstChoiceAndColonMark": unexpectedBetweenFirstChoiceAndColonMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colonMark": Syntax(colonMark).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenColonMarkAndSecondChoice": unexpectedBetweenColonMarkAndSecondChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "secondChoice": Syntax(secondChoice).asProtocol(SyntaxProtocol.self), - "unexpectedAfterSecondChoice": unexpectedAfterSecondChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - MemberAccessExprSyntax - -public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .memberAccessExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `MemberAccessExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .memberAccessExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, - base: ExprSyntax?, - _ unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax, - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax?, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeBase?.raw, - base?.raw, - unexpectedBetweenBaseAndDot?.raw, - dot.raw, - unexpectedBetweenDotAndName?.raw, - name.raw, - unexpectedBetweenNameAndDeclNameArguments?.raw, - declNameArguments?.raw, - unexpectedAfterDeclNameArguments?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.memberAccessExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeBase: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeBase(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeBase` replaced. - /// - param newChild: The new `unexpectedBeforeBase` to replace the node's - /// current `unexpectedBeforeBase`, if present. - public func withUnexpectedBeforeBase(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) - } - - public var base: ExprSyntax? { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } return ExprSyntax(childData!) } set(value) { - self = withBase(value) + self = withConditionExpression(value) } } - /// Returns a copy of the receiver with its `base` replaced. - /// - param newChild: The new `base` to replace the node's - /// current `base`, if present. - public func withBase(_ newChild: ExprSyntax?) -> MemberAccessExprSyntax { + /// Returns a copy of the receiver with its `conditionExpression` replaced. + /// - param newChild: The new `conditionExpression` to replace the node's + /// current `conditionExpression`, if present. + public func withConditionExpression(_ newChild: ExprSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) + return TernaryExprSyntax(newData) } - public var unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? { + public var unexpectedBetweenConditionExpressionAndQuestionMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenBaseAndDot(value) + self = withUnexpectedBetweenConditionExpressionAndQuestionMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenBaseAndDot` replaced. - /// - param newChild: The new `unexpectedBetweenBaseAndDot` to replace the node's - /// current `unexpectedBetweenBaseAndDot`, if present. - public func withUnexpectedBetweenBaseAndDot(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenConditionExpressionAndQuestionMark` replaced. + /// - param newChild: The new `unexpectedBetweenConditionExpressionAndQuestionMark` to replace the node's + /// current `unexpectedBetweenConditionExpressionAndQuestionMark`, if present. + public func withUnexpectedBetweenConditionExpressionAndQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) + return TernaryExprSyntax(newData) } - public var dot: TokenSyntax { + public var questionMark: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withDot(value) + self = withQuestionMark(value) } } - /// Returns a copy of the receiver with its `dot` replaced. - /// - param newChild: The new `dot` to replace the node's - /// current `dot`, if present. - public func withDot(_ newChild: TokenSyntax?) -> MemberAccessExprSyntax { + /// Returns a copy of the receiver with its `questionMark` replaced. + /// - param newChild: The new `questionMark` to replace the node's + /// current `questionMark`, if present. + public func withQuestionMark(_ newChild: TokenSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.period, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.infixQuestionMark, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) + return TernaryExprSyntax(newData) } - public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenDotAndName(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenDotAndName` replaced. - /// - param newChild: The new `unexpectedBetweenDotAndName` to replace the node's - /// current `unexpectedBetweenDotAndName`, if present. - public func withUnexpectedBetweenDotAndName(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) - } - - public var name: TokenSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withName(value) - } - } - - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax?) -> MemberAccessExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) - } - - public var unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenNameAndDeclNameArguments(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndDeclNameArguments` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndDeclNameArguments` to replace the node's - /// current `unexpectedBetweenNameAndDeclNameArguments`, if present. - public func withUnexpectedBetweenNameAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) - } - - public var declNameArguments: DeclNameArgumentsSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return DeclNameArgumentsSyntax(childData!) - } - set(value) { - self = withDeclNameArguments(value) - } - } - - /// Returns a copy of the receiver with its `declNameArguments` replaced. - /// - param newChild: The new `declNameArguments` to replace the node's - /// current `declNameArguments`, if present. - public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> MemberAccessExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) - } - - public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterDeclNameArguments(value) + self = withUnexpectedBetweenQuestionMarkAndFirstChoice(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterDeclNameArguments` replaced. - /// - param newChild: The new `unexpectedAfterDeclNameArguments` to replace the node's - /// current `unexpectedAfterDeclNameArguments`, if present. - public func withUnexpectedAfterDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenQuestionMarkAndFirstChoice` replaced. + /// - param newChild: The new `unexpectedBetweenQuestionMarkAndFirstChoice` to replace the node's + /// current `unexpectedBetweenQuestionMarkAndFirstChoice`, if present. + public func withUnexpectedBetweenQuestionMarkAndFirstChoice(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return MemberAccessExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeBase, - \Self.base, - \Self.unexpectedBetweenBaseAndDot, - \Self.dot, - \Self.unexpectedBetweenDotAndName, - \Self.name, - \Self.unexpectedBetweenNameAndDeclNameArguments, - \Self.declNameArguments, - \Self.unexpectedAfterDeclNameArguments, - ]) - } - - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return "base" - case 2: - return nil - case 3: - return nil - case 4: - return nil - case 5: - return "name" - case 6: - return nil - case 7: - return nil - case 8: - return nil - default: - fatalError("Invalid index") - } + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return TernaryExprSyntax(newData) } -} -extension MemberAccessExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeBase": unexpectedBeforeBase.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "base": base.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenBaseAndDot": unexpectedBetweenBaseAndDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "dot": Syntax(dot).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenDotAndName": unexpectedBetweenDotAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "name": Syntax(name).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenNameAndDeclNameArguments": unexpectedBetweenNameAndDeclNameArguments.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, - ]) + public var firstChoice: ExprSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return ExprSyntax(childData!) + } + set(value) { + self = withFirstChoice(value) + } } -} - -// MARK: - UnresolvedIsExprSyntax -public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax + /// Returns a copy of the receiver with its `firstChoice` replaced. + /// - param newChild: The new `firstChoice` to replace the node's + /// current `firstChoice`, if present. + public func withFirstChoice(_ newChild: ExprSyntax?) -> TernaryExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return TernaryExprSyntax(newData) + } - public init?(_ node: S) { - guard node.raw.kind == .unresolvedIsExpr else { return nil } - self._syntaxNode = node._syntaxNode + public var unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenFirstChoiceAndColonMark(value) + } } - /// Creates a `UnresolvedIsExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .unresolvedIsExpr) - self._syntaxNode = Syntax(data) + /// Returns a copy of the receiver with its `unexpectedBetweenFirstChoiceAndColonMark` replaced. + /// - param newChild: The new `unexpectedBetweenFirstChoiceAndColonMark` to replace the node's + /// current `unexpectedBetweenFirstChoiceAndColonMark`, if present. + public func withUnexpectedBetweenFirstChoiceAndColonMark(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return TernaryExprSyntax(newData) } - public init( - _ unexpectedBeforeIsTok: UnexpectedNodesSyntax? = nil, - isTok: TokenSyntax, - _ unexpectedAfterIsTok: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeIsTok?.raw, - isTok.raw, - unexpectedAfterIsTok?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedIsExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) + public var colonMark: TokenSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withColonMark(value) } - self.init(data) } - public var unexpectedBeforeIsTok: UnexpectedNodesSyntax? { + /// Returns a copy of the receiver with its `colonMark` replaced. + /// - param newChild: The new `colonMark` to replace the node's + /// current `colonMark`, if present. + public func withColonMark(_ newChild: TokenSyntax?) -> TernaryExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: arena) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return TernaryExprSyntax(newData) + } + + public var unexpectedBetweenColonMarkAndSecondChoice: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeIsTok(value) + self = withUnexpectedBetweenColonMarkAndSecondChoice(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeIsTok` replaced. - /// - param newChild: The new `unexpectedBeforeIsTok` to replace the node's - /// current `unexpectedBeforeIsTok`, if present. - public func withUnexpectedBeforeIsTok(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedIsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenColonMarkAndSecondChoice` replaced. + /// - param newChild: The new `unexpectedBetweenColonMarkAndSecondChoice` to replace the node's + /// current `unexpectedBetweenColonMarkAndSecondChoice`, if present. + public func withUnexpectedBetweenColonMarkAndSecondChoice(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return UnresolvedIsExprSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return TernaryExprSyntax(newData) } - public var isTok: TokenSyntax { + public var secondChoice: ExprSyntax { get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 9, parent: Syntax(self)) + return ExprSyntax(childData!) } set(value) { - self = withIsTok(value) + self = withSecondChoice(value) } } - /// Returns a copy of the receiver with its `isTok` replaced. - /// - param newChild: The new `isTok` to replace the node's - /// current `isTok`, if present. - public func withIsTok(_ newChild: TokenSyntax?) -> UnresolvedIsExprSyntax { + /// Returns a copy of the receiver with its `secondChoice` replaced. + /// - param newChild: The new `secondChoice` to replace the node's + /// current `secondChoice`, if present. + public func withSecondChoice(_ newChild: ExprSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.isKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return UnresolvedIsExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return TernaryExprSyntax(newData) } - public var unexpectedAfterIsTok: UnexpectedNodesSyntax? { + public var unexpectedAfterSecondChoice: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterIsTok(value) + self = withUnexpectedAfterSecondChoice(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterIsTok` replaced. - /// - param newChild: The new `unexpectedAfterIsTok` to replace the node's - /// current `unexpectedAfterIsTok`, if present. - public func withUnexpectedAfterIsTok(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedIsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterSecondChoice` replaced. + /// - param newChild: The new `unexpectedAfterSecondChoice` to replace the node's + /// current `unexpectedAfterSecondChoice`, if present. + public func withUnexpectedAfterSecondChoice(_ newChild: UnexpectedNodesSyntax?) -> TernaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return UnresolvedIsExprSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return TernaryExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeIsTok, - \Self.isTok, - \Self.unexpectedAfterIsTok, + \Self.unexpectedBeforeConditionExpression, + \Self.conditionExpression, + \Self.unexpectedBetweenConditionExpressionAndQuestionMark, + \Self.questionMark, + \Self.unexpectedBetweenQuestionMarkAndFirstChoice, + \Self.firstChoice, + \Self.unexpectedBetweenFirstChoiceAndColonMark, + \Self.colonMark, + \Self.unexpectedBetweenColonMarkAndSecondChoice, + \Self.secondChoice, + \Self.unexpectedAfterSecondChoice, ]) } @@ -5786,222 +4431,295 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "condition" case 2: return nil + case 3: + return nil + case 4: + return nil + case 5: + return "first choice" + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return "second choice" + case 10: + return nil default: fatalError("Invalid index") } } } -extension UnresolvedIsExprSyntax: CustomReflectable { +extension TernaryExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeIsTok": unexpectedBeforeIsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "isTok": Syntax(isTok).asProtocol(SyntaxProtocol.self), - "unexpectedAfterIsTok": unexpectedAfterIsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeConditionExpression": unexpectedBeforeConditionExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "conditionExpression": Syntax(conditionExpression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenConditionExpressionAndQuestionMark": unexpectedBetweenConditionExpressionAndQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "questionMark": Syntax(questionMark).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenQuestionMarkAndFirstChoice": unexpectedBetweenQuestionMarkAndFirstChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "firstChoice": Syntax(firstChoice).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenFirstChoiceAndColonMark": unexpectedBetweenFirstChoiceAndColonMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "colonMark": Syntax(colonMark).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenColonMarkAndSecondChoice": unexpectedBetweenColonMarkAndSecondChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "secondChoice": Syntax(secondChoice).asProtocol(SyntaxProtocol.self), + "unexpectedAfterSecondChoice": unexpectedAfterSecondChoice.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - IsExprSyntax +// MARK: - MemberAccessExprSyntax -public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .isExpr else { return nil } + guard node.raw.kind == .memberAccessExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `IsExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `MemberAccessExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .isExpr) + assert(data.raw.kind == .memberAccessExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: ExprSyntax, - _ unexpectedBetweenExpressionAndIsTok: UnexpectedNodesSyntax? = nil, - isTok: TokenSyntax, - _ unexpectedBetweenIsTokAndTypeName: UnexpectedNodesSyntax? = nil, - typeName: TypeSyntax, - _ unexpectedAfterTypeName: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, + base: ExprSyntax?, + _ unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax, + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax?, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndIsTok?.raw, - isTok.raw, - unexpectedBetweenIsTokAndTypeName?.raw, - typeName.raw, - unexpectedAfterTypeName?.raw, + unexpectedBeforeBase?.raw, + base?.raw, + unexpectedBetweenBaseAndDot?.raw, + dot.raw, + unexpectedBetweenDotAndName?.raw, + name.raw, + unexpectedBetweenNameAndDeclNameArguments?.raw, + declNameArguments?.raw, + unexpectedAfterDeclNameArguments?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.isExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.memberAccessExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { + public var unexpectedBeforeBase: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeExpression(value) + self = withUnexpectedBeforeBase(value) } } - - /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. - /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's - /// current `unexpectedBeforeExpression`, if present. - public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { + + /// Returns a copy of the receiver with its `unexpectedBeforeBase` replaced. + /// - param newChild: The new `unexpectedBeforeBase` to replace the node's + /// current `unexpectedBeforeBase`, if present. + public func withUnexpectedBeforeBase(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return IsExprSyntax(newData) + return MemberAccessExprSyntax(newData) } - public var expression: ExprSyntax { + public var base: ExprSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } return ExprSyntax(childData!) } set(value) { - self = withExpression(value) + self = withBase(value) } } - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax?) -> IsExprSyntax { + /// Returns a copy of the receiver with its `base` replaced. + /// - param newChild: The new `base` to replace the node's + /// current `base`, if present. + public func withBase(_ newChild: ExprSyntax?) -> MemberAccessExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return IsExprSyntax(newData) + return MemberAccessExprSyntax(newData) } - public var unexpectedBetweenExpressionAndIsTok: UnexpectedNodesSyntax? { + public var unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionAndIsTok(value) + self = withUnexpectedBetweenBaseAndDot(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndIsTok` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndIsTok` to replace the node's - /// current `unexpectedBetweenExpressionAndIsTok`, if present. - public func withUnexpectedBetweenExpressionAndIsTok(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenBaseAndDot` replaced. + /// - param newChild: The new `unexpectedBetweenBaseAndDot` to replace the node's + /// current `unexpectedBetweenBaseAndDot`, if present. + public func withUnexpectedBetweenBaseAndDot(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return IsExprSyntax(newData) + return MemberAccessExprSyntax(newData) } - public var isTok: TokenSyntax { + public var dot: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withIsTok(value) + self = withDot(value) } } - /// Returns a copy of the receiver with its `isTok` replaced. - /// - param newChild: The new `isTok` to replace the node's - /// current `isTok`, if present. - public func withIsTok(_ newChild: TokenSyntax?) -> IsExprSyntax { + /// Returns a copy of the receiver with its `dot` replaced. + /// - param newChild: The new `dot` to replace the node's + /// current `dot`, if present. + public func withDot(_ newChild: TokenSyntax?) -> MemberAccessExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.isKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.period, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return IsExprSyntax(newData) + return MemberAccessExprSyntax(newData) } - public var unexpectedBetweenIsTokAndTypeName: UnexpectedNodesSyntax? { + public var unexpectedBetweenDotAndName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenIsTokAndTypeName(value) + self = withUnexpectedBetweenDotAndName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenIsTokAndTypeName` replaced. - /// - param newChild: The new `unexpectedBetweenIsTokAndTypeName` to replace the node's - /// current `unexpectedBetweenIsTokAndTypeName`, if present. - public func withUnexpectedBetweenIsTokAndTypeName(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenDotAndName` replaced. + /// - param newChild: The new `unexpectedBetweenDotAndName` to replace the node's + /// current `unexpectedBetweenDotAndName`, if present. + public func withUnexpectedBetweenDotAndName(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return IsExprSyntax(newData) + return MemberAccessExprSyntax(newData) } - public var typeName: TypeSyntax { + public var name: TokenSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TypeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withTypeName(value) + self = withName(value) } } - /// Returns a copy of the receiver with its `typeName` replaced. - /// - param newChild: The new `typeName` to replace the node's - /// current `typeName`, if present. - public func withTypeName(_ newChild: TypeSyntax?) -> IsExprSyntax { + /// Returns a copy of the receiver with its `name` replaced. + /// - param newChild: The new `name` to replace the node's + /// current `name`, if present. + public func withName(_ newChild: TokenSyntax?) -> MemberAccessExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.unknown(""), arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return IsExprSyntax(newData) + return MemberAccessExprSyntax(newData) } - public var unexpectedAfterTypeName: UnexpectedNodesSyntax? { + public var unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterTypeName(value) + self = withUnexpectedBetweenNameAndDeclNameArguments(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterTypeName` replaced. - /// - param newChild: The new `unexpectedAfterTypeName` to replace the node's - /// current `unexpectedAfterTypeName`, if present. - public func withUnexpectedAfterTypeName(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenNameAndDeclNameArguments` replaced. + /// - param newChild: The new `unexpectedBetweenNameAndDeclNameArguments` to replace the node's + /// current `unexpectedBetweenNameAndDeclNameArguments`, if present. + public func withUnexpectedBetweenNameAndDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return IsExprSyntax(newData) + return MemberAccessExprSyntax(newData) + } + + public var declNameArguments: DeclNameArgumentsSyntax? { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } + return DeclNameArgumentsSyntax(childData!) + } + set(value) { + self = withDeclNameArguments(value) + } + } + + /// Returns a copy of the receiver with its `declNameArguments` replaced. + /// - param newChild: The new `declNameArguments` to replace the node's + /// current `declNameArguments`, if present. + public func withDeclNameArguments(_ newChild: DeclNameArgumentsSyntax?) -> MemberAccessExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return MemberAccessExprSyntax(newData) + } + + public var unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterDeclNameArguments(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterDeclNameArguments` replaced. + /// - param newChild: The new `unexpectedAfterDeclNameArguments` to replace the node's + /// current `unexpectedAfterDeclNameArguments`, if present. + public func withUnexpectedAfterDeclNameArguments(_ newChild: UnexpectedNodesSyntax?) -> MemberAccessExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return MemberAccessExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndIsTok, - \Self.isTok, - \Self.unexpectedBetweenIsTokAndTypeName, - \Self.typeName, - \Self.unexpectedAfterTypeName, + \Self.unexpectedBeforeBase, + \Self.base, + \Self.unexpectedBetweenBaseAndDot, + \Self.dot, + \Self.unexpectedBetweenDotAndName, + \Self.name, + \Self.unexpectedBetweenNameAndDeclNameArguments, + \Self.declNameArguments, + \Self.unexpectedAfterDeclNameArguments, ]) } @@ -6010,7 +4728,7 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "base" case 2: return nil case 3: @@ -6018,180 +4736,138 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 4: return nil case 5: - return nil + return "name" case 6: return nil + case 7: + return nil + case 8: + return nil default: fatalError("Invalid index") } } } -extension IsExprSyntax: CustomReflectable { +extension MemberAccessExprSyntax: 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), - "unexpectedBetweenExpressionAndIsTok": unexpectedBetweenExpressionAndIsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "isTok": Syntax(isTok).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenIsTokAndTypeName": unexpectedBetweenIsTokAndTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "typeName": Syntax(typeName).asProtocol(SyntaxProtocol.self), - "unexpectedAfterTypeName": unexpectedAfterTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeBase": unexpectedBeforeBase.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "base": base.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenBaseAndDot": unexpectedBetweenBaseAndDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "dot": Syntax(dot).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenDotAndName": unexpectedBetweenDotAndName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "name": Syntax(name).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenNameAndDeclNameArguments": unexpectedBetweenNameAndDeclNameArguments.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: - UnresolvedAsExprSyntax +// MARK: - UnresolvedIsExprSyntax -public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unresolvedAsExpr else { return nil } + guard node.raw.kind == .unresolvedIsExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `UnresolvedAsExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnresolvedIsExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .unresolvedAsExpr) + assert(data.raw.kind == .unresolvedIsExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeAsTok: UnexpectedNodesSyntax? = nil, - asTok: TokenSyntax, - _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax?, - _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeIsTok: UnexpectedNodesSyntax? = nil, + isTok: TokenSyntax, + _ unexpectedAfterIsTok: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeAsTok?.raw, - asTok.raw, - unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw, - questionOrExclamationMark?.raw, - unexpectedAfterQuestionOrExclamationMark?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedAsExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeAsTok: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeAsTok(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeAsTok` replaced. - /// - param newChild: The new `unexpectedBeforeAsTok` to replace the node's - /// current `unexpectedBeforeAsTok`, if present. - public func withUnexpectedBeforeAsTok(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedAsExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return UnresolvedAsExprSyntax(newData) - } - - public var asTok: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withAsTok(value) - } - } - - /// Returns a copy of the receiver with its `asTok` replaced. - /// - param newChild: The new `asTok` to replace the node's - /// current `asTok`, if present. - public func withAsTok(_ newChild: TokenSyntax?) -> UnresolvedAsExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.asKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return UnresolvedAsExprSyntax(newData) + unexpectedBeforeIsTok?.raw, + isTok.raw, + unexpectedAfterIsTok?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedIsExpr, + from: layout, arena: arena) + return SyntaxData.forRoot(raw) + } + self.init(data) } - public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedBeforeIsTok: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(value) + self = withUnexpectedBeforeIsTok(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAsTokAndQuestionOrExclamationMark` replaced. - /// - param newChild: The new `unexpectedBetweenAsTokAndQuestionOrExclamationMark` to replace the node's - /// current `unexpectedBetweenAsTokAndQuestionOrExclamationMark`, if present. - public func withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedAsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeIsTok` replaced. + /// - param newChild: The new `unexpectedBeforeIsTok` to replace the node's + /// current `unexpectedBeforeIsTok`, if present. + public func withUnexpectedBeforeIsTok(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedIsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return UnresolvedAsExprSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return UnresolvedIsExprSyntax(newData) } - public var questionOrExclamationMark: TokenSyntax? { + public var isTok: TokenSyntax { get { - let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withQuestionOrExclamationMark(value) + self = withIsTok(value) } } - /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced. - /// - param newChild: The new `questionOrExclamationMark` to replace the node's - /// current `questionOrExclamationMark`, if present. - public func withQuestionOrExclamationMark(_ newChild: TokenSyntax?) -> UnresolvedAsExprSyntax { + /// Returns a copy of the receiver with its `isTok` replaced. + /// - param newChild: The new `isTok` to replace the node's + /// current `isTok`, if present. + public func withIsTok(_ newChild: TokenSyntax?) -> UnresolvedIsExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return UnresolvedAsExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.isKeyword, arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return UnresolvedIsExprSyntax(newData) } - public var unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedAfterIsTok: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterQuestionOrExclamationMark(value) + self = withUnexpectedAfterIsTok(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterQuestionOrExclamationMark` replaced. - /// - param newChild: The new `unexpectedAfterQuestionOrExclamationMark` to replace the node's - /// current `unexpectedAfterQuestionOrExclamationMark`, if present. - public func withUnexpectedAfterQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedAsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterIsTok` replaced. + /// - param newChild: The new `unexpectedAfterIsTok` to replace the node's + /// current `unexpectedAfterIsTok`, if present. + public func withUnexpectedAfterIsTok(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedIsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return UnresolvedAsExprSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return UnresolvedIsExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeAsTok, - \Self.asTok, - \Self.unexpectedBetweenAsTokAndQuestionOrExclamationMark, - \Self.questionOrExclamationMark, - \Self.unexpectedAfterQuestionOrExclamationMark, + \Self.unexpectedBeforeIsTok, + \Self.isTok, + \Self.unexpectedAfterIsTok, ]) } @@ -6203,70 +4879,60 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 2: return nil - case 3: - return nil - case 4: - return nil default: fatalError("Invalid index") } } } -extension UnresolvedAsExprSyntax: CustomReflectable { +extension UnresolvedIsExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeAsTok": unexpectedBeforeAsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "asTok": Syntax(asTok).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAsTokAndQuestionOrExclamationMark": unexpectedBetweenAsTokAndQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "questionOrExclamationMark": questionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterQuestionOrExclamationMark": unexpectedAfterQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeIsTok": unexpectedBeforeIsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "isTok": Syntax(isTok).asProtocol(SyntaxProtocol.self), + "unexpectedAfterIsTok": unexpectedAfterIsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - AsExprSyntax +// MARK: - IsExprSyntax -public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .asExpr else { return nil } + guard node.raw.kind == .isExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `AsExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `IsExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .asExpr) + assert(data.raw.kind == .isExpr) self._syntaxNode = Syntax(data) } public init( _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, - _ unexpectedBetweenExpressionAndAsTok: UnexpectedNodesSyntax? = nil, - asTok: TokenSyntax, - _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax?, - _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenExpressionAndIsTok: UnexpectedNodesSyntax? = nil, + isTok: TokenSyntax, + _ unexpectedBetweenIsTokAndTypeName: UnexpectedNodesSyntax? = nil, typeName: TypeSyntax, _ unexpectedAfterTypeName: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, - unexpectedBetweenExpressionAndAsTok?.raw, - asTok.raw, - unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw, - questionOrExclamationMark?.raw, - unexpectedBetweenQuestionOrExclamationMarkAndTypeName?.raw, + unexpectedBetweenExpressionAndIsTok?.raw, + isTok.raw, + unexpectedBetweenIsTokAndTypeName?.raw, typeName.raw, unexpectedAfterTypeName?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.asExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.isExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } @@ -6287,11 +4953,11 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's /// current `unexpectedBeforeExpression`, if present. - public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return AsExprSyntax(newData) + return IsExprSyntax(newData) } public var expression: ExprSyntax { @@ -6307,120 +4973,78 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `expression` replaced. /// - param newChild: The new `expression` to replace the node's /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax?) -> AsExprSyntax { + public func withExpression(_ newChild: ExprSyntax?) -> IsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return AsExprSyntax(newData) + return IsExprSyntax(newData) } - public var unexpectedBetweenExpressionAndAsTok: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndIsTok: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionAndAsTok(value) + self = withUnexpectedBetweenExpressionAndIsTok(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndAsTok` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndAsTok` to replace the node's - /// current `unexpectedBetweenExpressionAndAsTok`, if present. - public func withUnexpectedBetweenExpressionAndAsTok(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndIsTok` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndIsTok` to replace the node's + /// current `unexpectedBetweenExpressionAndIsTok`, if present. + public func withUnexpectedBetweenExpressionAndIsTok(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return AsExprSyntax(newData) + return IsExprSyntax(newData) } - public var asTok: TokenSyntax { + public var isTok: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withAsTok(value) + self = withIsTok(value) } } - /// Returns a copy of the receiver with its `asTok` replaced. - /// - param newChild: The new `asTok` to replace the node's - /// current `asTok`, if present. - public func withAsTok(_ newChild: TokenSyntax?) -> AsExprSyntax { + /// Returns a copy of the receiver with its `isTok` replaced. + /// - param newChild: The new `isTok` to replace the node's + /// current `isTok`, if present. + public func withIsTok(_ newChild: TokenSyntax?) -> IsExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.asKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.isKeyword, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return AsExprSyntax(newData) + return IsExprSyntax(newData) } - public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedBetweenIsTokAndTypeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(value) + self = withUnexpectedBetweenIsTokAndTypeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenAsTokAndQuestionOrExclamationMark` replaced. - /// - param newChild: The new `unexpectedBetweenAsTokAndQuestionOrExclamationMark` to replace the node's - /// current `unexpectedBetweenAsTokAndQuestionOrExclamationMark`, if present. - public func withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenIsTokAndTypeName` replaced. + /// - param newChild: The new `unexpectedBetweenIsTokAndTypeName` to replace the node's + /// current `unexpectedBetweenIsTokAndTypeName`, if present. + public func withUnexpectedBetweenIsTokAndTypeName(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return AsExprSyntax(newData) - } - - public var questionOrExclamationMark: TokenSyntax? { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withQuestionOrExclamationMark(value) - } - } - - /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced. - /// - param newChild: The new `questionOrExclamationMark` to replace the node's - /// current `questionOrExclamationMark`, if present. - public func withQuestionOrExclamationMark(_ newChild: TokenSyntax?) -> AsExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return AsExprSyntax(newData) - } - - public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenQuestionOrExclamationMarkAndTypeName(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenQuestionOrExclamationMarkAndTypeName` replaced. - /// - param newChild: The new `unexpectedBetweenQuestionOrExclamationMarkAndTypeName` to replace the node's - /// current `unexpectedBetweenQuestionOrExclamationMarkAndTypeName`, if present. - public func withUnexpectedBetweenQuestionOrExclamationMarkAndTypeName(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return AsExprSyntax(newData) + return IsExprSyntax(newData) } public var typeName: TypeSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) + let childData = data.child(at: 5, parent: Syntax(self)) return TypeSyntax(childData!) } set(value) { @@ -6431,16 +5055,16 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `typeName` replaced. /// - param newChild: The new `typeName` to replace the node's /// current `typeName`, if present. - public func withTypeName(_ newChild: TypeSyntax?) -> AsExprSyntax { + public func withTypeName(_ newChild: TypeSyntax?) -> IsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return AsExprSyntax(newData) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return IsExprSyntax(newData) } public var unexpectedAfterTypeName: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } @@ -6452,22 +5076,20 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `unexpectedAfterTypeName` replaced. /// - param newChild: The new `unexpectedAfterTypeName` to replace the node's /// current `unexpectedAfterTypeName`, if present. - public func withUnexpectedAfterTypeName(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { + public func withUnexpectedAfterTypeName(_ newChild: UnexpectedNodesSyntax?) -> IsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return AsExprSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return IsExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeExpression, \Self.expression, - \Self.unexpectedBetweenExpressionAndAsTok, - \Self.asTok, - \Self.unexpectedBetweenAsTokAndQuestionOrExclamationMark, - \Self.questionOrExclamationMark, - \Self.unexpectedBetweenQuestionOrExclamationMarkAndTypeName, + \Self.unexpectedBetweenExpressionAndIsTok, + \Self.isTok, + \Self.unexpectedBetweenIsTokAndTypeName, \Self.typeName, \Self.unexpectedAfterTypeName, ]) @@ -6489,135 +5111,177 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 6: return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension AsExprSyntax: CustomReflectable { +extension IsExprSyntax: 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), - "unexpectedBetweenExpressionAndAsTok": unexpectedBetweenExpressionAndAsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "asTok": Syntax(asTok).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenAsTokAndQuestionOrExclamationMark": unexpectedBetweenAsTokAndQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "questionOrExclamationMark": questionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenQuestionOrExclamationMarkAndTypeName": unexpectedBetweenQuestionOrExclamationMarkAndTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenExpressionAndIsTok": unexpectedBetweenExpressionAndIsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "isTok": Syntax(isTok).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenIsTokAndTypeName": unexpectedBetweenIsTokAndTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "typeName": Syntax(typeName).asProtocol(SyntaxProtocol.self), "unexpectedAfterTypeName": unexpectedAfterTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - TypeExprSyntax +// MARK: - UnresolvedAsExprSyntax -public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeExpr else { return nil } + guard node.raw.kind == .unresolvedAsExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `TypeExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `UnresolvedAsExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .typeExpr) + assert(data.raw.kind == .unresolvedAsExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, - type: TypeSyntax, - _ unexpectedAfterType: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeAsTok: UnexpectedNodesSyntax? = nil, + asTok: TokenSyntax, + _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax?, + _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedAfterType?.raw, + unexpectedBeforeAsTok?.raw, + asTok.raw, + unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw, + questionOrExclamationMark?.raw, + unexpectedAfterQuestionOrExclamationMark?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.typeExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedAsExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeType: UnexpectedNodesSyntax? { + public var unexpectedBeforeAsTok: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeType(value) + self = withUnexpectedBeforeAsTok(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeType` replaced. - /// - param newChild: The new `unexpectedBeforeType` to replace the node's - /// current `unexpectedBeforeType`, if present. - public func withUnexpectedBeforeType(_ newChild: UnexpectedNodesSyntax?) -> TypeExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeAsTok` replaced. + /// - param newChild: The new `unexpectedBeforeAsTok` to replace the node's + /// current `unexpectedBeforeAsTok`, if present. + public func withUnexpectedBeforeAsTok(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedAsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return TypeExprSyntax(newData) + return UnresolvedAsExprSyntax(newData) } - public var type: TypeSyntax { + public var asTok: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TypeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withType(value) + self = withAsTok(value) } } - /// Returns a copy of the receiver with its `type` replaced. - /// - param newChild: The new `type` to replace the node's - /// current `type`, if present. - public func withType(_ newChild: TypeSyntax?) -> TypeExprSyntax { + /// Returns a copy of the receiver with its `asTok` replaced. + /// - param newChild: The new `asTok` to replace the node's + /// current `asTok`, if present. + public func withAsTok(_ newChild: TokenSyntax?) -> UnresolvedAsExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.asKeyword, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return TypeExprSyntax(newData) + return UnresolvedAsExprSyntax(newData) } - public var unexpectedAfterType: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterType(value) + self = withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterType` replaced. - /// - param newChild: The new `unexpectedAfterType` to replace the node's - /// current `unexpectedAfterType`, if present. - public func withUnexpectedAfterType(_ newChild: UnexpectedNodesSyntax?) -> TypeExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAsTokAndQuestionOrExclamationMark` replaced. + /// - param newChild: The new `unexpectedBetweenAsTokAndQuestionOrExclamationMark` to replace the node's + /// current `unexpectedBetweenAsTokAndQuestionOrExclamationMark`, if present. + public func withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedAsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return TypeExprSyntax(newData) + return UnresolvedAsExprSyntax(newData) + } + + public var questionOrExclamationMark: TokenSyntax? { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withQuestionOrExclamationMark(value) + } + } + + /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced. + /// - param newChild: The new `questionOrExclamationMark` to replace the node's + /// current `questionOrExclamationMark`, if present. + public func withQuestionOrExclamationMark(_ newChild: TokenSyntax?) -> UnresolvedAsExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return UnresolvedAsExprSyntax(newData) + } + + public var unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterQuestionOrExclamationMark(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedAfterQuestionOrExclamationMark` replaced. + /// - param newChild: The new `unexpectedAfterQuestionOrExclamationMark` to replace the node's + /// current `unexpectedAfterQuestionOrExclamationMark`, if present. + public func withUnexpectedAfterQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedAsExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return UnresolvedAsExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeType, - \Self.type, - \Self.unexpectedAfterType, + \Self.unexpectedBeforeAsTok, + \Self.asTok, + \Self.unexpectedBetweenAsTokAndQuestionOrExclamationMark, + \Self.questionOrExclamationMark, + \Self.unexpectedAfterQuestionOrExclamationMark, ]) } @@ -6629,286 +5293,273 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 2: return nil + case 3: + return nil + case 4: + return nil default: fatalError("Invalid index") } } } -extension TypeExprSyntax: CustomReflectable { +extension UnresolvedAsExprSyntax: 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), - "unexpectedAfterType": unexpectedAfterType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeAsTok": unexpectedBeforeAsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "asTok": Syntax(asTok).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAsTokAndQuestionOrExclamationMark": unexpectedBetweenAsTokAndQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "questionOrExclamationMark": questionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterQuestionOrExclamationMark": unexpectedAfterQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ClosureExprSyntax +// MARK: - AsExprSyntax -public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureExpr else { return nil } + guard node.raw.kind == .asExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ClosureExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `AsExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .closureExpr) + assert(data.raw.kind == .asExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax, - _ unexpectedBetweenLeftBraceAndSignature: UnexpectedNodesSyntax? = nil, - signature: ClosureSignatureSyntax?, - _ unexpectedBetweenSignatureAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax, - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: ExprSyntax, + _ unexpectedBetweenExpressionAndAsTok: UnexpectedNodesSyntax? = nil, + asTok: TokenSyntax, + _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax?, + _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: UnexpectedNodesSyntax? = nil, + typeName: TypeSyntax, + _ unexpectedAfterTypeName: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndSignature?.raw, - signature?.raw, - unexpectedBetweenSignatureAndStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw, + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndAsTok?.raw, + asTok.raw, + unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw, + questionOrExclamationMark?.raw, + unexpectedBetweenQuestionOrExclamationMarkAndTypeName?.raw, + typeName.raw, + unexpectedAfterTypeName?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.asExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeLeftBrace(value) + self = withUnexpectedBeforeExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeLeftBrace` replaced. - /// - param newChild: The new `unexpectedBeforeLeftBrace` to replace the node's - /// current `unexpectedBeforeLeftBrace`, if present. - public func withUnexpectedBeforeLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. + /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's + /// current `unexpectedBeforeExpression`, if present. + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var leftBrace: TokenSyntax { + public var expression: ExprSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withLeftBrace(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `leftBrace` replaced. - /// - param newChild: The new `leftBrace` to replace the node's - /// current `leftBrace`, if present. - public func withLeftBrace(_ newChild: TokenSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax?) -> AsExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var unexpectedBetweenLeftBraceAndSignature: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndAsTok: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftBraceAndSignature(value) + self = withUnexpectedBetweenExpressionAndAsTok(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndSignature` replaced. - /// - param newChild: The new `unexpectedBetweenLeftBraceAndSignature` to replace the node's - /// current `unexpectedBetweenLeftBraceAndSignature`, if present. - public func withUnexpectedBetweenLeftBraceAndSignature(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndAsTok` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndAsTok` to replace the node's + /// current `unexpectedBetweenExpressionAndAsTok`, if present. + public func withUnexpectedBetweenExpressionAndAsTok(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var signature: ClosureSignatureSyntax? { + public var asTok: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return ClosureSignatureSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withSignature(value) + self = withAsTok(value) } } - /// Returns a copy of the receiver with its `signature` replaced. - /// - param newChild: The new `signature` to replace the node's - /// current `signature`, if present. - public func withSignature(_ newChild: ClosureSignatureSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `asTok` replaced. + /// - param newChild: The new `asTok` to replace the node's + /// current `asTok`, if present. + public func withAsTok(_ newChild: TokenSyntax?) -> AsExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.asKeyword, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var unexpectedBetweenSignatureAndStatements: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenSignatureAndStatements(value) + self = withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenSignatureAndStatements` replaced. - /// - param newChild: The new `unexpectedBetweenSignatureAndStatements` to replace the node's - /// current `unexpectedBetweenSignatureAndStatements`, if present. - public func withUnexpectedBetweenSignatureAndStatements(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenAsTokAndQuestionOrExclamationMark` replaced. + /// - param newChild: The new `unexpectedBetweenAsTokAndQuestionOrExclamationMark` to replace the node's + /// current `unexpectedBetweenAsTokAndQuestionOrExclamationMark`, if present. + public func withUnexpectedBetweenAsTokAndQuestionOrExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var statements: CodeBlockItemListSyntax { + public var questionOrExclamationMark: TokenSyntax? { get { let childData = data.child(at: 5, parent: Syntax(self)) - return CodeBlockItemListSyntax(childData!) + if childData == nil { return nil } + return TokenSyntax(childData!) } set(value) { - self = withStatements(value) - } - } - - /// Adds the provided `Statement` to the node's `statements` - /// collection. - /// - param element: The new `Statement` to add to the node's - /// `statements` collection. - /// - returns: A copy of the receiver with the provided `Statement` - /// appended to its `statements` collection. - public func addStatement(_ element: CodeBlockItemSyntax) -> ClosureExprSyntax { - 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) + self = withQuestionOrExclamationMark(value) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return ClosureExprSyntax(newData) } - /// Returns a copy of the receiver with its `statements` replaced. - /// - param newChild: The new `statements` to replace the node's - /// current `statements`, if present. - public func withStatements(_ newChild: CodeBlockItemListSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced. + /// - param newChild: The new `questionOrExclamationMark` to replace the node's + /// current `questionOrExclamationMark`, if present. + public func withQuestionOrExclamationMark(_ newChild: TokenSyntax?) -> AsExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? { + public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenStatementsAndRightBrace(value) + self = withUnexpectedBetweenQuestionOrExclamationMarkAndTypeName(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenStatementsAndRightBrace` replaced. - /// - param newChild: The new `unexpectedBetweenStatementsAndRightBrace` to replace the node's - /// current `unexpectedBetweenStatementsAndRightBrace`, if present. - public func withUnexpectedBetweenStatementsAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenQuestionOrExclamationMarkAndTypeName` replaced. + /// - param newChild: The new `unexpectedBetweenQuestionOrExclamationMarkAndTypeName` to replace the node's + /// current `unexpectedBetweenQuestionOrExclamationMarkAndTypeName`, if present. + public func withUnexpectedBetweenQuestionOrExclamationMarkAndTypeName(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var rightBrace: TokenSyntax { + public var typeName: TypeSyntax { get { let childData = data.child(at: 7, parent: Syntax(self)) - return TokenSyntax(childData!) + return TypeSyntax(childData!) } set(value) { - self = withRightBrace(value) + self = withTypeName(value) } } - /// Returns a copy of the receiver with its `rightBrace` replaced. - /// - param newChild: The new `rightBrace` to replace the node's - /// current `rightBrace`, if present. - public func withRightBrace(_ newChild: TokenSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `typeName` replaced. + /// - param newChild: The new `typeName` to replace the node's + /// current `typeName`, if present. + public func withTypeName(_ newChild: TypeSyntax?) -> AsExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } - public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { + public var unexpectedAfterTypeName: UnexpectedNodesSyntax? { get { let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightBrace(value) + self = withUnexpectedAfterTypeName(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. - /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's - /// current `unexpectedAfterRightBrace`, if present. - public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterTypeName` replaced. + /// - param newChild: The new `unexpectedAfterTypeName` to replace the node's + /// current `unexpectedAfterTypeName`, if present. + public func withUnexpectedAfterTypeName(_ newChild: UnexpectedNodesSyntax?) -> AsExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ClosureExprSyntax(newData) + return AsExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftBrace, - \Self.leftBrace, - \Self.unexpectedBetweenLeftBraceAndSignature, - \Self.signature, - \Self.unexpectedBetweenSignatureAndStatements, - \Self.statements, - \Self.unexpectedBetweenStatementsAndRightBrace, - \Self.rightBrace, - \Self.unexpectedAfterRightBrace, + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndAsTok, + \Self.asTok, + \Self.unexpectedBetweenAsTokAndQuestionOrExclamationMark, + \Self.questionOrExclamationMark, + \Self.unexpectedBetweenQuestionOrExclamationMarkAndTypeName, + \Self.typeName, + \Self.unexpectedAfterTypeName, ]) } @@ -6938,125 +5589,125 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension ClosureExprSyntax: CustomReflectable { +extension AsExprSyntax: 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), - "unexpectedBetweenLeftBraceAndSignature": unexpectedBetweenLeftBraceAndSignature.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "signature": signature.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenSignatureAndStatements": unexpectedBetweenSignatureAndStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenStatementsAndRightBrace": unexpectedBetweenStatementsAndRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightBrace": Syntax(rightBrace).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightBrace": unexpectedAfterRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeExpression": unexpectedBeforeExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndAsTok": unexpectedBetweenExpressionAndAsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "asTok": Syntax(asTok).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenAsTokAndQuestionOrExclamationMark": unexpectedBetweenAsTokAndQuestionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "questionOrExclamationMark": questionOrExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenQuestionOrExclamationMarkAndTypeName": unexpectedBetweenQuestionOrExclamationMarkAndTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "typeName": Syntax(typeName).asProtocol(SyntaxProtocol.self), + "unexpectedAfterTypeName": unexpectedAfterTypeName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - UnresolvedPatternExprSyntax +// MARK: - TypeExprSyntax -public struct UnresolvedPatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unresolvedPatternExpr else { return nil } + guard node.raw.kind == .typeExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `UnresolvedPatternExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `TypeExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .unresolvedPatternExpr) + assert(data.raw.kind == .typeExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: PatternSyntax, - _ unexpectedAfterPattern: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, + type: TypeSyntax, + _ unexpectedAfterType: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedAfterPattern?.raw, + unexpectedBeforeType?.raw, + type.raw, + unexpectedAfterType?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedPatternExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.typeExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePattern: UnexpectedNodesSyntax? { + public var unexpectedBeforeType: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePattern(value) + self = withUnexpectedBeforeType(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. - /// - param newChild: The new `unexpectedBeforePattern` to replace the node's - /// current `unexpectedBeforePattern`, if present. - public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedPatternExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeType` replaced. + /// - param newChild: The new `unexpectedBeforeType` to replace the node's + /// current `unexpectedBeforeType`, if present. + public func withUnexpectedBeforeType(_ newChild: UnexpectedNodesSyntax?) -> TypeExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return UnresolvedPatternExprSyntax(newData) + return TypeExprSyntax(newData) } - public var pattern: PatternSyntax { + public var type: TypeSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return PatternSyntax(childData!) + return TypeSyntax(childData!) } set(value) { - self = withPattern(value) + self = withType(value) } } - /// Returns a copy of the receiver with its `pattern` replaced. - /// - param newChild: The new `pattern` to replace the node's - /// current `pattern`, if present. - public func withPattern(_ newChild: PatternSyntax?) -> UnresolvedPatternExprSyntax { + /// Returns a copy of the receiver with its `type` replaced. + /// - param newChild: The new `type` to replace the node's + /// current `type`, if present. + public func withType(_ newChild: TypeSyntax?) -> TypeExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingType, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return UnresolvedPatternExprSyntax(newData) + return TypeExprSyntax(newData) } - public var unexpectedAfterPattern: UnexpectedNodesSyntax? { + public var unexpectedAfterType: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterPattern(value) + self = withUnexpectedAfterType(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterPattern` replaced. - /// - param newChild: The new `unexpectedAfterPattern` to replace the node's - /// current `unexpectedAfterPattern`, if present. - public func withUnexpectedAfterPattern(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedPatternExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterType` replaced. + /// - param newChild: The new `unexpectedAfterType` to replace the node's + /// current `unexpectedAfterType`, if present. + public func withUnexpectedAfterType(_ newChild: UnexpectedNodesSyntax?) -> TypeExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return UnresolvedPatternExprSyntax(newData) + return TypeExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePattern, - \Self.pattern, - \Self.unexpectedAfterPattern, + \Self.unexpectedBeforeType, + \Self.type, + \Self.unexpectedAfterType, ]) } @@ -7074,396 +5725,428 @@ public struct UnresolvedPatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension UnresolvedPatternExprSyntax: CustomReflectable { +extension TypeExprSyntax: 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), - "unexpectedAfterPattern": unexpectedAfterPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeType": unexpectedBeforeType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "type": Syntax(type).asProtocol(SyntaxProtocol.self), + "unexpectedAfterType": unexpectedAfterType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - FunctionCallExprSyntax +// MARK: - ClosureExprSyntax -public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionCallExpr else { return nil } + guard node.raw.kind == .closureExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `FunctionCallExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ClosureExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .functionCallExpr) + assert(data.raw.kind == .closureExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? = nil, - calledExpression: ExprSyntax, - _ unexpectedBetweenCalledExpressionAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax?, - _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax?, - _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, - trailingClosure: ClosureExprSyntax?, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, - additionalTrailingClosures: MultipleTrailingClosureElementListSyntax?, - _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax, + _ unexpectedBetweenLeftBraceAndSignature: UnexpectedNodesSyntax? = nil, + signature: ClosureSignatureSyntax?, + _ unexpectedBetweenSignatureAndStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax, + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeCalledExpression?.raw, - calledExpression.raw, - unexpectedBetweenCalledExpressionAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArgumentList?.raw, - argumentList.raw, - unexpectedBetweenArgumentListAndRightParen?.raw, - rightParen?.raw, - unexpectedBetweenRightParenAndTrailingClosure?.raw, - trailingClosure?.raw, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw, - additionalTrailingClosures?.raw, - unexpectedAfterAdditionalTrailingClosures?.raw, + unexpectedBeforeLeftBrace?.raw, + leftBrace.raw, + unexpectedBetweenLeftBraceAndSignature?.raw, + signature?.raw, + unexpectedBetweenSignatureAndStatements?.raw, + statements.raw, + unexpectedBetweenStatementsAndRightBrace?.raw, + rightBrace.raw, + unexpectedAfterRightBrace?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.functionCallExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? { + public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeCalledExpression(value) + self = withUnexpectedBeforeLeftBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeCalledExpression` replaced. - /// - param newChild: The new `unexpectedBeforeCalledExpression` to replace the node's - /// current `unexpectedBeforeCalledExpression`, if present. - public func withUnexpectedBeforeCalledExpression(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeLeftBrace` replaced. + /// - param newChild: The new `unexpectedBeforeLeftBrace` to replace the node's + /// current `unexpectedBeforeLeftBrace`, if present. + public func withUnexpectedBeforeLeftBrace(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var calledExpression: ExprSyntax { + public var leftBrace: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return ExprSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withCalledExpression(value) + self = withLeftBrace(value) } } - /// Returns a copy of the receiver with its `calledExpression` replaced. - /// - param newChild: The new `calledExpression` to replace the node's - /// current `calledExpression`, if present. - public func withCalledExpression(_ newChild: ExprSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `leftBrace` replaced. + /// - param newChild: The new `leftBrace` to replace the node's + /// current `leftBrace`, if present. + public func withLeftBrace(_ newChild: TokenSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftBrace, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var unexpectedBetweenCalledExpressionAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBraceAndSignature: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCalledExpressionAndLeftParen(value) + self = withUnexpectedBetweenLeftBraceAndSignature(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCalledExpressionAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenCalledExpressionAndLeftParen` to replace the node's - /// current `unexpectedBetweenCalledExpressionAndLeftParen`, if present. - public func withUnexpectedBetweenCalledExpressionAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftBraceAndSignature` replaced. + /// - param newChild: The new `unexpectedBetweenLeftBraceAndSignature` to replace the node's + /// current `unexpectedBetweenLeftBraceAndSignature`, if present. + public func withUnexpectedBetweenLeftBraceAndSignature(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var leftParen: TokenSyntax? { + public var signature: ClosureSignatureSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) if childData == nil { return nil } - return TokenSyntax(childData!) + return ClosureSignatureSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withSignature(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `signature` replaced. + /// - param newChild: The new `signature` to replace the node's + /// current `signature`, if present. + public func withSignature(_ newChild: ClosureSignatureSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? { + public var unexpectedBetweenSignatureAndStatements: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndArgumentList(value) + self = withUnexpectedBetweenSignatureAndStatements(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndArgumentList` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndArgumentList` to replace the node's - /// current `unexpectedBetweenLeftParenAndArgumentList`, if present. - public func withUnexpectedBetweenLeftParenAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenSignatureAndStatements` replaced. + /// - param newChild: The new `unexpectedBetweenSignatureAndStatements` to replace the node's + /// current `unexpectedBetweenSignatureAndStatements`, if present. + public func withUnexpectedBetweenSignatureAndStatements(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var argumentList: TupleExprElementListSyntax { + public var statements: CodeBlockItemListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return TupleExprElementListSyntax(childData!) + return CodeBlockItemListSyntax(childData!) } set(value) { - self = withArgumentList(value) + self = withStatements(value) } } - /// Adds the provided `Argument` to the node's `argumentList` + /// Adds the provided `Statement` to the node's `statements` /// 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) -> FunctionCallExprSyntax { + /// - 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) -> ClosureExprSyntax { 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.tupleExprElementList, + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - /// Returns a copy of the receiver with its `argumentList` replaced. - /// - param newChild: The new `argumentList` to replace the node's - /// current `argumentList`, if present. - public func withArgumentList(_ newChild: TupleExprElementListSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `statements` replaced. + /// - param newChild: The new `statements` to replace the node's + /// current `statements`, if present. + public func withStatements(_ newChild: CodeBlockItemListSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.codeBlockItemList, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenArgumentListAndRightParen(value) + self = withUnexpectedBetweenStatementsAndRightBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenArgumentListAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenArgumentListAndRightParen` to replace the node's - /// current `unexpectedBetweenArgumentListAndRightParen`, if present. - public func withUnexpectedBetweenArgumentListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenStatementsAndRightBrace` replaced. + /// - param newChild: The new `unexpectedBetweenStatementsAndRightBrace` to replace the node's + /// current `unexpectedBetweenStatementsAndRightBrace`, if present. + public func withUnexpectedBetweenStatementsAndRightBrace(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var rightParen: TokenSyntax? { + public var rightBrace: TokenSyntax { get { let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withRightParen(value) + self = withRightBrace(value) } } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `rightBrace` replaced. + /// - param newChild: The new `rightBrace` to replace the node's + /// current `rightBrace`, if present. + public func withRightBrace(_ newChild: TokenSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightBrace, arena: arena) let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? { + public var unexpectedAfterRightBrace: UnexpectedNodesSyntax? { get { let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenRightParenAndTrailingClosure(value) + self = withUnexpectedAfterRightBrace(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenRightParenAndTrailingClosure` replaced. - /// - param newChild: The new `unexpectedBetweenRightParenAndTrailingClosure` to replace the node's - /// current `unexpectedBetweenRightParenAndTrailingClosure`, if present. - public func withUnexpectedBetweenRightParenAndTrailingClosure(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRightBrace` replaced. + /// - param newChild: The new `unexpectedAfterRightBrace` to replace the node's + /// current `unexpectedAfterRightBrace`, if present. + public func withUnexpectedAfterRightBrace(_ newChild: UnexpectedNodesSyntax?) -> ClosureExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + return ClosureExprSyntax(newData) } - public var trailingClosure: ClosureExprSyntax? { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } - return ClosureExprSyntax(childData!) + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeLeftBrace, + \Self.leftBrace, + \Self.unexpectedBetweenLeftBraceAndSignature, + \Self.signature, + \Self.unexpectedBetweenSignatureAndStatements, + \Self.statements, + \Self.unexpectedBetweenStatementsAndRightBrace, + \Self.rightBrace, + \Self.unexpectedAfterRightBrace, + ]) + } + + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + case 3: + return 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") } - set(value) { - self = withTrailingClosure(value) + } +} + +extension ClosureExprSyntax: 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), + "unexpectedBetweenLeftBraceAndSignature": unexpectedBetweenLeftBraceAndSignature.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "signature": signature.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenSignatureAndStatements": unexpectedBetweenSignatureAndStatements.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "statements": Syntax(statements).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenStatementsAndRightBrace": unexpectedBetweenStatementsAndRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightBrace": Syntax(rightBrace).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRightBrace": unexpectedAfterRightBrace.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + +// MARK: - UnresolvedPatternExprSyntax + +public struct UnresolvedPatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .unresolvedPatternExpr else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `UnresolvedPatternExprSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .unresolvedPatternExpr) + self._syntaxNode = Syntax(data) + } + + public init( + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: PatternSyntax, + _ unexpectedAfterPattern: UnexpectedNodesSyntax? = nil + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforePattern?.raw, + pattern.raw, + unexpectedAfterPattern?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.unresolvedPatternExpr, + from: layout, arena: arena) + return SyntaxData.forRoot(raw) } + self.init(data) } - /// Returns a copy of the receiver with its `trailingClosure` replaced. - /// - param newChild: The new `trailingClosure` to replace the node's - /// current `trailingClosure`, if present. - public func withTrailingClosure(_ newChild: ClosureExprSyntax?) -> FunctionCallExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) - } - - public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? { + public var unexpectedBeforePattern: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenTrailingClosureAndAdditionalTrailingClosures(value) + self = withUnexpectedBeforePattern(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures` replaced. - /// - param newChild: The new `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures` to replace the node's - /// current `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures`, if present. - public func withUnexpectedBetweenTrailingClosureAndAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforePattern` replaced. + /// - param newChild: The new `unexpectedBeforePattern` to replace the node's + /// current `unexpectedBeforePattern`, if present. + public func withUnexpectedBeforePattern(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedPatternExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return UnresolvedPatternExprSyntax(newData) } - public var additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? { + public var pattern: PatternSyntax { get { - let childData = data.child(at: 11, parent: Syntax(self)) - if childData == nil { return nil } - return MultipleTrailingClosureElementListSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + return PatternSyntax(childData!) } set(value) { - self = withAdditionalTrailingClosures(value) - } - } - - /// Adds the provided `AdditionalTrailingClosure` to the node's `additionalTrailingClosures` - /// collection. - /// - param element: The new `AdditionalTrailingClosure` to add to the node's - /// `additionalTrailingClosures` collection. - /// - returns: A copy of the receiver with the provided `AdditionalTrailingClosure` - /// appended to its `additionalTrailingClosures` collection. - public func addAdditionalTrailingClosure(_ element: MultipleTrailingClosureElementSyntax) -> FunctionCallExprSyntax { - var collection: RawSyntax - let arena = SyntaxArena() - if let col = raw.layoutView!.children[11] { - collection = col.layoutView!.appending(element.raw, arena: arena) - } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + self = withPattern(value) } - let newData = data.replacingChild(at: 11, with: collection, arena: arena) - return FunctionCallExprSyntax(newData) } - /// Returns a copy of the receiver with its `additionalTrailingClosures` replaced. - /// - param newChild: The new `additionalTrailingClosures` to replace the node's - /// current `additionalTrailingClosures`, if present. - public func withAdditionalTrailingClosures(_ newChild: MultipleTrailingClosureElementListSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `pattern` replaced. + /// - param newChild: The new `pattern` to replace the node's + /// current `pattern`, if present. + public func withPattern(_ newChild: PatternSyntax?) -> UnresolvedPatternExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 11, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingPattern, arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return UnresolvedPatternExprSyntax(newData) } - public var unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? { + public var unexpectedAfterPattern: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 12, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterAdditionalTrailingClosures(value) + self = withUnexpectedAfterPattern(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterAdditionalTrailingClosures` replaced. - /// - param newChild: The new `unexpectedAfterAdditionalTrailingClosures` to replace the node's - /// current `unexpectedAfterAdditionalTrailingClosures`, if present. - public func withUnexpectedAfterAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterPattern` replaced. + /// - param newChild: The new `unexpectedAfterPattern` to replace the node's + /// current `unexpectedAfterPattern`, if present. + public func withUnexpectedAfterPattern(_ newChild: UnexpectedNodesSyntax?) -> UnresolvedPatternExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 12, with: raw, arena: arena) - return FunctionCallExprSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return UnresolvedPatternExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeCalledExpression, - \Self.calledExpression, - \Self.unexpectedBetweenCalledExpressionAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndArgumentList, - \Self.argumentList, - \Self.unexpectedBetweenArgumentListAndRightParen, - \Self.rightParen, - \Self.unexpectedBetweenRightParenAndTrailingClosure, - \Self.trailingClosure, - \Self.unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, - \Self.additionalTrailingClosures, - \Self.unexpectedAfterAdditionalTrailingClosures, + \Self.unexpectedBeforePattern, + \Self.pattern, + \Self.unexpectedAfterPattern, ]) } @@ -7472,28 +6155,8 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return "called expression" - case 2: - return nil - case 3: - return nil - case 4: - return nil - case 5: - return "arguments" - case 6: - return nil - case 7: - return nil - case 8: - return nil - case 9: - return "trailing closure" - case 10: return nil - case 11: - return "trailing closures" - case 12: + case 2: return nil default: fatalError("Invalid index") @@ -7501,54 +6164,44 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension FunctionCallExprSyntax: CustomReflectable { +extension UnresolvedPatternExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeCalledExpression": unexpectedBeforeCalledExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "calledExpression": Syntax(calledExpression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCalledExpressionAndLeftParen": unexpectedBetweenCalledExpressionAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": leftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenLeftParenAndArgumentList": unexpectedBetweenLeftParenAndArgumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "argumentList": Syntax(argumentList).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenArgumentListAndRightParen": unexpectedBetweenArgumentListAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": rightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenRightParenAndTrailingClosure": unexpectedBetweenRightParenAndTrailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "trailingClosure": trailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures": unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "additionalTrailingClosures": additionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterAdditionalTrailingClosures": unexpectedAfterAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforePattern": unexpectedBeforePattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), + "unexpectedAfterPattern": unexpectedAfterPattern.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - SubscriptExprSyntax +// MARK: - FunctionCallExprSyntax -public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .subscriptExpr else { return nil } + guard node.raw.kind == .functionCallExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SubscriptExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `FunctionCallExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .subscriptExpr) + assert(data.raw.kind == .functionCallExpr) self._syntaxNode = Syntax(data) } public init( _ unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? = nil, calledExpression: ExprSyntax, - _ unexpectedBetweenCalledExpressionAndLeftBracket: UnexpectedNodesSyntax? = nil, - leftBracket: TokenSyntax, - _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenCalledExpressionAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax?, + _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, - rightBracket: TokenSyntax, - _ unexpectedBetweenRightBracketAndTrailingClosure: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax?, + _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, trailingClosure: ClosureExprSyntax?, _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, additionalTrailingClosures: MultipleTrailingClosureElementListSyntax?, @@ -7557,20 +6210,20 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { let layout: [RawSyntax?] = [ unexpectedBeforeCalledExpression?.raw, calledExpression.raw, - unexpectedBetweenCalledExpressionAndLeftBracket?.raw, - leftBracket.raw, - unexpectedBetweenLeftBracketAndArgumentList?.raw, + unexpectedBetweenCalledExpressionAndLeftParen?.raw, + leftParen?.raw, + unexpectedBetweenLeftParenAndArgumentList?.raw, argumentList.raw, - unexpectedBetweenArgumentListAndRightBracket?.raw, - rightBracket.raw, - unexpectedBetweenRightBracketAndTrailingClosure?.raw, + unexpectedBetweenArgumentListAndRightParen?.raw, + rightParen?.raw, + unexpectedBetweenRightParenAndTrailingClosure?.raw, trailingClosure?.raw, unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw, additionalTrailingClosures?.raw, unexpectedAfterAdditionalTrailingClosures?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.subscriptExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.functionCallExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } @@ -7591,11 +6244,11 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `unexpectedBeforeCalledExpression` replaced. /// - param newChild: The new `unexpectedBeforeCalledExpression` to replace the node's /// current `unexpectedBeforeCalledExpression`, if present. - public func withUnexpectedBeforeCalledExpression(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + public func withUnexpectedBeforeCalledExpression(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } public var calledExpression: ExprSyntax { @@ -7611,73 +6264,74 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `calledExpression` replaced. /// - param newChild: The new `calledExpression` to replace the node's /// current `calledExpression`, if present. - public func withCalledExpression(_ newChild: ExprSyntax?) -> SubscriptExprSyntax { + public func withCalledExpression(_ newChild: ExprSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } - public var unexpectedBetweenCalledExpressionAndLeftBracket: UnexpectedNodesSyntax? { + public var unexpectedBetweenCalledExpressionAndLeftParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCalledExpressionAndLeftBracket(value) + self = withUnexpectedBetweenCalledExpressionAndLeftParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCalledExpressionAndLeftBracket` replaced. - /// - param newChild: The new `unexpectedBetweenCalledExpressionAndLeftBracket` to replace the node's - /// current `unexpectedBetweenCalledExpressionAndLeftBracket`, if present. - public func withUnexpectedBetweenCalledExpressionAndLeftBracket(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCalledExpressionAndLeftParen` replaced. + /// - param newChild: The new `unexpectedBetweenCalledExpressionAndLeftParen` to replace the node's + /// current `unexpectedBetweenCalledExpressionAndLeftParen`, if present. + public func withUnexpectedBetweenCalledExpressionAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } - public var leftBracket: TokenSyntax { + public var leftParen: TokenSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withLeftBracket(value) + self = withLeftParen(value) } } - /// Returns a copy of the receiver with its `leftBracket` replaced. - /// - param newChild: The new `leftBracket` to replace the node's - /// current `leftBracket`, if present. - public func withLeftBracket(_ newChild: TokenSyntax?) -> SubscriptExprSyntax { + /// Returns a copy of the receiver with its `leftParen` replaced. + /// - param newChild: The new `leftParen` to replace the node's + /// current `leftParen`, if present. + public func withLeftParen(_ newChild: TokenSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } - public var unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftBracketAndArgumentList(value) + self = withUnexpectedBetweenLeftParenAndArgumentList(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftBracketAndArgumentList` replaced. - /// - param newChild: The new `unexpectedBetweenLeftBracketAndArgumentList` to replace the node's - /// current `unexpectedBetweenLeftBracketAndArgumentList`, if present. - public func withUnexpectedBetweenLeftBracketAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndArgumentList` replaced. + /// - param newChild: The new `unexpectedBetweenLeftParenAndArgumentList` to replace the node's + /// current `unexpectedBetweenLeftParenAndArgumentList`, if present. + public func withUnexpectedBetweenLeftParenAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } public var argumentList: TupleExprElementListSyntax { @@ -7696,7 +6350,7 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// `argumentList` collection. /// - returns: A copy of the receiver with the provided `Argument` /// appended to its `argumentList` collection. - public func addArgument(_ element: TupleExprElementSyntax) -> SubscriptExprSyntax { + public func addArgument(_ element: TupleExprElementSyntax) -> FunctionCallExprSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[5] { @@ -7706,79 +6360,80 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } /// Returns a copy of the receiver with its `argumentList` replaced. /// - param newChild: The new `argumentList` to replace the node's /// current `argumentList`, if present. - public func withArgumentList(_ newChild: TupleExprElementListSyntax?) -> SubscriptExprSyntax { + public func withArgumentList(_ newChild: TupleExprElementListSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } - public var unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? { + public var unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? { get { let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenArgumentListAndRightBracket(value) + self = withUnexpectedBetweenArgumentListAndRightParen(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenArgumentListAndRightBracket` replaced. - /// - param newChild: The new `unexpectedBetweenArgumentListAndRightBracket` to replace the node's - /// current `unexpectedBetweenArgumentListAndRightBracket`, if present. - public func withUnexpectedBetweenArgumentListAndRightBracket(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenArgumentListAndRightParen` replaced. + /// - param newChild: The new `unexpectedBetweenArgumentListAndRightParen` to replace the node's + /// current `unexpectedBetweenArgumentListAndRightParen`, if present. + public func withUnexpectedBetweenArgumentListAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } - public var rightBracket: TokenSyntax { + public var rightParen: TokenSyntax? { get { let childData = data.child(at: 7, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withRightBracket(value) + self = withRightParen(value) } } - /// Returns a copy of the receiver with its `rightBracket` replaced. - /// - param newChild: The new `rightBracket` to replace the node's - /// current `rightBracket`, if present. - public func withRightBracket(_ newChild: TokenSyntax?) -> SubscriptExprSyntax { + /// Returns a copy of the receiver with its `rightParen` replaced. + /// - param newChild: The new `rightParen` to replace the node's + /// current `rightParen`, if present. + public func withRightParen(_ newChild: TokenSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } - public var unexpectedBetweenRightBracketAndTrailingClosure: UnexpectedNodesSyntax? { + public var unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? { get { let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenRightBracketAndTrailingClosure(value) + self = withUnexpectedBetweenRightParenAndTrailingClosure(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenRightBracketAndTrailingClosure` replaced. - /// - param newChild: The new `unexpectedBetweenRightBracketAndTrailingClosure` to replace the node's - /// current `unexpectedBetweenRightBracketAndTrailingClosure`, if present. - public func withUnexpectedBetweenRightBracketAndTrailingClosure(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenRightParenAndTrailingClosure` replaced. + /// - param newChild: The new `unexpectedBetweenRightParenAndTrailingClosure` to replace the node's + /// current `unexpectedBetweenRightParenAndTrailingClosure`, if present. + public func withUnexpectedBetweenRightParenAndTrailingClosure(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } public var trailingClosure: ClosureExprSyntax? { @@ -7795,11 +6450,11 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `trailingClosure` replaced. /// - param newChild: The new `trailingClosure` to replace the node's /// current `trailingClosure`, if present. - public func withTrailingClosure(_ newChild: ClosureExprSyntax?) -> SubscriptExprSyntax { + public func withTrailingClosure(_ newChild: ClosureExprSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? { @@ -7816,11 +6471,11 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures` replaced. /// - param newChild: The new `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures` to replace the node's /// current `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures`, if present. - public func withUnexpectedBetweenTrailingClosureAndAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + public func withUnexpectedBetweenTrailingClosureAndAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } public var additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? { @@ -7840,7 +6495,7 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// `additionalTrailingClosures` collection. /// - returns: A copy of the receiver with the provided `AdditionalTrailingClosure` /// appended to its `additionalTrailingClosures` collection. - public func addAdditionalTrailingClosure(_ element: MultipleTrailingClosureElementSyntax) -> SubscriptExprSyntax { + public func addAdditionalTrailingClosure(_ element: MultipleTrailingClosureElementSyntax) -> FunctionCallExprSyntax { var collection: RawSyntax let arena = SyntaxArena() if let col = raw.layoutView!.children[11] { @@ -7850,17 +6505,17 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 11, with: collection, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } /// Returns a copy of the receiver with its `additionalTrailingClosures` replaced. /// - param newChild: The new `additionalTrailingClosures` to replace the node's /// current `additionalTrailingClosures`, if present. - public func withAdditionalTrailingClosures(_ newChild: MultipleTrailingClosureElementListSyntax?) -> SubscriptExprSyntax { + public func withAdditionalTrailingClosures(_ newChild: MultipleTrailingClosureElementListSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 11, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } public var unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? { @@ -7877,24 +6532,24 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `unexpectedAfterAdditionalTrailingClosures` replaced. /// - param newChild: The new `unexpectedAfterAdditionalTrailingClosures` to replace the node's /// current `unexpectedAfterAdditionalTrailingClosures`, if present. - public func withUnexpectedAfterAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + public func withUnexpectedAfterAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> FunctionCallExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 12, with: raw, arena: arena) - return SubscriptExprSyntax(newData) + return FunctionCallExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeCalledExpression, \Self.calledExpression, - \Self.unexpectedBetweenCalledExpressionAndLeftBracket, - \Self.leftBracket, - \Self.unexpectedBetweenLeftBracketAndArgumentList, + \Self.unexpectedBetweenCalledExpressionAndLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndArgumentList, \Self.argumentList, - \Self.unexpectedBetweenArgumentListAndRightBracket, - \Self.rightBracket, - \Self.unexpectedBetweenRightBracketAndTrailingClosure, + \Self.unexpectedBetweenArgumentListAndRightParen, + \Self.rightParen, + \Self.unexpectedBetweenRightParenAndTrailingClosure, \Self.trailingClosure, \Self.unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, \Self.additionalTrailingClosures, @@ -7927,199 +6582,8 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 10: return nil case 11: - return "trailing closures" - case 12: - return nil - default: - fatalError("Invalid index") - } - } -} - -extension SubscriptExprSyntax: CustomReflectable { - public var customMirror: Mirror { - return Mirror(self, children: [ - "unexpectedBeforeCalledExpression": unexpectedBeforeCalledExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "calledExpression": Syntax(calledExpression).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCalledExpressionAndLeftBracket": unexpectedBetweenCalledExpressionAndLeftBracket.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), - "unexpectedBetweenRightBracketAndTrailingClosure": unexpectedBetweenRightBracketAndTrailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "trailingClosure": trailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures": unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "additionalTrailingClosures": additionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterAdditionalTrailingClosures": unexpectedAfterAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - -// MARK: - OptionalChainingExprSyntax - -public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .optionalChainingExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `OptionalChainingExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .optionalChainingExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: ExprSyntax, - _ unexpectedBetweenExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, - questionMark: TokenSyntax, - _ unexpectedAfterQuestionMark: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndQuestionMark?.raw, - questionMark.raw, - unexpectedAfterQuestionMark?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.optionalChainingExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeExpression(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. - /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's - /// current `unexpectedBeforeExpression`, if present. - public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> OptionalChainingExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return OptionalChainingExprSyntax(newData) - } - - public var expression: ExprSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withExpression(value) - } - } - - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax?) -> OptionalChainingExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return OptionalChainingExprSyntax(newData) - } - - public var unexpectedBetweenExpressionAndQuestionMark: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenExpressionAndQuestionMark(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndQuestionMark` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndQuestionMark` to replace the node's - /// current `unexpectedBetweenExpressionAndQuestionMark`, if present. - public func withUnexpectedBetweenExpressionAndQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> OptionalChainingExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return OptionalChainingExprSyntax(newData) - } - - public var questionMark: TokenSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withQuestionMark(value) - } - } - - /// Returns a copy of the receiver with its `questionMark` replaced. - /// - param newChild: The new `questionMark` to replace the node's - /// current `questionMark`, if present. - public func withQuestionMark(_ newChild: TokenSyntax?) -> OptionalChainingExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.postfixQuestionMark, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return OptionalChainingExprSyntax(newData) - } - - public var unexpectedAfterQuestionMark: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterQuestionMark(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterQuestionMark` replaced. - /// - param newChild: The new `unexpectedAfterQuestionMark` to replace the node's - /// current `unexpectedAfterQuestionMark`, if present. - public func withUnexpectedAfterQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> OptionalChainingExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return OptionalChainingExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndQuestionMark, - \Self.questionMark, - \Self.unexpectedAfterQuestionMark, - ]) - } - - 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 "trailing closures" + case 12: return nil default: fatalError("Invalid index") @@ -8127,351 +6591,404 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension OptionalChainingExprSyntax: CustomReflectable { +extension FunctionCallExprSyntax: 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), - "unexpectedBetweenExpressionAndQuestionMark": unexpectedBetweenExpressionAndQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "questionMark": Syntax(questionMark).asProtocol(SyntaxProtocol.self), - "unexpectedAfterQuestionMark": unexpectedAfterQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeCalledExpression": unexpectedBeforeCalledExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "calledExpression": Syntax(calledExpression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCalledExpressionAndLeftParen": unexpectedBetweenCalledExpressionAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "leftParen": leftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenLeftParenAndArgumentList": unexpectedBetweenLeftParenAndArgumentList.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "argumentList": Syntax(argumentList).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenArgumentListAndRightParen": unexpectedBetweenArgumentListAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "rightParen": rightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenRightParenAndTrailingClosure": unexpectedBetweenRightParenAndTrailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "trailingClosure": trailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures": unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "additionalTrailingClosures": additionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterAdditionalTrailingClosures": unexpectedAfterAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ForcedValueExprSyntax +// MARK: - SubscriptExprSyntax -public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .forcedValueExpr else { return nil } + guard node.raw.kind == .subscriptExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ForcedValueExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `SubscriptExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .forcedValueExpr) + assert(data.raw.kind == .subscriptExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: ExprSyntax, - _ unexpectedBetweenExpressionAndExclamationMark: UnexpectedNodesSyntax? = nil, - exclamationMark: TokenSyntax, - _ unexpectedAfterExclamationMark: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? = nil, + calledExpression: ExprSyntax, + _ unexpectedBetweenCalledExpressionAndLeftBracket: UnexpectedNodesSyntax? = nil, + leftBracket: TokenSyntax, + _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, + rightBracket: TokenSyntax, + _ unexpectedBetweenRightBracketAndTrailingClosure: UnexpectedNodesSyntax? = nil, + trailingClosure: ClosureExprSyntax?, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + additionalTrailingClosures: MultipleTrailingClosureElementListSyntax?, + _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndExclamationMark?.raw, - exclamationMark.raw, - unexpectedAfterExclamationMark?.raw, + unexpectedBeforeCalledExpression?.raw, + calledExpression.raw, + unexpectedBetweenCalledExpressionAndLeftBracket?.raw, + leftBracket.raw, + unexpectedBetweenLeftBracketAndArgumentList?.raw, + argumentList.raw, + unexpectedBetweenArgumentListAndRightBracket?.raw, + rightBracket.raw, + unexpectedBetweenRightBracketAndTrailingClosure?.raw, + trailingClosure?.raw, + unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw, + additionalTrailingClosures?.raw, + unexpectedAfterAdditionalTrailingClosures?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.forcedValueExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.subscriptExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { + public var unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeExpression(value) + self = withUnexpectedBeforeCalledExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. - /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's - /// current `unexpectedBeforeExpression`, if present. - public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> ForcedValueExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeCalledExpression` replaced. + /// - param newChild: The new `unexpectedBeforeCalledExpression` to replace the node's + /// current `unexpectedBeforeCalledExpression`, if present. + public func withUnexpectedBeforeCalledExpression(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ForcedValueExprSyntax(newData) + return SubscriptExprSyntax(newData) } - public var expression: ExprSyntax { + public var calledExpression: ExprSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return ExprSyntax(childData!) } set(value) { - self = withExpression(value) + self = withCalledExpression(value) } } - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax?) -> ForcedValueExprSyntax { + /// Returns a copy of the receiver with its `calledExpression` replaced. + /// - param newChild: The new `calledExpression` to replace the node's + /// current `calledExpression`, if present. + public func withCalledExpression(_ newChild: ExprSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ForcedValueExprSyntax(newData) + return SubscriptExprSyntax(newData) } - public var unexpectedBetweenExpressionAndExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedBetweenCalledExpressionAndLeftBracket: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionAndExclamationMark(value) + self = withUnexpectedBetweenCalledExpressionAndLeftBracket(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndExclamationMark` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndExclamationMark` to replace the node's - /// current `unexpectedBetweenExpressionAndExclamationMark`, if present. - public func withUnexpectedBetweenExpressionAndExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> ForcedValueExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenCalledExpressionAndLeftBracket` replaced. + /// - param newChild: The new `unexpectedBetweenCalledExpressionAndLeftBracket` to replace the node's + /// current `unexpectedBetweenCalledExpressionAndLeftBracket`, if present. + public func withUnexpectedBetweenCalledExpressionAndLeftBracket(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ForcedValueExprSyntax(newData) + return SubscriptExprSyntax(newData) } - public var exclamationMark: TokenSyntax { + public var leftBracket: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withExclamationMark(value) + self = withLeftBracket(value) } } - /// Returns a copy of the receiver with its `exclamationMark` replaced. - /// - param newChild: The new `exclamationMark` to replace the node's - /// current `exclamationMark`, if present. - public func withExclamationMark(_ newChild: TokenSyntax?) -> ForcedValueExprSyntax { + /// Returns a copy of the receiver with its `leftBracket` replaced. + /// - param newChild: The new `leftBracket` to replace the node's + /// current `leftBracket`, if present. + public func withLeftBracket(_ newChild: TokenSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.exclamationMark, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftSquareBracket, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ForcedValueExprSyntax(newData) + return SubscriptExprSyntax(newData) } - public var unexpectedAfterExclamationMark: UnexpectedNodesSyntax? { + public var unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterExclamationMark(value) + self = withUnexpectedBetweenLeftBracketAndArgumentList(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterExclamationMark` replaced. - /// - param newChild: The new `unexpectedAfterExclamationMark` to replace the node's - /// current `unexpectedAfterExclamationMark`, if present. - public func withUnexpectedAfterExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> ForcedValueExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenLeftBracketAndArgumentList` replaced. + /// - param newChild: The new `unexpectedBetweenLeftBracketAndArgumentList` to replace the node's + /// current `unexpectedBetweenLeftBracketAndArgumentList`, if present. + public func withUnexpectedBetweenLeftBracketAndArgumentList(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ForcedValueExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndExclamationMark, - \Self.exclamationMark, - \Self.unexpectedAfterExclamationMark, - ]) + return SubscriptExprSyntax(newData) } - public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { - switch index.data?.indexInParent { - case 0: - return nil - case 1: - return nil - case 2: - return nil - case 3: - return nil - case 4: - return nil - default: - fatalError("Invalid index") + public var argumentList: TupleExprElementListSyntax { + get { + let childData = data.child(at: 5, parent: Syntax(self)) + return TupleExprElementListSyntax(childData!) + } + set(value) { + self = withArgumentList(value) } } -} -extension ForcedValueExprSyntax: 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), - "unexpectedBetweenExpressionAndExclamationMark": unexpectedBetweenExpressionAndExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "exclamationMark": Syntax(exclamationMark).asProtocol(SyntaxProtocol.self), - "unexpectedAfterExclamationMark": unexpectedAfterExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) + /// 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) -> SubscriptExprSyntax { + 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.tupleExprElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return SubscriptExprSyntax(newData) } -} - -// MARK: - PostfixUnaryExprSyntax - -public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - public init?(_ node: S) { - guard node.raw.kind == .postfixUnaryExpr else { return nil } - self._syntaxNode = node._syntaxNode + /// Returns a copy of the receiver with its `argumentList` replaced. + /// - param newChild: The new `argumentList` to replace the node's + /// current `argumentList`, if present. + public func withArgumentList(_ newChild: TupleExprElementListSyntax?) -> SubscriptExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return SubscriptExprSyntax(newData) } - /// Creates a `PostfixUnaryExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .postfixUnaryExpr) - self._syntaxNode = Syntax(data) + public var unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenArgumentListAndRightBracket(value) + } } - public init( - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: ExprSyntax, - _ unexpectedBetweenExpressionAndOperatorToken: UnexpectedNodesSyntax? = nil, - operatorToken: TokenSyntax, - _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndOperatorToken?.raw, - operatorToken.raw, - unexpectedAfterOperatorToken?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.postfixUnaryExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) + /// Returns a copy of the receiver with its `unexpectedBetweenArgumentListAndRightBracket` replaced. + /// - param newChild: The new `unexpectedBetweenArgumentListAndRightBracket` to replace the node's + /// current `unexpectedBetweenArgumentListAndRightBracket`, if present. + public func withUnexpectedBetweenArgumentListAndRightBracket(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return SubscriptExprSyntax(newData) + } + + public var rightBracket: TokenSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withRightBracket(value) } - self.init(data) } - public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { + /// Returns a copy of the receiver with its `rightBracket` replaced. + /// - param newChild: The new `rightBracket` to replace the node's + /// current `rightBracket`, if present. + public func withRightBracket(_ newChild: TokenSyntax?) -> SubscriptExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightSquareBracket, arena: arena) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return SubscriptExprSyntax(newData) + } + + public var unexpectedBetweenRightBracketAndTrailingClosure: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 0, parent: Syntax(self)) + let childData = data.child(at: 8, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeExpression(value) + self = withUnexpectedBetweenRightBracketAndTrailingClosure(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. - /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's - /// current `unexpectedBeforeExpression`, if present. - public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> PostfixUnaryExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenRightBracketAndTrailingClosure` replaced. + /// - param newChild: The new `unexpectedBetweenRightBracketAndTrailingClosure` to replace the node's + /// current `unexpectedBetweenRightBracketAndTrailingClosure`, if present. + public func withUnexpectedBetweenRightBracketAndTrailingClosure(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return PostfixUnaryExprSyntax(newData) + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return SubscriptExprSyntax(newData) } - public var expression: ExprSyntax { + public var trailingClosure: ClosureExprSyntax? { get { - let childData = data.child(at: 1, parent: Syntax(self)) - return ExprSyntax(childData!) + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return ClosureExprSyntax(childData!) } set(value) { - self = withExpression(value) + self = withTrailingClosure(value) } } - /// Returns a copy of the receiver with its `expression` replaced. - /// - param newChild: The new `expression` to replace the node's - /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax?) -> PostfixUnaryExprSyntax { + /// Returns a copy of the receiver with its `trailingClosure` replaced. + /// - param newChild: The new `trailingClosure` to replace the node's + /// current `trailingClosure`, if present. + public func withTrailingClosure(_ newChild: ClosureExprSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return PostfixUnaryExprSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return SubscriptExprSyntax(newData) } - public var unexpectedBetweenExpressionAndOperatorToken: UnexpectedNodesSyntax? { + public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 2, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionAndOperatorToken(value) + self = withUnexpectedBetweenTrailingClosureAndAdditionalTrailingClosures(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndOperatorToken` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndOperatorToken` to replace the node's - /// current `unexpectedBetweenExpressionAndOperatorToken`, if present. - public func withUnexpectedBetweenExpressionAndOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> PostfixUnaryExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures` replaced. + /// - param newChild: The new `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures` to replace the node's + /// current `unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures`, if present. + public func withUnexpectedBetweenTrailingClosureAndAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return PostfixUnaryExprSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return SubscriptExprSyntax(newData) } - public var operatorToken: TokenSyntax { + public var additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? { get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 11, parent: Syntax(self)) + if childData == nil { return nil } + return MultipleTrailingClosureElementListSyntax(childData!) } set(value) { - self = withOperatorToken(value) + self = withAdditionalTrailingClosures(value) } } - /// Returns a copy of the receiver with its `operatorToken` replaced. - /// - param newChild: The new `operatorToken` to replace the node's - /// current `operatorToken`, if present. - public func withOperatorToken(_ newChild: TokenSyntax?) -> PostfixUnaryExprSyntax { + /// Adds the provided `AdditionalTrailingClosure` to the node's `additionalTrailingClosures` + /// collection. + /// - param element: The new `AdditionalTrailingClosure` to add to the node's + /// `additionalTrailingClosures` collection. + /// - returns: A copy of the receiver with the provided `AdditionalTrailingClosure` + /// appended to its `additionalTrailingClosures` collection. + public func addAdditionalTrailingClosure(_ element: MultipleTrailingClosureElementSyntax) -> SubscriptExprSyntax { + var collection: RawSyntax let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.postfixOperator(""), arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return PostfixUnaryExprSyntax(newData) + if let col = raw.layoutView!.children[11] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 11, with: collection, arena: arena) + return SubscriptExprSyntax(newData) } - public var unexpectedAfterOperatorToken: UnexpectedNodesSyntax? { + /// Returns a copy of the receiver with its `additionalTrailingClosures` replaced. + /// - param newChild: The new `additionalTrailingClosures` to replace the node's + /// current `additionalTrailingClosures`, if present. + public func withAdditionalTrailingClosures(_ newChild: MultipleTrailingClosureElementListSyntax?) -> SubscriptExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 11, with: raw, arena: arena) + return SubscriptExprSyntax(newData) + } + + public var unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 4, parent: Syntax(self)) + let childData = data.child(at: 12, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterOperatorToken(value) + self = withUnexpectedAfterAdditionalTrailingClosures(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterOperatorToken` replaced. - /// - param newChild: The new `unexpectedAfterOperatorToken` to replace the node's - /// current `unexpectedAfterOperatorToken`, if present. - public func withUnexpectedAfterOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> PostfixUnaryExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterAdditionalTrailingClosures` replaced. + /// - param newChild: The new `unexpectedAfterAdditionalTrailingClosures` to replace the node's + /// current `unexpectedAfterAdditionalTrailingClosures`, if present. + public func withUnexpectedAfterAdditionalTrailingClosures(_ newChild: UnexpectedNodesSyntax?) -> SubscriptExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return PostfixUnaryExprSyntax(newData) + let newData = data.replacingChild(at: 12, with: raw, arena: arena) + return SubscriptExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeExpression, - \Self.expression, - \Self.unexpectedBetweenExpressionAndOperatorToken, - \Self.operatorToken, - \Self.unexpectedAfterOperatorToken, + \Self.unexpectedBeforeCalledExpression, + \Self.calledExpression, + \Self.unexpectedBetweenCalledExpressionAndLeftBracket, + \Self.leftBracket, + \Self.unexpectedBetweenLeftBracketAndArgumentList, + \Self.argumentList, + \Self.unexpectedBetweenArgumentListAndRightBracket, + \Self.rightBracket, + \Self.unexpectedBetweenRightBracketAndTrailingClosure, + \Self.trailingClosure, + \Self.unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, + \Self.additionalTrailingClosures, + \Self.unexpectedAfterAdditionalTrailingClosures, ]) } @@ -8480,65 +6997,89 @@ public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 0: return nil case 1: - return nil + return "called expression" case 2: return nil case 3: return nil case 4: return nil + case 5: + return "arguments" + case 6: + return nil + case 7: + return nil + case 8: + return nil + case 9: + return "trailing closure" + case 10: + return nil + case 11: + return "trailing closures" + case 12: + return nil default: fatalError("Invalid index") } } } -extension PostfixUnaryExprSyntax: CustomReflectable { +extension SubscriptExprSyntax: 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), - "unexpectedBetweenExpressionAndOperatorToken": unexpectedBetweenExpressionAndOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "operatorToken": Syntax(operatorToken).asProtocol(SyntaxProtocol.self), - "unexpectedAfterOperatorToken": unexpectedAfterOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeCalledExpression": unexpectedBeforeCalledExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "calledExpression": Syntax(calledExpression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCalledExpressionAndLeftBracket": unexpectedBetweenCalledExpressionAndLeftBracket.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), + "unexpectedBetweenRightBracketAndTrailingClosure": unexpectedBetweenRightBracketAndTrailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "trailingClosure": trailingClosure.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures": unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "additionalTrailingClosures": additionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterAdditionalTrailingClosures": unexpectedAfterAdditionalTrailingClosures.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - SpecializeExprSyntax +// MARK: - OptionalChainingExprSyntax -public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .specializeExpr else { return nil } + guard node.raw.kind == .optionalChainingExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `SpecializeExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `OptionalChainingExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .specializeExpr) + assert(data.raw.kind == .optionalChainingExpr) self._syntaxNode = Syntax(data) } public init( _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, expression: ExprSyntax, - _ unexpectedBetweenExpressionAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, - genericArgumentClause: GenericArgumentClauseSyntax, - _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil + _ unexpectedBetweenExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, + questionMark: TokenSyntax, + _ unexpectedAfterQuestionMark: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, - unexpectedBetweenExpressionAndGenericArgumentClause?.raw, - genericArgumentClause.raw, - unexpectedAfterGenericArgumentClause?.raw, + unexpectedBetweenExpressionAndQuestionMark?.raw, + questionMark.raw, + unexpectedAfterQuestionMark?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.specializeExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.optionalChainingExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } @@ -8559,11 +7100,11 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's /// current `unexpectedBeforeExpression`, if present. - public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> SpecializeExprSyntax { + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> OptionalChainingExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return SpecializeExprSyntax(newData) + return OptionalChainingExprSyntax(newData) } public var expression: ExprSyntax { @@ -8579,82 +7120,82 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Returns a copy of the receiver with its `expression` replaced. /// - param newChild: The new `expression` to replace the node's /// current `expression`, if present. - public func withExpression(_ newChild: ExprSyntax?) -> SpecializeExprSyntax { + public func withExpression(_ newChild: ExprSyntax?) -> OptionalChainingExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return SpecializeExprSyntax(newData) + return OptionalChainingExprSyntax(newData) } - public var unexpectedBetweenExpressionAndGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndQuestionMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenExpressionAndGenericArgumentClause(value) + self = withUnexpectedBetweenExpressionAndQuestionMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndGenericArgumentClause` replaced. - /// - param newChild: The new `unexpectedBetweenExpressionAndGenericArgumentClause` to replace the node's - /// current `unexpectedBetweenExpressionAndGenericArgumentClause`, if present. - public func withUnexpectedBetweenExpressionAndGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SpecializeExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndQuestionMark` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndQuestionMark` to replace the node's + /// current `unexpectedBetweenExpressionAndQuestionMark`, if present. + public func withUnexpectedBetweenExpressionAndQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> OptionalChainingExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return SpecializeExprSyntax(newData) + return OptionalChainingExprSyntax(newData) } - public var genericArgumentClause: GenericArgumentClauseSyntax { + public var questionMark: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - return GenericArgumentClauseSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withGenericArgumentClause(value) - } - } - - /// Returns a copy of the receiver with its `genericArgumentClause` replaced. - /// - param newChild: The new `genericArgumentClause` to replace the node's - /// current `genericArgumentClause`, if present. - public func withGenericArgumentClause(_ newChild: GenericArgumentClauseSyntax?) -> SpecializeExprSyntax { + self = withQuestionMark(value) + } + } + + /// Returns a copy of the receiver with its `questionMark` replaced. + /// - param newChild: The new `questionMark` to replace the node's + /// current `questionMark`, if present. + public func withQuestionMark(_ newChild: TokenSyntax?) -> OptionalChainingExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.genericArgumentClause, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.postfixQuestionMark, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return SpecializeExprSyntax(newData) + return OptionalChainingExprSyntax(newData) } - public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { + public var unexpectedAfterQuestionMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterGenericArgumentClause(value) + self = withUnexpectedAfterQuestionMark(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterGenericArgumentClause` replaced. - /// - param newChild: The new `unexpectedAfterGenericArgumentClause` to replace the node's - /// current `unexpectedAfterGenericArgumentClause`, if present. - public func withUnexpectedAfterGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SpecializeExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterQuestionMark` replaced. + /// - param newChild: The new `unexpectedAfterQuestionMark` to replace the node's + /// current `unexpectedAfterQuestionMark`, if present. + public func withUnexpectedAfterQuestionMark(_ newChild: UnexpectedNodesSyntax?) -> OptionalChainingExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return SpecializeExprSyntax(newData) + return OptionalChainingExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeExpression, \Self.expression, - \Self.unexpectedBetweenExpressionAndGenericArgumentClause, - \Self.genericArgumentClause, - \Self.unexpectedAfterGenericArgumentClause, + \Self.unexpectedBetweenExpressionAndQuestionMark, + \Self.questionMark, + \Self.unexpectedAfterQuestionMark, ]) } @@ -8676,330 +7217,351 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension SpecializeExprSyntax: CustomReflectable { +extension OptionalChainingExprSyntax: 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), - "unexpectedBetweenExpressionAndGenericArgumentClause": unexpectedBetweenExpressionAndGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "genericArgumentClause": Syntax(genericArgumentClause).asProtocol(SyntaxProtocol.self), - "unexpectedAfterGenericArgumentClause": unexpectedAfterGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenExpressionAndQuestionMark": unexpectedBetweenExpressionAndQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "questionMark": Syntax(questionMark).asProtocol(SyntaxProtocol.self), + "unexpectedAfterQuestionMark": unexpectedAfterQuestionMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - StringLiteralExprSyntax +// MARK: - ForcedValueExprSyntax -public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .stringLiteralExpr else { return nil } + guard node.raw.kind == .forcedValueExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `StringLiteralExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `ForcedValueExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .stringLiteralExpr) + assert(data.raw.kind == .forcedValueExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeOpenDelimiter: UnexpectedNodesSyntax? = nil, - openDelimiter: TokenSyntax?, - _ unexpectedBetweenOpenDelimiterAndOpenQuote: UnexpectedNodesSyntax? = nil, - openQuote: TokenSyntax, - _ unexpectedBetweenOpenQuoteAndSegments: UnexpectedNodesSyntax? = nil, - segments: StringLiteralSegmentsSyntax, - _ unexpectedBetweenSegmentsAndCloseQuote: UnexpectedNodesSyntax? = nil, - closeQuote: TokenSyntax, - _ unexpectedBetweenCloseQuoteAndCloseDelimiter: UnexpectedNodesSyntax? = nil, - closeDelimiter: TokenSyntax?, - _ unexpectedAfterCloseDelimiter: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: ExprSyntax, + _ unexpectedBetweenExpressionAndExclamationMark: UnexpectedNodesSyntax? = nil, + exclamationMark: TokenSyntax, + _ unexpectedAfterExclamationMark: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeOpenDelimiter?.raw, - openDelimiter?.raw, - unexpectedBetweenOpenDelimiterAndOpenQuote?.raw, - openQuote.raw, - unexpectedBetweenOpenQuoteAndSegments?.raw, - segments.raw, - unexpectedBetweenSegmentsAndCloseQuote?.raw, - closeQuote.raw, - unexpectedBetweenCloseQuoteAndCloseDelimiter?.raw, - closeDelimiter?.raw, - unexpectedAfterCloseDelimiter?.raw, + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndExclamationMark?.raw, + exclamationMark.raw, + unexpectedAfterExclamationMark?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.forcedValueExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeOpenDelimiter: UnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeOpenDelimiter(value) + self = withUnexpectedBeforeExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeOpenDelimiter` replaced. - /// - param newChild: The new `unexpectedBeforeOpenDelimiter` to replace the node's - /// current `unexpectedBeforeOpenDelimiter`, if present. - public func withUnexpectedBeforeOpenDelimiter(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. + /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's + /// current `unexpectedBeforeExpression`, if present. + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> ForcedValueExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + return ForcedValueExprSyntax(newData) } - public var openDelimiter: TokenSyntax? { + public var expression: ExprSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withOpenDelimiter(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `openDelimiter` replaced. - /// - param newChild: The new `openDelimiter` to replace the node's - /// current `openDelimiter`, if present. - public func withOpenDelimiter(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax?) -> ForcedValueExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + return ForcedValueExprSyntax(newData) } - public var unexpectedBetweenOpenDelimiterAndOpenQuote: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndExclamationMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenOpenDelimiterAndOpenQuote(value) + self = withUnexpectedBetweenExpressionAndExclamationMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenOpenDelimiterAndOpenQuote` replaced. - /// - param newChild: The new `unexpectedBetweenOpenDelimiterAndOpenQuote` to replace the node's - /// current `unexpectedBetweenOpenDelimiterAndOpenQuote`, if present. - public func withUnexpectedBetweenOpenDelimiterAndOpenQuote(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndExclamationMark` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndExclamationMark` to replace the node's + /// current `unexpectedBetweenExpressionAndExclamationMark`, if present. + public func withUnexpectedBetweenExpressionAndExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> ForcedValueExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + return ForcedValueExprSyntax(newData) } - public var openQuote: TokenSyntax { + public var exclamationMark: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withOpenQuote(value) + self = withExclamationMark(value) } } - /// Returns a copy of the receiver with its `openQuote` replaced. - /// - param newChild: The new `openQuote` to replace the node's - /// current `openQuote`, if present. - public func withOpenQuote(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `exclamationMark` replaced. + /// - param newChild: The new `exclamationMark` to replace the node's + /// current `exclamationMark`, if present. + public func withExclamationMark(_ newChild: TokenSyntax?) -> ForcedValueExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.stringQuote, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.exclamationMark, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + return ForcedValueExprSyntax(newData) } - public var unexpectedBetweenOpenQuoteAndSegments: UnexpectedNodesSyntax? { + public var unexpectedAfterExclamationMark: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenOpenQuoteAndSegments(value) + self = withUnexpectedAfterExclamationMark(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenOpenQuoteAndSegments` replaced. - /// - param newChild: The new `unexpectedBetweenOpenQuoteAndSegments` to replace the node's - /// current `unexpectedBetweenOpenQuoteAndSegments`, if present. - public func withUnexpectedBetweenOpenQuoteAndSegments(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterExclamationMark` replaced. + /// - param newChild: The new `unexpectedAfterExclamationMark` to replace the node's + /// current `unexpectedAfterExclamationMark`, if present. + public func withUnexpectedAfterExclamationMark(_ newChild: UnexpectedNodesSyntax?) -> ForcedValueExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + return ForcedValueExprSyntax(newData) } - public var segments: StringLiteralSegmentsSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return StringLiteralSegmentsSyntax(childData!) - } - set(value) { - self = withSegments(value) - } + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndExclamationMark, + \Self.exclamationMark, + \Self.unexpectedAfterExclamationMark, + ]) } - /// Adds the provided `Segment` to the node's `segments` - /// collection. - /// - param element: The new `Segment` to add to the node's - /// `segments` collection. - /// - returns: A copy of the receiver with the provided `Segment` - /// appended to its `segments` collection. - public func addSegment(_ element: Syntax) -> StringLiteralExprSyntax { - 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.stringLiteralSegments, - from: [element.raw], arena: arena) + public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? { + switch index.data?.indexInParent { + case 0: + return nil + case 1: + return nil + case 2: + return nil + case 3: + return nil + case 4: + return nil + default: + fatalError("Invalid index") } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return StringLiteralExprSyntax(newData) } +} - /// Returns a copy of the receiver with its `segments` replaced. - /// - param newChild: The new `segments` to replace the node's - /// current `segments`, if present. - public func withSegments(_ newChild: StringLiteralSegmentsSyntax?) -> StringLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.stringLiteralSegments, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) +extension ForcedValueExprSyntax: 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), + "unexpectedBetweenExpressionAndExclamationMark": unexpectedBetweenExpressionAndExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "exclamationMark": Syntax(exclamationMark).asProtocol(SyntaxProtocol.self), + "unexpectedAfterExclamationMark": unexpectedAfterExclamationMark.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + ]) + } +} + +// MARK: - PostfixUnaryExprSyntax + +public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { + public let _syntaxNode: Syntax + + public init?(_ node: S) { + guard node.raw.kind == .postfixUnaryExpr else { return nil } + self._syntaxNode = node._syntaxNode + } + + /// Creates a `PostfixUnaryExprSyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .postfixUnaryExpr) + self._syntaxNode = Syntax(data) + } + + public init( + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: ExprSyntax, + _ unexpectedBetweenExpressionAndOperatorToken: UnexpectedNodesSyntax? = nil, + operatorToken: TokenSyntax, + _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil + ) { + let layout: [RawSyntax?] = [ + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndOperatorToken?.raw, + operatorToken.raw, + unexpectedAfterOperatorToken?.raw, + ] + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.postfixUnaryExpr, + from: layout, arena: arena) + return SyntaxData.forRoot(raw) + } + self.init(data) } - public var unexpectedBetweenSegmentsAndCloseQuote: UnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenSegmentsAndCloseQuote(value) + self = withUnexpectedBeforeExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenSegmentsAndCloseQuote` replaced. - /// - param newChild: The new `unexpectedBetweenSegmentsAndCloseQuote` to replace the node's - /// current `unexpectedBetweenSegmentsAndCloseQuote`, if present. - public func withUnexpectedBetweenSegmentsAndCloseQuote(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. + /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's + /// current `unexpectedBeforeExpression`, if present. + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> PostfixUnaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + let newData = data.replacingChild(at: 0, with: raw, arena: arena) + return PostfixUnaryExprSyntax(newData) } - public var closeQuote: TokenSyntax { + public var expression: ExprSyntax { get { - let childData = data.child(at: 7, parent: Syntax(self)) - return TokenSyntax(childData!) + let childData = data.child(at: 1, parent: Syntax(self)) + return ExprSyntax(childData!) } set(value) { - self = withCloseQuote(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `closeQuote` replaced. - /// - param newChild: The new `closeQuote` to replace the node's - /// current `closeQuote`, if present. - public func withCloseQuote(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax?) -> PostfixUnaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.stringQuote, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) + let newData = data.replacingChild(at: 1, with: raw, arena: arena) + return PostfixUnaryExprSyntax(newData) } - public var unexpectedBetweenCloseQuoteAndCloseDelimiter: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndOperatorToken: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 8, parent: Syntax(self)) + let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenCloseQuoteAndCloseDelimiter(value) + self = withUnexpectedBetweenExpressionAndOperatorToken(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenCloseQuoteAndCloseDelimiter` replaced. - /// - param newChild: The new `unexpectedBetweenCloseQuoteAndCloseDelimiter` to replace the node's - /// current `unexpectedBetweenCloseQuoteAndCloseDelimiter`, if present. - public func withUnexpectedBetweenCloseQuoteAndCloseDelimiter(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndOperatorToken` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndOperatorToken` to replace the node's + /// current `unexpectedBetweenExpressionAndOperatorToken`, if present. + public func withUnexpectedBetweenExpressionAndOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> PostfixUnaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return PostfixUnaryExprSyntax(newData) } - public var closeDelimiter: TokenSyntax? { + public var operatorToken: TokenSyntax { get { - let childData = data.child(at: 9, parent: Syntax(self)) - if childData == nil { return nil } + let childData = data.child(at: 3, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withCloseDelimiter(value) + self = withOperatorToken(value) } } - /// Returns a copy of the receiver with its `closeDelimiter` replaced. - /// - param newChild: The new `closeDelimiter` to replace the node's - /// current `closeDelimiter`, if present. - public func withCloseDelimiter(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `operatorToken` replaced. + /// - param newChild: The new `operatorToken` to replace the node's + /// current `operatorToken`, if present. + public func withOperatorToken(_ newChild: TokenSyntax?) -> PostfixUnaryExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.postfixOperator(""), arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return PostfixUnaryExprSyntax(newData) } - public var unexpectedAfterCloseDelimiter: UnexpectedNodesSyntax? { + public var unexpectedAfterOperatorToken: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 10, parent: Syntax(self)) + let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterCloseDelimiter(value) + self = withUnexpectedAfterOperatorToken(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterCloseDelimiter` replaced. - /// - param newChild: The new `unexpectedAfterCloseDelimiter` to replace the node's - /// current `unexpectedAfterCloseDelimiter`, if present. - public func withUnexpectedAfterCloseDelimiter(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterOperatorToken` replaced. + /// - param newChild: The new `unexpectedAfterOperatorToken` to replace the node's + /// current `unexpectedAfterOperatorToken`, if present. + public func withUnexpectedAfterOperatorToken(_ newChild: UnexpectedNodesSyntax?) -> PostfixUnaryExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return StringLiteralExprSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return PostfixUnaryExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeOpenDelimiter, - \Self.openDelimiter, - \Self.unexpectedBetweenOpenDelimiterAndOpenQuote, - \Self.openQuote, - \Self.unexpectedBetweenOpenQuoteAndSegments, - \Self.segments, - \Self.unexpectedBetweenSegmentsAndCloseQuote, - \Self.closeQuote, - \Self.unexpectedBetweenCloseQuoteAndCloseDelimiter, - \Self.closeDelimiter, - \Self.unexpectedAfterCloseDelimiter, + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndOperatorToken, + \Self.operatorToken, + \Self.unexpectedAfterOperatorToken, ]) } @@ -9015,145 +7577,174 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 4: return nil - case 5: - return nil - case 6: - return nil - case 7: - return nil - case 8: - return nil - case 9: - return nil - case 10: - return nil default: fatalError("Invalid index") } } } -extension StringLiteralExprSyntax: CustomReflectable { +extension PostfixUnaryExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeOpenDelimiter": unexpectedBeforeOpenDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "openDelimiter": openDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenOpenDelimiterAndOpenQuote": unexpectedBetweenOpenDelimiterAndOpenQuote.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "openQuote": Syntax(openQuote).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenOpenQuoteAndSegments": unexpectedBetweenOpenQuoteAndSegments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "segments": Syntax(segments).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenSegmentsAndCloseQuote": unexpectedBetweenSegmentsAndCloseQuote.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "closeQuote": Syntax(closeQuote).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenCloseQuoteAndCloseDelimiter": unexpectedBetweenCloseQuoteAndCloseDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "closeDelimiter": closeDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterCloseDelimiter": unexpectedAfterCloseDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeExpression": unexpectedBeforeExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndOperatorToken": unexpectedBetweenExpressionAndOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "operatorToken": Syntax(operatorToken).asProtocol(SyntaxProtocol.self), + "unexpectedAfterOperatorToken": unexpectedAfterOperatorToken.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - RegexLiteralExprSyntax +// MARK: - SpecializeExprSyntax -public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .regexLiteralExpr else { return nil } + guard node.raw.kind == .specializeExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `RegexLiteralExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `SpecializeExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .regexLiteralExpr) + assert(data.raw.kind == .specializeExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeRegex: UnexpectedNodesSyntax? = nil, - regex: TokenSyntax, - _ unexpectedAfterRegex: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: ExprSyntax, + _ unexpectedBetweenExpressionAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax, + _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeRegex?.raw, - regex.raw, - unexpectedAfterRegex?.raw, + unexpectedBeforeExpression?.raw, + expression.raw, + unexpectedBetweenExpressionAndGenericArgumentClause?.raw, + genericArgumentClause.raw, + unexpectedAfterGenericArgumentClause?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.regexLiteralExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.specializeExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeRegex: UnexpectedNodesSyntax? { + public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeRegex(value) + self = withUnexpectedBeforeExpression(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeRegex` replaced. - /// - param newChild: The new `unexpectedBeforeRegex` to replace the node's - /// current `unexpectedBeforeRegex`, if present. - public func withUnexpectedBeforeRegex(_ newChild: UnexpectedNodesSyntax?) -> RegexLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeExpression` replaced. + /// - param newChild: The new `unexpectedBeforeExpression` to replace the node's + /// current `unexpectedBeforeExpression`, if present. + public func withUnexpectedBeforeExpression(_ newChild: UnexpectedNodesSyntax?) -> SpecializeExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return RegexLiteralExprSyntax(newData) + return SpecializeExprSyntax(newData) } - public var regex: TokenSyntax { + public var expression: ExprSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) + return ExprSyntax(childData!) } set(value) { - self = withRegex(value) + self = withExpression(value) } } - /// Returns a copy of the receiver with its `regex` replaced. - /// - param newChild: The new `regex` to replace the node's - /// current `regex`, if present. - public func withRegex(_ newChild: TokenSyntax?) -> RegexLiteralExprSyntax { + /// Returns a copy of the receiver with its `expression` replaced. + /// - param newChild: The new `expression` to replace the node's + /// current `expression`, if present. + public func withExpression(_ newChild: ExprSyntax?) -> SpecializeExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.regexLiteral(""), arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return RegexLiteralExprSyntax(newData) + return SpecializeExprSyntax(newData) } - public var unexpectedAfterRegex: UnexpectedNodesSyntax? { + public var unexpectedBetweenExpressionAndGenericArgumentClause: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRegex(value) + self = withUnexpectedBetweenExpressionAndGenericArgumentClause(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenExpressionAndGenericArgumentClause` replaced. + /// - param newChild: The new `unexpectedBetweenExpressionAndGenericArgumentClause` to replace the node's + /// current `unexpectedBetweenExpressionAndGenericArgumentClause`, if present. + public func withUnexpectedBetweenExpressionAndGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SpecializeExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 2, with: raw, arena: arena) + return SpecializeExprSyntax(newData) + } + + public var genericArgumentClause: GenericArgumentClauseSyntax { + get { + let childData = data.child(at: 3, parent: Syntax(self)) + return GenericArgumentClauseSyntax(childData!) + } + set(value) { + self = withGenericArgumentClause(value) + } + } + + /// Returns a copy of the receiver with its `genericArgumentClause` replaced. + /// - param newChild: The new `genericArgumentClause` to replace the node's + /// current `genericArgumentClause`, if present. + public func withGenericArgumentClause(_ newChild: GenericArgumentClauseSyntax?) -> SpecializeExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.genericArgumentClause, arena: arena) + let newData = data.replacingChild(at: 3, with: raw, arena: arena) + return SpecializeExprSyntax(newData) + } + + public var unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 4, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedAfterGenericArgumentClause(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRegex` replaced. - /// - param newChild: The new `unexpectedAfterRegex` to replace the node's - /// current `unexpectedAfterRegex`, if present. - public func withUnexpectedAfterRegex(_ newChild: UnexpectedNodesSyntax?) -> RegexLiteralExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterGenericArgumentClause` replaced. + /// - param newChild: The new `unexpectedAfterGenericArgumentClause` to replace the node's + /// current `unexpectedAfterGenericArgumentClause`, if present. + public func withUnexpectedAfterGenericArgumentClause(_ newChild: UnexpectedNodesSyntax?) -> SpecializeExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return RegexLiteralExprSyntax(newData) + let newData = data.replacingChild(at: 4, with: raw, arena: arena) + return SpecializeExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeRegex, - \Self.regex, - \Self.unexpectedAfterRegex, + \Self.unexpectedBeforeExpression, + \Self.expression, + \Self.unexpectedBetweenExpressionAndGenericArgumentClause, + \Self.genericArgumentClause, + \Self.unexpectedAfterGenericArgumentClause, ]) } @@ -9165,239 +7756,340 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 2: return nil + case 3: + return nil + case 4: + return nil default: fatalError("Invalid index") } } } -extension RegexLiteralExprSyntax: CustomReflectable { +extension SpecializeExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeRegex": unexpectedBeforeRegex.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "regex": Syntax(regex).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRegex": unexpectedAfterRegex.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeExpression": unexpectedBeforeExpression.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "expression": Syntax(expression).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenExpressionAndGenericArgumentClause": unexpectedBetweenExpressionAndGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "genericArgumentClause": Syntax(genericArgumentClause).asProtocol(SyntaxProtocol.self), + "unexpectedAfterGenericArgumentClause": unexpectedAfterGenericArgumentClause.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - KeyPathExprSyntax +// MARK: - StringLiteralExprSyntax -public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathExpr else { return nil } + guard node.raw.kind == .stringLiteralExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `KeyPathExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `StringLiteralExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .keyPathExpr) + assert(data.raw.kind == .stringLiteralExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, - backslash: TokenSyntax, - _ unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? = nil, - root: TypeSyntax?, - _ unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? = nil, - components: KeyPathComponentListSyntax, - _ unexpectedAfterComponents: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeOpenDelimiter: UnexpectedNodesSyntax? = nil, + openDelimiter: TokenSyntax?, + _ unexpectedBetweenOpenDelimiterAndOpenQuote: UnexpectedNodesSyntax? = nil, + openQuote: TokenSyntax, + _ unexpectedBetweenOpenQuoteAndSegments: UnexpectedNodesSyntax? = nil, + segments: StringLiteralSegmentsSyntax, + _ unexpectedBetweenSegmentsAndCloseQuote: UnexpectedNodesSyntax? = nil, + closeQuote: TokenSyntax, + _ unexpectedBetweenCloseQuoteAndCloseDelimiter: UnexpectedNodesSyntax? = nil, + closeDelimiter: TokenSyntax?, + _ unexpectedAfterCloseDelimiter: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeBackslash?.raw, - backslash.raw, - unexpectedBetweenBackslashAndRoot?.raw, - root?.raw, - unexpectedBetweenRootAndComponents?.raw, - components.raw, - unexpectedAfterComponents?.raw, + unexpectedBeforeOpenDelimiter?.raw, + openDelimiter?.raw, + unexpectedBetweenOpenDelimiterAndOpenQuote?.raw, + openQuote.raw, + unexpectedBetweenOpenQuoteAndSegments?.raw, + segments.raw, + unexpectedBetweenSegmentsAndCloseQuote?.raw, + closeQuote.raw, + unexpectedBetweenCloseQuoteAndCloseDelimiter?.raw, + closeDelimiter?.raw, + unexpectedAfterCloseDelimiter?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.keyPathExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { + public var unexpectedBeforeOpenDelimiter: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeBackslash(value) + self = withUnexpectedBeforeOpenDelimiter(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeBackslash` replaced. - /// - param newChild: The new `unexpectedBeforeBackslash` to replace the node's - /// current `unexpectedBeforeBackslash`, if present. - public func withUnexpectedBeforeBackslash(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeOpenDelimiter` replaced. + /// - param newChild: The new `unexpectedBeforeOpenDelimiter` to replace the node's + /// current `unexpectedBeforeOpenDelimiter`, if present. + public func withUnexpectedBeforeOpenDelimiter(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return KeyPathExprSyntax(newData) + return StringLiteralExprSyntax(newData) } - public var backslash: TokenSyntax { + public var openDelimiter: TokenSyntax? { get { let childData = data.child(at: 1, parent: Syntax(self)) + if childData == nil { return nil } return TokenSyntax(childData!) } set(value) { - self = withBackslash(value) + self = withOpenDelimiter(value) } } - /// Returns a copy of the receiver with its `backslash` replaced. - /// - param newChild: The new `backslash` to replace the node's - /// current `backslash`, if present. - public func withBackslash(_ newChild: TokenSyntax?) -> KeyPathExprSyntax { + /// Returns a copy of the receiver with its `openDelimiter` replaced. + /// - param newChild: The new `openDelimiter` to replace the node's + /// current `openDelimiter`, if present. + public func withOpenDelimiter(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.backslash, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return KeyPathExprSyntax(newData) + return StringLiteralExprSyntax(newData) } - public var unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? { + public var unexpectedBetweenOpenDelimiterAndOpenQuote: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenBackslashAndRoot(value) + self = withUnexpectedBetweenOpenDelimiterAndOpenQuote(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenBackslashAndRoot` replaced. - /// - param newChild: The new `unexpectedBetweenBackslashAndRoot` to replace the node's - /// current `unexpectedBetweenBackslashAndRoot`, if present. - public func withUnexpectedBetweenBackslashAndRoot(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenOpenDelimiterAndOpenQuote` replaced. + /// - param newChild: The new `unexpectedBetweenOpenDelimiterAndOpenQuote` to replace the node's + /// current `unexpectedBetweenOpenDelimiterAndOpenQuote`, if present. + public func withUnexpectedBetweenOpenDelimiterAndOpenQuote(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return KeyPathExprSyntax(newData) + return StringLiteralExprSyntax(newData) } - public var root: TypeSyntax? { + public var openQuote: TokenSyntax { get { let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TypeSyntax(childData!) + return TokenSyntax(childData!) } set(value) { - self = withRoot(value) + self = withOpenQuote(value) } } - /// Returns a copy of the receiver with its `root` replaced. - /// - param newChild: The new `root` to replace the node's - /// current `root`, if present. - public func withRoot(_ newChild: TypeSyntax?) -> KeyPathExprSyntax { + /// Returns a copy of the receiver with its `openQuote` replaced. + /// - param newChild: The new `openQuote` to replace the node's + /// current `openQuote`, if present. + public func withOpenQuote(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.stringQuote, arena: arena) let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return KeyPathExprSyntax(newData) + return StringLiteralExprSyntax(newData) } - public var unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? { + public var unexpectedBetweenOpenQuoteAndSegments: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenRootAndComponents(value) + self = withUnexpectedBetweenOpenQuoteAndSegments(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenRootAndComponents` replaced. - /// - param newChild: The new `unexpectedBetweenRootAndComponents` to replace the node's - /// current `unexpectedBetweenRootAndComponents`, if present. - public func withUnexpectedBetweenRootAndComponents(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenOpenQuoteAndSegments` replaced. + /// - param newChild: The new `unexpectedBetweenOpenQuoteAndSegments` to replace the node's + /// current `unexpectedBetweenOpenQuoteAndSegments`, if present. + public func withUnexpectedBetweenOpenQuoteAndSegments(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return KeyPathExprSyntax(newData) + return StringLiteralExprSyntax(newData) } - public var components: KeyPathComponentListSyntax { + public var segments: StringLiteralSegmentsSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - return KeyPathComponentListSyntax(childData!) + return StringLiteralSegmentsSyntax(childData!) } set(value) { - self = withComponents(value) + self = withSegments(value) } } - /// Adds the provided `KeyPathComponent` to the node's `components` + /// Adds the provided `Segment` to the node's `segments` /// collection. - /// - param element: The new `KeyPathComponent` to add to the node's - /// `components` collection. - /// - returns: A copy of the receiver with the provided `KeyPathComponent` - /// appended to its `components` collection. - public func addKeyPathComponent(_ element: KeyPathComponentSyntax) -> KeyPathExprSyntax { + /// - param element: The new `Segment` to add to the node's + /// `segments` collection. + /// - returns: A copy of the receiver with the provided `Segment` + /// appended to its `segments` collection. + public func addSegment(_ element: Syntax) -> StringLiteralExprSyntax { 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.keyPathComponentList, - from: [element.raw], arena: arena) + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralSegments, + from: [element.raw], arena: arena) + } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return StringLiteralExprSyntax(newData) + } + + /// Returns a copy of the receiver with its `segments` replaced. + /// - param newChild: The new `segments` to replace the node's + /// current `segments`, if present. + public func withSegments(_ newChild: StringLiteralSegmentsSyntax?) -> StringLiteralExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.stringLiteralSegments, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return StringLiteralExprSyntax(newData) + } + + public var unexpectedBetweenSegmentsAndCloseQuote: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 6, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenSegmentsAndCloseQuote(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenSegmentsAndCloseQuote` replaced. + /// - param newChild: The new `unexpectedBetweenSegmentsAndCloseQuote` to replace the node's + /// current `unexpectedBetweenSegmentsAndCloseQuote`, if present. + public func withUnexpectedBetweenSegmentsAndCloseQuote(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return StringLiteralExprSyntax(newData) + } + + public var closeQuote: TokenSyntax { + get { + let childData = data.child(at: 7, parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withCloseQuote(value) + } + } + + /// Returns a copy of the receiver with its `closeQuote` replaced. + /// - param newChild: The new `closeQuote` to replace the node's + /// current `closeQuote`, if present. + public func withCloseQuote(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.stringQuote, arena: arena) + let newData = data.replacingChild(at: 7, with: raw, arena: arena) + return StringLiteralExprSyntax(newData) + } + + public var unexpectedBetweenCloseQuoteAndCloseDelimiter: UnexpectedNodesSyntax? { + get { + let childData = data.child(at: 8, parent: Syntax(self)) + if childData == nil { return nil } + return UnexpectedNodesSyntax(childData!) + } + set(value) { + self = withUnexpectedBetweenCloseQuoteAndCloseDelimiter(value) + } + } + + /// Returns a copy of the receiver with its `unexpectedBetweenCloseQuoteAndCloseDelimiter` replaced. + /// - param newChild: The new `unexpectedBetweenCloseQuoteAndCloseDelimiter` to replace the node's + /// current `unexpectedBetweenCloseQuoteAndCloseDelimiter`, if present. + public func withUnexpectedBetweenCloseQuoteAndCloseDelimiter(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { + let arena = SyntaxArena() + let raw = newChild?.raw + let newData = data.replacingChild(at: 8, with: raw, arena: arena) + return StringLiteralExprSyntax(newData) + } + + public var closeDelimiter: TokenSyntax? { + get { + let childData = data.child(at: 9, parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withCloseDelimiter(value) } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return KeyPathExprSyntax(newData) } - /// Returns a copy of the receiver with its `components` replaced. - /// - param newChild: The new `components` to replace the node's - /// current `components`, if present. - public func withComponents(_ newChild: KeyPathComponentListSyntax?) -> KeyPathExprSyntax { + /// Returns a copy of the receiver with its `closeDelimiter` replaced. + /// - param newChild: The new `closeDelimiter` to replace the node's + /// current `closeDelimiter`, if present. + public func withCloseDelimiter(_ newChild: TokenSyntax?) -> StringLiteralExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.keyPathComponentList, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return KeyPathExprSyntax(newData) + let raw = newChild?.raw + let newData = data.replacingChild(at: 9, with: raw, arena: arena) + return StringLiteralExprSyntax(newData) } - public var unexpectedAfterComponents: UnexpectedNodesSyntax? { + public var unexpectedAfterCloseDelimiter: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 6, parent: Syntax(self)) + let childData = data.child(at: 10, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterComponents(value) + self = withUnexpectedAfterCloseDelimiter(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterComponents` replaced. - /// - param newChild: The new `unexpectedAfterComponents` to replace the node's - /// current `unexpectedAfterComponents`, if present. - public func withUnexpectedAfterComponents(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterCloseDelimiter` replaced. + /// - param newChild: The new `unexpectedAfterCloseDelimiter` to replace the node's + /// current `unexpectedAfterCloseDelimiter`, if present. + public func withUnexpectedAfterCloseDelimiter(_ newChild: UnexpectedNodesSyntax?) -> StringLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return KeyPathExprSyntax(newData) + let newData = data.replacingChild(at: 10, with: raw, arena: arena) + return StringLiteralExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeBackslash, - \Self.backslash, - \Self.unexpectedBetweenBackslashAndRoot, - \Self.root, - \Self.unexpectedBetweenRootAndComponents, - \Self.components, - \Self.unexpectedAfterComponents, + \Self.unexpectedBeforeOpenDelimiter, + \Self.openDelimiter, + \Self.unexpectedBetweenOpenDelimiterAndOpenQuote, + \Self.openQuote, + \Self.unexpectedBetweenOpenQuoteAndSegments, + \Self.segments, + \Self.unexpectedBetweenSegmentsAndCloseQuote, + \Self.closeQuote, + \Self.unexpectedBetweenCloseQuoteAndCloseDelimiter, + \Self.closeDelimiter, + \Self.unexpectedAfterCloseDelimiter, ]) } @@ -9410,296 +8102,148 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return "root" + 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 KeyPathExprSyntax: CustomReflectable { +extension StringLiteralExprSyntax: 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), - "unexpectedBetweenBackslashAndRoot": unexpectedBetweenBackslashAndRoot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "root": root.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenRootAndComponents": unexpectedBetweenRootAndComponents.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "components": Syntax(components).asProtocol(SyntaxProtocol.self), - "unexpectedAfterComponents": unexpectedAfterComponents.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBeforeOpenDelimiter": unexpectedBeforeOpenDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "openDelimiter": openDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenOpenDelimiterAndOpenQuote": unexpectedBetweenOpenDelimiterAndOpenQuote.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "openQuote": Syntax(openQuote).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenOpenQuoteAndSegments": unexpectedBetweenOpenQuoteAndSegments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "segments": Syntax(segments).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenSegmentsAndCloseQuote": unexpectedBetweenSegmentsAndCloseQuote.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "closeQuote": Syntax(closeQuote).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenCloseQuoteAndCloseDelimiter": unexpectedBetweenCloseQuoteAndCloseDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "closeDelimiter": closeDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedAfterCloseDelimiter": unexpectedAfterCloseDelimiter.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ObjcKeyPathExprSyntax +// MARK: - RegexLiteralExprSyntax -public struct ObjcKeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .objcKeyPathExpr else { return nil } + guard node.raw.kind == .regexLiteralExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ObjcKeyPathExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `RegexLiteralExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .objcKeyPathExpr) + assert(data.raw.kind == .regexLiteralExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforeKeyPath: UnexpectedNodesSyntax? = nil, - keyPath: TokenSyntax, - _ unexpectedBetweenKeyPathAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax, - _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, - name: ObjcNameSyntax, - _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeRegex: UnexpectedNodesSyntax? = nil, + regex: TokenSyntax, + _ unexpectedAfterRegex: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforeKeyPath?.raw, - keyPath.raw, - unexpectedBetweenKeyPathAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeRegex?.raw, + regex.raw, + unexpectedAfterRegex?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcKeyPathExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.regexLiteralExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforeKeyPath: UnexpectedNodesSyntax? { + public var unexpectedBeforeRegex: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforeKeyPath(value) + self = withUnexpectedBeforeRegex(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforeKeyPath` replaced. - /// - param newChild: The new `unexpectedBeforeKeyPath` to replace the node's - /// current `unexpectedBeforeKeyPath`, if present. - public func withUnexpectedBeforeKeyPath(_ newChild: UnexpectedNodesSyntax?) -> ObjcKeyPathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeRegex` replaced. + /// - param newChild: The new `unexpectedBeforeRegex` to replace the node's + /// current `unexpectedBeforeRegex`, if present. + public func withUnexpectedBeforeRegex(_ newChild: UnexpectedNodesSyntax?) -> RegexLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) + return RegexLiteralExprSyntax(newData) } - public var keyPath: TokenSyntax { + public var regex: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withKeyPath(value) + self = withRegex(value) } } - /// Returns a copy of the receiver with its `keyPath` replaced. - /// - param newChild: The new `keyPath` to replace the node's - /// current `keyPath`, if present. - public func withKeyPath(_ newChild: TokenSyntax?) -> ObjcKeyPathExprSyntax { + /// Returns a copy of the receiver with its `regex` replaced. + /// - param newChild: The new `regex` to replace the node's + /// current `regex`, if present. + public func withRegex(_ newChild: TokenSyntax?) -> RegexLiteralExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundKeyPathKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.regexLiteral(""), arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) + return RegexLiteralExprSyntax(newData) } - public var unexpectedBetweenKeyPathAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedAfterRegex: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenKeyPathAndLeftParen(value) + self = withUnexpectedAfterRegex(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenKeyPathAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenKeyPathAndLeftParen` to replace the node's - /// current `unexpectedBetweenKeyPathAndLeftParen`, if present. - public func withUnexpectedBetweenKeyPathAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> ObjcKeyPathExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterRegex` replaced. + /// - param newChild: The new `unexpectedAfterRegex` to replace the node's + /// current `unexpectedAfterRegex`, if present. + public func withUnexpectedAfterRegex(_ newChild: UnexpectedNodesSyntax?) -> RegexLiteralExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) - } - - public var leftParen: TokenSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withLeftParen(value) - } - } - - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax?) -> ObjcKeyPathExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) - } - - public var unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLeftParenAndName(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndName` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndName` to replace the node's - /// current `unexpectedBetweenLeftParenAndName`, if present. - public func withUnexpectedBetweenLeftParenAndName(_ newChild: UnexpectedNodesSyntax?) -> ObjcKeyPathExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) - } - - public var name: ObjcNameSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return ObjcNameSyntax(childData!) - } - set(value) { - self = withName(value) - } - } - - /// Adds the provided `NamePiece` to the node's `name` - /// collection. - /// - param element: The new `NamePiece` to add to the node's - /// `name` collection. - /// - returns: A copy of the receiver with the provided `NamePiece` - /// appended to its `name` collection. - public func addNamePiece(_ element: ObjcNamePieceSyntax) -> ObjcKeyPathExprSyntax { - 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.objcName, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return ObjcKeyPathExprSyntax(newData) - } - - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: ObjcNameSyntax?) -> ObjcKeyPathExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.objcName, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) - } - - public var unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenNameAndRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndRightParen` to replace the node's - /// current `unexpectedBetweenNameAndRightParen`, if present. - public func withUnexpectedBetweenNameAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> ObjcKeyPathExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) - } - - public var rightParen: TokenSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withRightParen(value) - } - } - - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax?) -> ObjcKeyPathExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> ObjcKeyPathExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ObjcKeyPathExprSyntax(newData) + return RegexLiteralExprSyntax(newData) } - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeKeyPath, - \Self.keyPath, - \Self.unexpectedBetweenKeyPathAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndName, - \Self.name, - \Self.unexpectedBetweenNameAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeRegex, + \Self.regex, + \Self.unexpectedAfterRegex, ]) } @@ -9711,380 +8255,239 @@ public struct ObjcKeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { return nil case 2: return nil - case 3: - return nil - case 4: - return nil - case 5: - return "name" - case 6: - return nil - case 7: - return nil - case 8: - return nil default: fatalError("Invalid index") } } } -extension ObjcKeyPathExprSyntax: CustomReflectable { +extension RegexLiteralExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforeKeyPath": unexpectedBeforeKeyPath.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "keyPath": Syntax(keyPath).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenKeyPathAndLeftParen": unexpectedBetweenKeyPathAndLeftParen.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, + "unexpectedBeforeRegex": unexpectedBeforeRegex.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "regex": Syntax(regex).asProtocol(SyntaxProtocol.self), + "unexpectedAfterRegex": unexpectedAfterRegex.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } -// MARK: - ObjcSelectorExprSyntax +// MARK: - KeyPathExprSyntax -public struct ObjcSelectorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { +public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .objcSelectorExpr else { return nil } + guard node.raw.kind == .keyPathExpr else { return nil } self._syntaxNode = node._syntaxNode } - /// Creates a `ObjcSelectorExprSyntax` node from the given `SyntaxData`. This assumes + /// Creates a `KeyPathExprSyntax` node from the given `SyntaxData`. This assumes /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour /// is undefined. internal init(_ data: SyntaxData) { - assert(data.raw.kind == .objcSelectorExpr) + assert(data.raw.kind == .keyPathExpr) self._syntaxNode = Syntax(data) } public init( - _ unexpectedBeforePoundSelector: UnexpectedNodesSyntax? = nil, - poundSelector: TokenSyntax, - _ unexpectedBetweenPoundSelectorAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax, - _ unexpectedBetweenLeftParenAndKind: UnexpectedNodesSyntax? = nil, - kind: TokenSyntax?, - _ unexpectedBetweenKindAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax?, - _ unexpectedBetweenColonAndName: UnexpectedNodesSyntax? = nil, - name: ExprSyntax, - _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil + _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, + backslash: TokenSyntax, + _ unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? = nil, + root: TypeSyntax?, + _ unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? = nil, + components: KeyPathComponentListSyntax, + _ unexpectedAfterComponents: UnexpectedNodesSyntax? = nil ) { let layout: [RawSyntax?] = [ - unexpectedBeforePoundSelector?.raw, - poundSelector.raw, - unexpectedBetweenPoundSelectorAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndKind?.raw, - kind?.raw, - unexpectedBetweenKindAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, + unexpectedBeforeBackslash?.raw, + backslash.raw, + unexpectedBetweenBackslashAndRoot?.raw, + root?.raw, + unexpectedBetweenRootAndComponents?.raw, + components.raw, + unexpectedAfterComponents?.raw, ] let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcSelectorExpr, + let raw = RawSyntax.makeLayout(kind: SyntaxKind.keyPathExpr, from: layout, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpectedBeforePoundSelector: UnexpectedNodesSyntax? { + public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { get { let childData = data.child(at: 0, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBeforePoundSelector(value) + self = withUnexpectedBeforeBackslash(value) } } - /// Returns a copy of the receiver with its `unexpectedBeforePoundSelector` replaced. - /// - param newChild: The new `unexpectedBeforePoundSelector` to replace the node's - /// current `unexpectedBeforePoundSelector`, if present. - public func withUnexpectedBeforePoundSelector(_ newChild: UnexpectedNodesSyntax?) -> ObjcSelectorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBeforeBackslash` replaced. + /// - param newChild: The new `unexpectedBeforeBackslash` to replace the node's + /// current `unexpectedBeforeBackslash`, if present. + public func withUnexpectedBeforeBackslash(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) + return KeyPathExprSyntax(newData) } - public var poundSelector: TokenSyntax { + public var backslash: TokenSyntax { get { let childData = data.child(at: 1, parent: Syntax(self)) return TokenSyntax(childData!) } set(value) { - self = withPoundSelector(value) + self = withBackslash(value) } } - /// Returns a copy of the receiver with its `poundSelector` replaced. - /// - param newChild: The new `poundSelector` to replace the node's - /// current `poundSelector`, if present. - public func withPoundSelector(_ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax { + /// Returns a copy of the receiver with its `backslash` replaced. + /// - param newChild: The new `backslash` to replace the node's + /// current `backslash`, if present. + public func withBackslash(_ newChild: TokenSyntax?) -> KeyPathExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundSelectorKeyword, arena: arena) + let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.backslash, arena: arena) let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) + return KeyPathExprSyntax(newData) } - public var unexpectedBetweenPoundSelectorAndLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? { get { let childData = data.child(at: 2, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenPoundSelectorAndLeftParen(value) + self = withUnexpectedBetweenBackslashAndRoot(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenPoundSelectorAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenPoundSelectorAndLeftParen` to replace the node's - /// current `unexpectedBetweenPoundSelectorAndLeftParen`, if present. - public func withUnexpectedBetweenPoundSelectorAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> ObjcSelectorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenBackslashAndRoot` replaced. + /// - param newChild: The new `unexpectedBetweenBackslashAndRoot` to replace the node's + /// current `unexpectedBetweenBackslashAndRoot`, if present. + public func withUnexpectedBetweenBackslashAndRoot(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) + return KeyPathExprSyntax(newData) } - public var leftParen: TokenSyntax { + public var root: TypeSyntax? { get { let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) + if childData == nil { return nil } + return TypeSyntax(childData!) } set(value) { - self = withLeftParen(value) + self = withRoot(value) } } - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax { + /// Returns a copy of the receiver with its `root` replaced. + /// - param newChild: The new `root` to replace the node's + /// current `root`, if present. + public func withRoot(_ newChild: TypeSyntax?) -> KeyPathExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) + let raw = newChild?.raw let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) + return KeyPathExprSyntax(newData) } - public var unexpectedBetweenLeftParenAndKind: UnexpectedNodesSyntax? { + public var unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? { get { let childData = data.child(at: 4, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedBetweenLeftParenAndKind(value) + self = withUnexpectedBetweenRootAndComponents(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndKind` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndKind` to replace the node's - /// current `unexpectedBetweenLeftParenAndKind`, if present. - public func withUnexpectedBetweenLeftParenAndKind(_ newChild: UnexpectedNodesSyntax?) -> ObjcSelectorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedBetweenRootAndComponents` replaced. + /// - param newChild: The new `unexpectedBetweenRootAndComponents` to replace the node's + /// current `unexpectedBetweenRootAndComponents`, if present. + public func withUnexpectedBetweenRootAndComponents(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) + return KeyPathExprSyntax(newData) } - public var kind: TokenSyntax? { + public var components: KeyPathComponentListSyntax { get { let childData = data.child(at: 5, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withKind(value) - } - } - - /// Returns a copy of the receiver with its `kind` replaced. - /// - param newChild: The new `kind` to replace the node's - /// current `kind`, if present. - public func withKind(_ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) - } - - public var unexpectedBetweenKindAndColon: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenKindAndColon(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenKindAndColon` replaced. - /// - param newChild: The new `unexpectedBetweenKindAndColon` to replace the node's - /// current `unexpectedBetweenKindAndColon`, if present. - public func withUnexpectedBetweenKindAndColon(_ newChild: UnexpectedNodesSyntax?) -> ObjcSelectorExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) - } - - public var colon: TokenSyntax? { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withColon(value) - } - } - - /// Returns a copy of the receiver with its `colon` replaced. - /// - param newChild: The new `colon` to replace the node's - /// current `colon`, if present. - public func withColon(_ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) - } - - public var unexpectedBetweenColonAndName: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenColonAndName(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenColonAndName` replaced. - /// - param newChild: The new `unexpectedBetweenColonAndName` to replace the node's - /// current `unexpectedBetweenColonAndName`, if present. - public func withUnexpectedBetweenColonAndName(_ newChild: UnexpectedNodesSyntax?) -> ObjcSelectorExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) - } - - public var name: ExprSyntax { - get { - let childData = data.child(at: 9, parent: Syntax(self)) - return ExprSyntax(childData!) - } - set(value) { - self = withName(value) - } - } - - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: ExprSyntax?) -> ObjcSelectorExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena) - let newData = data.replacingChild(at: 9, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) - } - - public var unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 10, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) + return KeyPathComponentListSyntax(childData!) } set(value) { - self = withUnexpectedBetweenNameAndRightParen(value) + self = withComponents(value) } } - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndRightParen` to replace the node's - /// current `unexpectedBetweenNameAndRightParen`, if present. - public func withUnexpectedBetweenNameAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> ObjcSelectorExprSyntax { + /// Adds the provided `KeyPathComponent` to the node's `components` + /// collection. + /// - param element: The new `KeyPathComponent` to add to the node's + /// `components` collection. + /// - returns: A copy of the receiver with the provided `KeyPathComponent` + /// appended to its `components` collection. + public func addKeyPathComponent(_ element: KeyPathComponentSyntax) -> KeyPathExprSyntax { + var collection: RawSyntax let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 10, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) - } - - public var rightParen: TokenSyntax { - get { - let childData = data.child(at: 11, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withRightParen(value) + if let col = raw.layoutView!.children[5] { + collection = col.layoutView!.appending(element.raw, arena: arena) + } else { + collection = RawSyntax.makeLayout(kind: SyntaxKind.keyPathComponentList, + from: [element.raw], arena: arena) } + let newData = data.replacingChild(at: 5, with: collection, arena: arena) + return KeyPathExprSyntax(newData) } - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax { + /// Returns a copy of the receiver with its `components` replaced. + /// - param newChild: The new `components` to replace the node's + /// current `components`, if present. + public func withComponents(_ newChild: KeyPathComponentListSyntax?) -> KeyPathExprSyntax { let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) - let newData = data.replacingChild(at: 11, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) + let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.keyPathComponentList, arena: arena) + let newData = data.replacingChild(at: 5, with: raw, arena: arena) + return KeyPathExprSyntax(newData) } - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { + public var unexpectedAfterComponents: UnexpectedNodesSyntax? { get { - let childData = data.child(at: 12, parent: Syntax(self)) + let childData = data.child(at: 6, parent: Syntax(self)) if childData == nil { return nil } return UnexpectedNodesSyntax(childData!) } set(value) { - self = withUnexpectedAfterRightParen(value) + self = withUnexpectedAfterComponents(value) } } - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> ObjcSelectorExprSyntax { + /// Returns a copy of the receiver with its `unexpectedAfterComponents` replaced. + /// - param newChild: The new `unexpectedAfterComponents` to replace the node's + /// current `unexpectedAfterComponents`, if present. + public func withUnexpectedAfterComponents(_ newChild: UnexpectedNodesSyntax?) -> KeyPathExprSyntax { let arena = SyntaxArena() let raw = newChild?.raw - let newData = data.replacingChild(at: 12, with: raw, arena: arena) - return ObjcSelectorExprSyntax(newData) + let newData = data.replacingChild(at: 6, with: raw, arena: arena) + return KeyPathExprSyntax(newData) } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforePoundSelector, - \Self.poundSelector, - \Self.unexpectedBetweenPoundSelectorAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndKind, - \Self.kind, - \Self.unexpectedBetweenKindAndColon, - \Self.colon, - \Self.unexpectedBetweenColonAndName, - \Self.name, - \Self.unexpectedBetweenNameAndRightParen, - \Self.rightParen, - \Self.unexpectedAfterRightParen, + \Self.unexpectedBeforeBackslash, + \Self.backslash, + \Self.unexpectedBetweenBackslashAndRoot, + \Self.root, + \Self.unexpectedBetweenRootAndComponents, + \Self.components, + \Self.unexpectedAfterComponents, ]) } @@ -10097,24 +8500,12 @@ public struct ObjcSelectorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { case 2: return nil case 3: - return nil + return "root" case 4: return nil - case 5: - return nil - case 6: - return nil - case 7: - return nil - case 8: - return nil - case 9: - return "name" - case 10: - return nil - case 11: + case 5: return nil - case 12: + case 6: return nil default: fatalError("Invalid index") @@ -10122,22 +8513,16 @@ public struct ObjcSelectorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } -extension ObjcSelectorExprSyntax: CustomReflectable { +extension KeyPathExprSyntax: CustomReflectable { public var customMirror: Mirror { return Mirror(self, children: [ - "unexpectedBeforePoundSelector": unexpectedBeforePoundSelector.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "poundSelector": Syntax(poundSelector).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenPoundSelectorAndLeftParen": unexpectedBetweenPoundSelectorAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndKind": unexpectedBetweenLeftParenAndKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "kind": kind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenKindAndColon": unexpectedBetweenKindAndColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedBetweenColonAndName": unexpectedBetweenColonAndName.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, + "unexpectedBeforeBackslash": unexpectedBeforeBackslash.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "backslash": Syntax(backslash).asProtocol(SyntaxProtocol.self), + "unexpectedBetweenBackslashAndRoot": unexpectedBetweenBackslashAndRoot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "root": root.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "unexpectedBetweenRootAndComponents": unexpectedBetweenRootAndComponents.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "components": Syntax(components).asProtocol(SyntaxProtocol.self), + "unexpectedAfterComponents": unexpectedAfterComponents.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, ]) } } @@ -11001,311 +9386,3 @@ extension EditorPlaceholderExprSyntax: CustomReflectable { } } -// MARK: - ObjectLiteralExprSyntax - -public struct ObjectLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .objectLiteralExpr else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `ObjectLiteralExprSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .objectLiteralExpr) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax, - _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, - arguments: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeIdentifier?.raw, - identifier.raw, - unexpectedBetweenIdentifierAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objectLiteralExpr, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeIdentifier(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeIdentifier` replaced. - /// - param newChild: The new `unexpectedBeforeIdentifier` to replace the node's - /// current `unexpectedBeforeIdentifier`, if present. - public func withUnexpectedBeforeIdentifier(_ newChild: UnexpectedNodesSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var identifier: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withIdentifier(value) - } - } - - /// Returns a copy of the receiver with its `identifier` replaced. - /// - param newChild: The new `identifier` to replace the node's - /// current `identifier`, if present. - public func withIdentifier(_ newChild: TokenSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.poundColorLiteralKeyword, arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var unexpectedBetweenIdentifierAndLeftParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenIdentifierAndLeftParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenIdentifierAndLeftParen` replaced. - /// - param newChild: The new `unexpectedBetweenIdentifierAndLeftParen` to replace the node's - /// current `unexpectedBetweenIdentifierAndLeftParen`, if present. - public func withUnexpectedBetweenIdentifierAndLeftParen(_ newChild: UnexpectedNodesSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var leftParen: TokenSyntax { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withLeftParen(value) - } - } - - /// Returns a copy of the receiver with its `leftParen` replaced. - /// - param newChild: The new `leftParen` to replace the node's - /// current `leftParen`, if present. - public func withLeftParen(_ newChild: TokenSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena) - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenLeftParenAndArguments(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenLeftParenAndArguments` replaced. - /// - param newChild: The new `unexpectedBetweenLeftParenAndArguments` to replace the node's - /// current `unexpectedBetweenLeftParenAndArguments`, if present. - public func withUnexpectedBetweenLeftParenAndArguments(_ newChild: UnexpectedNodesSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var arguments: TupleExprElementListSyntax { - get { - let childData = data.child(at: 5, parent: Syntax(self)) - return TupleExprElementListSyntax(childData!) - } - set(value) { - self = withArguments(value) - } - } - - /// Adds the provided `Argument` to the node's `arguments` - /// collection. - /// - param element: The new `Argument` to add to the node's - /// `arguments` collection. - /// - returns: A copy of the receiver with the provided `Argument` - /// appended to its `arguments` collection. - public func addArgument(_ element: TupleExprElementSyntax) -> ObjectLiteralExprSyntax { - 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.tupleExprElementList, - from: [element.raw], arena: arena) - } - let newData = data.replacingChild(at: 5, with: collection, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - /// Returns a copy of the receiver with its `arguments` replaced. - /// - param newChild: The new `arguments` to replace the node's - /// current `arguments`, if present. - public func withArguments(_ newChild: TupleExprElementListSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena) - let newData = data.replacingChild(at: 5, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 6, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenArgumentsAndRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenArgumentsAndRightParen` replaced. - /// - param newChild: The new `unexpectedBetweenArgumentsAndRightParen` to replace the node's - /// current `unexpectedBetweenArgumentsAndRightParen`, if present. - public func withUnexpectedBetweenArgumentsAndRightParen(_ newChild: UnexpectedNodesSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 6, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var rightParen: TokenSyntax { - get { - let childData = data.child(at: 7, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withRightParen(value) - } - } - - /// Returns a copy of the receiver with its `rightParen` replaced. - /// - param newChild: The new `rightParen` to replace the node's - /// current `rightParen`, if present. - public func withRightParen(_ newChild: TokenSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena) - let newData = data.replacingChild(at: 7, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 8, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterRightParen(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterRightParen` replaced. - /// - param newChild: The new `unexpectedAfterRightParen` to replace the node's - /// current `unexpectedAfterRightParen`, if present. - public func withUnexpectedAfterRightParen(_ newChild: UnexpectedNodesSyntax?) -> ObjectLiteralExprSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 8, with: raw, arena: arena) - return ObjectLiteralExprSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeIdentifier, - \Self.identifier, - \Self.unexpectedBetweenIdentifierAndLeftParen, - \Self.leftParen, - \Self.unexpectedBetweenLeftParenAndArguments, - \Self.arguments, - \Self.unexpectedBetweenArgumentsAndRightParen, - \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 - default: - fatalError("Invalid index") - } - } -} - -extension ObjectLiteralExprSyntax: 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), - "unexpectedBetweenIdentifierAndLeftParen": unexpectedBetweenIdentifierAndLeftParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "leftParen": Syntax(leftParen).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenLeftParenAndArguments": unexpectedBetweenLeftParenAndArguments.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "arguments": Syntax(arguments).asProtocol(SyntaxProtocol.self), - "unexpectedBetweenArgumentsAndRightParen": unexpectedBetweenArgumentsAndRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "rightParen": Syntax(rightParen).asProtocol(SyntaxProtocol.self), - "unexpectedAfterRightParen": unexpectedAfterRightParen.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift index ab8fb3d758c..0444478b1b9 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift @@ -4729,190 +4729,6 @@ extension KeyPathOptionalComponentSyntax: CustomReflectable { } } -// MARK: - ObjcNamePieceSyntax - -public struct ObjcNamePieceSyntax: SyntaxProtocol, SyntaxHashable { - public let _syntaxNode: Syntax - - public init?(_ node: S) { - guard node.raw.kind == .objcNamePiece else { return nil } - self._syntaxNode = node._syntaxNode - } - - /// Creates a `ObjcNamePieceSyntax` node from the given `SyntaxData`. This assumes - /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour - /// is undefined. - internal init(_ data: SyntaxData) { - assert(data.raw.kind == .objcNamePiece) - self._syntaxNode = Syntax(data) - } - - public init( - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax?, - _ unexpectedAfterDot: UnexpectedNodesSyntax? = nil - ) { - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndDot?.raw, - dot?.raw, - unexpectedAfterDot?.raw, - ] - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objcNamePiece, - from: layout, arena: arena) - return SyntaxData.forRoot(raw) - } - self.init(data) - } - - public var unexpectedBeforeName: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 0, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBeforeName(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBeforeName` replaced. - /// - param newChild: The new `unexpectedBeforeName` to replace the node's - /// current `unexpectedBeforeName`, if present. - public func withUnexpectedBeforeName(_ newChild: UnexpectedNodesSyntax?) -> ObjcNamePieceSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 0, with: raw, arena: arena) - return ObjcNamePieceSyntax(newData) - } - - public var name: TokenSyntax { - get { - let childData = data.child(at: 1, parent: Syntax(self)) - return TokenSyntax(childData!) - } - set(value) { - self = withName(value) - } - } - - /// Returns a copy of the receiver with its `name` replaced. - /// - param newChild: The new `name` to replace the node's - /// current `name`, if present. - public func withName(_ newChild: TokenSyntax?) -> ObjcNamePieceSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: arena) - let newData = data.replacingChild(at: 1, with: raw, arena: arena) - return ObjcNamePieceSyntax(newData) - } - - public var unexpectedBetweenNameAndDot: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 2, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedBetweenNameAndDot(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedBetweenNameAndDot` replaced. - /// - param newChild: The new `unexpectedBetweenNameAndDot` to replace the node's - /// current `unexpectedBetweenNameAndDot`, if present. - public func withUnexpectedBetweenNameAndDot(_ newChild: UnexpectedNodesSyntax?) -> ObjcNamePieceSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 2, with: raw, arena: arena) - return ObjcNamePieceSyntax(newData) - } - - public var dot: TokenSyntax? { - get { - let childData = data.child(at: 3, parent: Syntax(self)) - if childData == nil { return nil } - return TokenSyntax(childData!) - } - set(value) { - self = withDot(value) - } - } - - /// Returns a copy of the receiver with its `dot` replaced. - /// - param newChild: The new `dot` to replace the node's - /// current `dot`, if present. - public func withDot(_ newChild: TokenSyntax?) -> ObjcNamePieceSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 3, with: raw, arena: arena) - return ObjcNamePieceSyntax(newData) - } - - public var unexpectedAfterDot: UnexpectedNodesSyntax? { - get { - let childData = data.child(at: 4, parent: Syntax(self)) - if childData == nil { return nil } - return UnexpectedNodesSyntax(childData!) - } - set(value) { - self = withUnexpectedAfterDot(value) - } - } - - /// Returns a copy of the receiver with its `unexpectedAfterDot` replaced. - /// - param newChild: The new `unexpectedAfterDot` to replace the node's - /// current `unexpectedAfterDot`, if present. - public func withUnexpectedAfterDot(_ newChild: UnexpectedNodesSyntax?) -> ObjcNamePieceSyntax { - let arena = SyntaxArena() - let raw = newChild?.raw - let newData = data.replacingChild(at: 4, with: raw, arena: arena) - return ObjcNamePieceSyntax(newData) - } - - public static var structure: SyntaxNodeStructure { - return .layout([ - \Self.unexpectedBeforeName, - \Self.name, - \Self.unexpectedBetweenNameAndDot, - \Self.dot, - \Self.unexpectedAfterDot, - ]) - } - - 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 ObjcNamePieceSyntax: 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), - "unexpectedBetweenNameAndDot": unexpectedBetweenNameAndDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "dot": dot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - "unexpectedAfterDot": unexpectedAfterDot.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, - ]) - } -} - // MARK: - YieldExprListElementSyntax public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift index c8175f4d335..7cafdfd3302 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift @@ -245,13 +245,6 @@ extension ObjCSelector: ExpressibleByArrayLiteral { } } -/// `ObjcName` represents a collection of `ObjcNamePieceSyntax` -extension ObjcName: ExpressibleByArrayLiteral { - public init (arrayLiteral elements: Element...) { - self.init (elements) - } -} - /// `PatternBindingList` represents a collection of `PatternBindingSyntax` extension PatternBindingList: ExpressibleByArrayLiteral { public init (arrayLiteral elements: Element...) { diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index 7fb53d7b843..7880613d005 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -3253,118 +3253,6 @@ extension ObjCSelectorPiece { } } -extension ObjcKeyPathExpr { - /// Creates a `ObjcKeyPathExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforeKeyPath: - /// - keyPath: - /// - unexpectedBetweenKeyPathAndLeftParen: - /// - leftParen: - /// - unexpectedBetweenLeftParenAndName: - /// - name: - /// - unexpectedBetweenNameAndRightParen: - /// - rightParen: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforeKeyPath: UnexpectedNodes? = nil, keyPath: Token = Token.`poundKeyPath`, unexpectedBetweenKeyPathAndLeftParen: UnexpectedNodes? = nil, leftParen: Token = Token.`leftParen`, unexpectedBetweenLeftParenAndName: UnexpectedNodes? = nil, name: ObjcName, unexpectedBetweenNameAndRightParen: UnexpectedNodes? = nil, rightParen: Token = Token.`rightParen`) { - assert(keyPath.text == "#keyPath") - assert(leftParen.text == "(") - assert(rightParen.text == ")") - self = ObjcKeyPathExprSyntax(unexpectedBeforeKeyPath, keyPath: keyPath, unexpectedBetweenKeyPathAndLeftParen, leftParen: leftParen, unexpectedBetweenLeftParenAndName, name: name, unexpectedBetweenNameAndRightParen, rightParen: rightParen) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - -extension ObjcNamePiece { - /// Creates a `ObjcNamePiece` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforeName: - /// - name: - /// - unexpectedBetweenNameAndDot: - /// - dot: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforeName: UnexpectedNodes? = nil, name: Token, unexpectedBetweenNameAndDot: UnexpectedNodes? = nil, dot: Token? = nil) { - assert(dot == nil || dot!.text == ".") - self = ObjcNamePieceSyntax(unexpectedBeforeName, name: name, unexpectedBetweenNameAndDot, dot: dot) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } - - /// A convenience initializer that allows: - /// - Initializing syntax collections using result builders - /// - Initializing tokens without default text using strings - @_disfavoredOverload public init (leadingTrivia: Trivia = [], unexpectedBeforeName: UnexpectedNodes? = nil, name: String, unexpectedBetweenNameAndDot: UnexpectedNodes? = nil, dot: Token? = nil) { - self.init (unexpectedBeforeName, name: Token.`identifier`(name), unexpectedBetweenNameAndDot, dot: dot) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - } -} - -extension ObjcSelectorExpr { - /// Creates a `ObjcSelectorExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundSelector: - /// - poundSelector: - /// - unexpectedBetweenPoundSelectorAndLeftParen: - /// - leftParen: - /// - unexpectedBetweenLeftParenAndKind: - /// - kind: - /// - unexpectedBetweenKindAndColon: - /// - colon: - /// - unexpectedBetweenColonAndName: - /// - name: - /// - unexpectedBetweenNameAndRightParen: - /// - rightParen: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundSelector: UnexpectedNodes? = nil, poundSelector: Token = Token.`poundSelector`, unexpectedBetweenPoundSelectorAndLeftParen: UnexpectedNodes? = nil, leftParen: Token = Token.`leftParen`, unexpectedBetweenLeftParenAndKind: UnexpectedNodes? = nil, kind: Token? = nil, unexpectedBetweenKindAndColon: UnexpectedNodes? = nil, colon: Token? = nil, unexpectedBetweenColonAndName: UnexpectedNodes? = nil, name: ExprSyntaxProtocol, unexpectedBetweenNameAndRightParen: UnexpectedNodes? = nil, rightParen: Token = Token.`rightParen`) { - assert(poundSelector.text == "#selector") - assert(leftParen.text == "(") - assert(kind == nil || kind!.text == "getter" || kind!.text == "setter") - assert(colon == nil || colon!.text == ":") - assert(rightParen.text == ")") - self = ObjcSelectorExprSyntax(unexpectedBeforePoundSelector, poundSelector: poundSelector, unexpectedBetweenPoundSelectorAndLeftParen, leftParen: leftParen, unexpectedBetweenLeftParenAndKind, kind: kind, unexpectedBetweenKindAndColon, colon: colon, unexpectedBetweenColonAndName, name: ExprSyntax(fromProtocol: name), unexpectedBetweenNameAndRightParen, rightParen: rightParen) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } - - /// A convenience initializer that allows: - /// - Initializing syntax collections using result builders - /// - Initializing tokens without default text using strings - @_disfavoredOverload public init (leadingTrivia: Trivia = [], unexpectedBeforePoundSelector: UnexpectedNodes? = nil, poundSelector: Token = Token.`poundSelector`, unexpectedBetweenPoundSelectorAndLeftParen: UnexpectedNodes? = nil, leftParen: Token = Token.`leftParen`, unexpectedBetweenLeftParenAndKind: UnexpectedNodes? = nil, kind: String?, unexpectedBetweenKindAndColon: UnexpectedNodes? = nil, colon: Token? = nil, unexpectedBetweenColonAndName: UnexpectedNodes? = nil, name: ExprSyntaxProtocol, unexpectedBetweenNameAndRightParen: UnexpectedNodes? = nil, rightParen: Token = Token.`rightParen`) { - self.init (unexpectedBeforePoundSelector, poundSelector: poundSelector, unexpectedBetweenPoundSelectorAndLeftParen, leftParen: leftParen, unexpectedBetweenLeftParenAndKind, kind: kind.map { - Token.`contextualKeyword`($0) - }, unexpectedBetweenKindAndColon, colon: colon, unexpectedBetweenColonAndName, name: ExprSyntax(fromProtocol: name), unexpectedBetweenNameAndRightParen, rightParen: rightParen) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - } -} - -extension ObjectLiteralExpr { - /// Creates a `ObjectLiteralExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforeIdentifier: - /// - identifier: - /// - unexpectedBetweenIdentifierAndLeftParen: - /// - leftParen: - /// - unexpectedBetweenLeftParenAndArguments: - /// - arguments: - /// - unexpectedBetweenArgumentsAndRightParen: - /// - rightParen: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforeIdentifier: UnexpectedNodes? = nil, identifier: Token, unexpectedBetweenIdentifierAndLeftParen: UnexpectedNodes? = nil, leftParen: Token = Token.`leftParen`, unexpectedBetweenLeftParenAndArguments: UnexpectedNodes? = nil, arguments: TupleExprElementList, unexpectedBetweenArgumentsAndRightParen: UnexpectedNodes? = nil, rightParen: Token = Token.`rightParen`) { - assert(identifier.text == "#colorLiteral" || identifier.text == "#fileLiteral" || identifier.text == "#imageLiteral") - assert(leftParen.text == "(") - assert(rightParen.text == ")") - self = ObjectLiteralExprSyntax(unexpectedBeforeIdentifier, identifier: identifier, unexpectedBetweenIdentifierAndLeftParen, leftParen: leftParen, unexpectedBetweenLeftParenAndArguments, arguments: arguments, unexpectedBetweenArgumentsAndRightParen, rightParen: rightParen) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } - - /// A convenience initializer that allows: - /// - Initializing syntax collections using result builders - /// - Initializing tokens without default text using strings - @_disfavoredOverload public init (leadingTrivia: Trivia = [], unexpectedBeforeIdentifier: UnexpectedNodes? = nil, identifier: Token, unexpectedBetweenIdentifierAndLeftParen: UnexpectedNodes? = nil, leftParen: Token = Token.`leftParen`, unexpectedBetweenLeftParenAndArguments: UnexpectedNodes? = nil, unexpectedBetweenArgumentsAndRightParen: UnexpectedNodes? = nil, rightParen: Token = Token.`rightParen`, @TupleExprElementListBuilder argumentsBuilder: () -> TupleExprElementListSyntax = { - TupleExprElementListSyntax([]) - }) { - self.init (unexpectedBeforeIdentifier, identifier: identifier, unexpectedBetweenIdentifierAndLeftParen, leftParen: leftParen, unexpectedBetweenLeftParenAndArguments, arguments: argumentsBuilder(), unexpectedBetweenArgumentsAndRightParen, rightParen: rightParen) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - } -} - /// The arguments for the '@_opaqueReturnTypeOf()'. extension OpaqueReturnTypeOfAttributeArguments { /// Creates a `OpaqueReturnTypeOfAttributeArguments` using the provided parameters. @@ -3648,32 +3536,6 @@ extension PoundAssertStmt { } } -extension PoundColumnExpr { - /// Creates a `PoundColumnExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundColumn: - /// - poundColumn: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundColumn: UnexpectedNodes? = nil, poundColumn: Token = Token.`poundColumn`) { - assert(poundColumn.text == "#column") - self = PoundColumnExprSyntax(unexpectedBeforePoundColumn, poundColumn: poundColumn) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - -extension PoundDsohandleExpr { - /// Creates a `PoundDsohandleExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundDsohandle: - /// - poundDsohandle: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundDsohandle: UnexpectedNodes? = nil, poundDsohandle: Token = Token.`poundDsohandle`) { - assert(poundDsohandle.text == "#dsohandle") - self = PoundDsohandleExprSyntax(unexpectedBeforePoundDsohandle, poundDsohandle: poundDsohandle) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - extension PoundErrorDecl { /// Creates a `PoundErrorDecl` using the provided parameters. /// - Parameters: @@ -3695,71 +3557,6 @@ extension PoundErrorDecl { } } -extension PoundFileExpr { - /// Creates a `PoundFileExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundFile: - /// - poundFile: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundFile: UnexpectedNodes? = nil, poundFile: Token = Token.`poundFile`) { - assert(poundFile.text == "#file") - self = PoundFileExprSyntax(unexpectedBeforePoundFile, poundFile: poundFile) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - -extension PoundFileIDExpr { - /// Creates a `PoundFileIDExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundFileID: - /// - poundFileID: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundFileID: UnexpectedNodes? = nil, poundFileID: Token = Token.`poundFileID`) { - assert(poundFileID.text == "#fileID") - self = PoundFileIDExprSyntax(unexpectedBeforePoundFileID, poundFileID: poundFileID) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - -extension PoundFilePathExpr { - /// Creates a `PoundFilePathExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundFilePath: - /// - poundFilePath: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundFilePath: UnexpectedNodes? = nil, poundFilePath: Token = Token.`poundFilePath`) { - assert(poundFilePath.text == "#filePath") - self = PoundFilePathExprSyntax(unexpectedBeforePoundFilePath, poundFilePath: poundFilePath) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - -extension PoundFunctionExpr { - /// Creates a `PoundFunctionExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundFunction: - /// - poundFunction: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundFunction: UnexpectedNodes? = nil, poundFunction: Token = Token.`poundFunction`) { - assert(poundFunction.text == "#function") - self = PoundFunctionExprSyntax(unexpectedBeforePoundFunction, poundFunction: poundFunction) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - -extension PoundLineExpr { - /// Creates a `PoundLineExpr` using the provided parameters. - /// - Parameters: - /// - unexpectedBeforePoundLine: - /// - poundLine: - @_disfavoredOverload public init (leadingTrivia: Trivia = [], trailingTrivia: Trivia = [], unexpectedBeforePoundLine: UnexpectedNodes? = nil, poundLine: Token = Token.`poundLine`) { - assert(poundLine.text == "#line") - self = PoundLineExprSyntax(unexpectedBeforePoundLine, poundLine: poundLine) - self.leadingTrivia = leadingTrivia + (self.leadingTrivia ?? []) - self.trailingTrivia = trailingTrivia + (self.trailingTrivia ?? []) - } -} - extension PoundSourceLocationArgs { /// Creates a `PoundSourceLocationArgs` using the provided parameters. /// - Parameters: diff --git a/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift b/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift index 644f2e1410c..904818f544e 100644 --- a/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift +++ b/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift @@ -2635,86 +2635,6 @@ public extension ObjCSelector { } } -@resultBuilder -public struct ObjcNameBuilder { - /// The type of individual statement expressions in the transformed function, - /// which defaults to Component if buildExpression() is not provided. - public typealias Expression = ObjcNamePiece - - /// The type of a partial result, which will be carried through all of the - /// build methods. - public typealias Component = [Expression] - - /// The type of the final returned result, which defaults to Component if - /// buildFinalResult() is not provided. - public typealias FinalResult = ObjcName - - /// Required by every result builder to build combined results from - /// statement blocks. - public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 - } - } - - /// If declared, provides contextual type information for statement - /// expressions to translate them into partial results. - public static func buildExpression(_ expression: Self.Expression) -> Self.Component { - return [expression] - } - - /// Add all the elements of `expression` to this result builder, effectively flattening them. - public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 - } - } - - /// Enables support for `if` statements that do not have an `else`. - public static func buildOptional(_ component: Self.Component?) -> Self.Component { - return component ?? [] - } - - /// With buildEither(second:), enables support for 'if-else' and 'switch' - /// statements by folding conditional results into a single result. - public static func buildEither(first component: Self.Component) -> Self.Component { - return component - } - - /// With buildEither(first:), enables support for 'if-else' and 'switch' - /// statements by folding conditional results into a single result. - public static func buildEither(second component: Self.Component) -> Self.Component { - return component - } - - /// Enables support for 'for..in' loops by combining the - /// results of all iterations into a single result. - public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 - } - } - - /// If declared, this will be called on the partial result of an 'if' - /// #available' block to allow the result builder to erase type - /// information. - public static func buildLimitedAvailability(_ component: Self.Component) -> Self.Component { - return component - } - - /// If declared, this will be called on the partial result from the outermost - /// block statement to produce the final returned result. - public static func buildFinalResult(_ component: Component) -> FinalResult { - return .init (component) - } -} - -public extension ObjcName { - init (@ObjcNameBuilder itemsBuilder: () -> ObjcName) { - self = itemsBuilder() - } -} - @resultBuilder public struct PatternBindingListBuilder { /// The type of individual statement expressions in the transformed function, diff --git a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift index 3b41ba220ca..15810ddb2a6 100644 --- a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift +++ b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift @@ -285,15 +285,6 @@ extension NamedOpaqueReturnTypeSyntax: SyntaxExpressibleByStringInterpolation { extension NilLiteralExprSyntax: SyntaxExpressibleByStringInterpolation { } -extension ObjcKeyPathExprSyntax: SyntaxExpressibleByStringInterpolation { -} - -extension ObjcSelectorExprSyntax: SyntaxExpressibleByStringInterpolation { -} - -extension ObjectLiteralExprSyntax: SyntaxExpressibleByStringInterpolation { -} - extension OperatorDeclSyntax: SyntaxExpressibleByStringInterpolation { } @@ -338,30 +329,9 @@ extension PostfixUnaryExprSyntax: SyntaxExpressibleByStringInterpolation { extension PoundAssertStmtSyntax: SyntaxExpressibleByStringInterpolation { } -extension PoundColumnExprSyntax: SyntaxExpressibleByStringInterpolation { -} - -extension PoundDsohandleExprSyntax: SyntaxExpressibleByStringInterpolation { -} - extension PoundErrorDeclSyntax: SyntaxExpressibleByStringInterpolation { } -extension PoundFileExprSyntax: SyntaxExpressibleByStringInterpolation { -} - -extension PoundFileIDExprSyntax: SyntaxExpressibleByStringInterpolation { -} - -extension PoundFilePathExprSyntax: SyntaxExpressibleByStringInterpolation { -} - -extension PoundFunctionExprSyntax: SyntaxExpressibleByStringInterpolation { -} - -extension PoundLineExprSyntax: SyntaxExpressibleByStringInterpolation { -} - extension PoundSourceLocationSyntax: SyntaxExpressibleByStringInterpolation { } diff --git a/Sources/SwiftSyntaxBuilder/generated/Token.swift b/Sources/SwiftSyntaxBuilder/generated/Token.swift index 673675b7a39..77079d07435 100644 --- a/Sources/SwiftSyntaxBuilder/generated/Token.swift +++ b/Sources/SwiftSyntaxBuilder/generated/Token.swift @@ -281,31 +281,6 @@ public extension TokenSyntax { return .throwsKeyword() } - /// The `__FILE__` keyword - static var `__FILE__`: Token { - return .__file__Keyword() - } - - /// The `__LINE__` keyword - static var `__LINE__`: Token { - return .__line__Keyword() - } - - /// The `__COLUMN__` keyword - static var `__COLUMN__`: Token { - return .__column__Keyword() - } - - /// The `__FUNCTION__` keyword - static var `__FUNCTION__`: Token { - return .__function__Keyword() - } - - /// The `__DSO_HANDLE__` keyword - static var `__DSO_HANDLE__`: Token { - return .__dso_handle__Keyword() - } - /// The `_` keyword static var `wildcard`: Token { return .wildcardKeyword() @@ -446,51 +421,6 @@ public extension TokenSyntax { return .multilineStringQuoteToken() } - /// The `#keyPath` keyword - static var `poundKeyPath`: Token { - return .poundKeyPathKeyword() - } - - /// The `#line` keyword - static var `poundLine`: Token { - return .poundLineKeyword() - } - - /// The `#selector` keyword - static var `poundSelector`: Token { - return .poundSelectorKeyword() - } - - /// The `#file` keyword - static var `poundFile`: Token { - return .poundFileKeyword() - } - - /// The `#fileID` keyword - static var `poundFileID`: Token { - return .poundFileIDKeyword() - } - - /// The `#filePath` keyword - static var `poundFilePath`: Token { - return .poundFilePathKeyword() - } - - /// The `#column` keyword - static var `poundColumn`: Token { - return .poundColumnKeyword() - } - - /// The `#function` keyword - static var `poundFunction`: Token { - return .poundFunctionKeyword() - } - - /// The `#dsohandle` keyword - static var `poundDsohandle`: Token { - return .poundDsohandleKeyword() - } - /// The `#assert` keyword static var `poundAssert`: Token { return .poundAssertKeyword() @@ -541,21 +471,6 @@ public extension TokenSyntax { return .poundUnavailableKeyword() } - /// The `#fileLiteral` keyword - static var `poundFileLiteral`: Token { - return .poundFileLiteralKeyword() - } - - /// The `#imageLiteral` keyword - static var `poundImageLiteral`: Token { - return .poundImageLiteralKeyword() - } - - /// The `#colorLiteral` keyword - static var `poundColorLiteral`: Token { - return .poundColorLiteralKeyword() - } - /// The `#_hasSymbol` keyword static var `poundHasSymbol`: Token { return .poundHasSymbolKeyword() diff --git a/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift b/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift index 656cca89462..1cfbc11382d 100644 --- a/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift +++ b/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift @@ -353,16 +353,6 @@ public typealias ObjCSelectorPiece = ObjCSelectorPieceSyntax public typealias ObjCSelector = ObjCSelectorSyntax -public typealias ObjcKeyPathExpr = ObjcKeyPathExprSyntax - -public typealias ObjcNamePiece = ObjcNamePieceSyntax - -public typealias ObjcName = ObjcNameSyntax - -public typealias ObjcSelectorExpr = ObjcSelectorExprSyntax - -public typealias ObjectLiteralExpr = ObjectLiteralExprSyntax - public typealias OpaqueReturnTypeOfAttributeArguments = OpaqueReturnTypeOfAttributeArgumentsSyntax public typealias OperatorDecl = OperatorDeclSyntax @@ -393,22 +383,8 @@ public typealias PostfixUnaryExpr = PostfixUnaryExprSyntax public typealias PoundAssertStmt = PoundAssertStmtSyntax -public typealias PoundColumnExpr = PoundColumnExprSyntax - -public typealias PoundDsohandleExpr = PoundDsohandleExprSyntax - public typealias PoundErrorDecl = PoundErrorDeclSyntax -public typealias PoundFileExpr = PoundFileExprSyntax - -public typealias PoundFileIDExpr = PoundFileIDExprSyntax - -public typealias PoundFilePathExpr = PoundFilePathExprSyntax - -public typealias PoundFunctionExpr = PoundFunctionExprSyntax - -public typealias PoundLineExpr = PoundLineExprSyntax - public typealias PoundSourceLocationArgs = PoundSourceLocationArgsSyntax public typealias PoundSourceLocation = PoundSourceLocationSyntax diff --git a/Tests/SwiftParserTest/ExpressionTests.swift b/Tests/SwiftParserTest/ExpressionTests.swift index a1b1b63c827..308b95630ea 100644 --- a/Tests/SwiftParserTest/ExpressionTests.swift +++ b/Tests/SwiftParserTest/ExpressionTests.swift @@ -637,11 +637,10 @@ final class ExpressionTests: XCTestCase { ] ) - AssertParse("#keyPath(1️⃣(b:2️⃣)", + AssertParse("#keyPath((b:1️⃣)2️⃣", diagnostics: [ - DiagnosticSpec(locationMarker: "1️⃣", message: "expected identifier in '#keyPath' expression"), - DiagnosticSpec(locationMarker: "1️⃣", message: "expected ')' to end '#keyPath' expression"), - DiagnosticSpec(locationMarker: "2️⃣", message: "expected value in function call"), + DiagnosticSpec(locationMarker: "1️⃣", message: "expected value in tuple"), + DiagnosticSpec(locationMarker: "2️⃣", message: "expected ')' to end pound literal expression"), ]) } diff --git a/Tests/SwiftSyntaxParserTest/TokenTest.swift b/Tests/SwiftSyntaxParserTest/TokenTest.swift index ec5df3693fc..a7d0cb1f8f4 100644 --- a/Tests/SwiftSyntaxParserTest/TokenTest.swift +++ b/Tests/SwiftSyntaxParserTest/TokenTest.swift @@ -120,11 +120,6 @@ public class TokenTests: XCTestCase { TokenKind.trueKeyword, TokenKind.tryKeyword, TokenKind.throwsKeyword, - TokenKind.__file__Keyword, - TokenKind.__line__Keyword, - TokenKind.__column__Keyword, - TokenKind.__function__Keyword, - TokenKind.__dso_handle__Keyword, TokenKind.wildcardKeyword, ] diff --git a/gyb_syntax_support/ExprNodes.py b/gyb_syntax_support/ExprNodes.py index 624910a3f1a..507e539678e 100644 --- a/gyb_syntax_support/ExprNodes.py +++ b/gyb_syntax_support/ExprNodes.py @@ -10,12 +10,6 @@ Child('Expression', kind='Expr'), ]), - # A #column expression. - Node('PoundColumnExpr', name_for_diagnostics=None, kind='Expr', - children=[ - Child('PoundColumn', kind='PoundColumnToken'), - ]), - Node('TupleExprElementList', name_for_diagnostics=None, kind='SyntaxCollection', element='TupleExprElement'), @@ -135,42 +129,6 @@ by a `SequenceExprSyntax`. '''), - # A #line expression. - Node('PoundLineExpr', name_for_diagnostics=None, kind='Expr', - children=[ - Child('PoundLine', kind='PoundLineToken'), - ]), - - # A #file expression. - Node('PoundFileExpr', name_for_diagnostics=None, kind='Expr', - children=[ - Child('PoundFile', kind='PoundFileToken'), - ]), - - # A #fileID expression. - Node('PoundFileIDExpr', name_for_diagnostics=None, kind='Expr', - children=[ - Child('PoundFileID', kind='PoundFileIDToken'), - ]), - - # A #filePath expression. - Node('PoundFilePathExpr', name_for_diagnostics=None, kind='Expr', - children=[ - Child('PoundFilePath', kind='PoundFilePathToken'), - ]), - - # A #function expression. - Node('PoundFunctionExpr', name_for_diagnostics=None, kind='Expr', - children=[ - Child('PoundFunction', kind='PoundFunctionToken'), - ]), - - # A #dsohandle expression. - Node('PoundDsohandleExpr', name_for_diagnostics=None, kind='Expr', - children=[ - Child('PoundDsohandle', kind='PoundDsohandleToken'), - ]), - # symbolic-reference-expression -> identifier generic-argument-clause? Node('SymbolicReferenceExpr', name_for_diagnostics=None, kind='Expr', children=[ @@ -682,43 +640,6 @@ ]), ]), - # e.g. "a." or "a" - Node('ObjcNamePiece', name_for_diagnostics=None, kind='Syntax', - children=[ - Child('Name', kind='IdentifierToken'), - Child('Dot', kind='PeriodToken', is_optional=True), - ]), - - # e.g. "a.b.c" - Node('ObjcName', name_for_diagnostics=None, kind='SyntaxCollection', - element='ObjcNamePiece'), - - # e.g. "#keyPath(a.b.c)" - Node('ObjcKeyPathExpr', name_for_diagnostics="'#keyPath' expression", kind='Expr', - traits=['Parenthesized'], - children=[ - Child('KeyPath', kind='PoundKeyPathToken'), - Child('LeftParen', kind='LeftParenToken'), - Child('Name', kind='ObjcName', name_for_diagnostics='name', - collection_element_name='NamePiece'), - Child('RightParen', kind='RightParenToken'), - ]), - - # e.g. "#selector(getter:Foo.bar)" - Node('ObjcSelectorExpr', name_for_diagnostics="'#selector' expression", kind='Expr', - traits=['Parenthesized'], - children=[ - Child('PoundSelector', kind='PoundSelectorToken'), - Child('LeftParen', kind='LeftParenToken'), - Child('Kind', kind='ContextualKeywordToken', - text_choices=['getter', 'setter'], - is_optional=True), - Child('Colon', kind='ColonToken', - is_optional=True), - Child('Name', kind='Expr', name_for_diagnostics='name'), - Child('RightParen', kind='RightParenToken'), - ]), - # e.g., "#embed("filename.txt")" Node('MacroExpansionExpr', name_for_diagnostics="pound literal expression", kind='Expr', @@ -755,21 +676,6 @@ children=[ Child('Identifier', kind='IdentifierToken'), ]), - # #fileLiteral(a, b, c) - Node('ObjectLiteralExpr', name_for_diagnostics='object literal', kind='Expr', - traits=['Parenthesized'], - children=[ - Child('Identifier', kind='Token', - token_choices=[ - 'PoundColorLiteralToken', - 'PoundFileLiteralToken', - 'PoundImageLiteralToken', - ]), - Child('LeftParen', kind='LeftParenToken'), - Child('Arguments', kind='TupleExprElementList', - collection_element_name='Argument'), - Child('RightParen', kind='RightParenToken'), - ]), Node('YieldExprList', name_for_diagnostics='yield list', kind='SyntaxCollection', diff --git a/gyb_syntax_support/Token.py b/gyb_syntax_support/Token.py index 3b2298c8527..24986a5d8e5 100644 --- a/gyb_syntax_support/Token.py +++ b/gyb_syntax_support/Token.py @@ -99,24 +99,6 @@ def macro_name(self): return "POUND_KEYWORD" -class PoundObjectLiteral(PoundKeyword): - def __init__(self, name, kind, text, name_for_diagnostics, - protocol, classification='ObjectLiteral'): - PoundKeyword.__init__( - self, - name=name, - kind=kind, - text=text, - name_for_diagnostics=name_for_diagnostics, - classification=classification - ) - self.description = name_for_diagnostics - self.protocol = protocol - - def macro_name(self): - return "POUND_OBJECT_LITERAL" - - class PoundConfig(PoundKeyword): def macro_name(self): return "POUND_CONFIG" @@ -244,12 +226,6 @@ def macro_name(self): ExprKeyword('Try', 'try'), ExprKeyword('Throws', 'throws'), - Keyword('__FILE__', '__FILE__'), - Keyword('__LINE__', '__LINE__'), - Keyword('__COLUMN__', '__COLUMN__'), - Keyword('__FUNCTION__', '__FUNCTION__'), - Keyword('__DSO_HANDLE__', '__DSO_HANDLE__'), - # Pattern keywords PatternKeyword('Wildcard', '_'), @@ -298,15 +274,6 @@ def macro_name(self): # Keywords prefixed with a '#'. - PoundKeyword('PoundKeyPath', 'keyPath', text='#keyPath'), - PoundKeyword('PoundLine', 'line', text='#line'), - PoundKeyword('PoundSelector', 'selector', text='#selector'), - PoundKeyword('PoundFile', 'file', text='#file'), - PoundKeyword('PoundFileID', 'fileID', text='#fileID'), - PoundKeyword('PoundFilePath', 'filePath', text='#filePath'), - PoundKeyword('PoundColumn', 'column', text='#column'), - PoundKeyword('PoundFunction', 'function', text='#function'), - PoundKeyword('PoundDsohandle', 'dsohandle', text='#dsohandle'), PoundKeyword('PoundAssert', 'assert', text='#assert'), PoundDirectiveKeyword('PoundSourceLocation', 'sourceLocation', @@ -324,19 +291,6 @@ def macro_name(self): PoundConfig('PoundAvailable', 'available', text='#available'), PoundConfig('PoundUnavailable', 'unavailable', text='#unavailable'), - PoundObjectLiteral('PoundFileLiteral', 'fileLiteral', - text='#fileLiteral', - name_for_diagnostics='file reference', - protocol='ExpressibleByFileReferenceLiteral'), - PoundObjectLiteral('PoundImageLiteral', 'imageLiteral', - text='#imageLiteral', - name_for_diagnostics='image', - protocol='ExpressibleByImageLiteral'), - PoundObjectLiteral('PoundColorLiteral', 'colorLiteral', - text='#colorLiteral', - name_for_diagnostics='color', - protocol='ExpressibleByColorLiteral'), - PoundConfig('PoundHasSymbol', '_hasSymbol', text='#_hasSymbol'), Literal('IntegerLiteral', 'integer_literal', name_for_diagnostics='integer literal',