From c1ebe0e11ec0b17073e6cf4812bcafe550daa610 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Tue, 18 Mar 2025 20:23:27 +0000 Subject: [PATCH 1/3] Move `repeat` handling from `canParseTypeScalar` to `canParseType` This is handled in `parseType`, not `parseTypeScalar`. `canParseType` is currently the only client of `canParseTypeScalar` though, so this is NFC. --- Sources/SwiftParser/Types.swift | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift index 89d7ce16210..2a205011f36 100644 --- a/Sources/SwiftParser/Types.swift +++ b/Sources/SwiftParser/Types.swift @@ -626,6 +626,9 @@ extension Parser { extension Parser.Lookahead { mutating func canParseType() -> Bool { + // 'repeat' starts a pack expansion type + self.consume(if: .keyword(.repeat)) + guard self.canParseTypeScalar() else { return false } @@ -656,9 +659,6 @@ extension Parser.Lookahead { } mutating func canParseTypeScalar() -> Bool { - // 'repeat' starts a pack expansion type - self.consume(if: .keyword(.repeat)) - self.skipTypeAttributeList() guard self.canParseSimpleOrCompositionType() else { From 46b5bda8539ddecc11ee653e3c3bcf1bd9eb724b Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Tue, 18 Mar 2025 20:23:27 +0000 Subject: [PATCH 2/3] Parse InlineArray type sugar Parse e.g `[3 x Int]` as type sugar for InlineArray. Gated behind an experimental feature flag for now. --- .../SyntaxSupport/ExperimentalFeatures.swift | 5 + .../Sources/SyntaxSupport/KeywordSpec.swift | 3 + .../SyntaxSupport/SyntaxNodeKind.swift | 1 + .../Sources/SyntaxSupport/TypeNodes.swift | 42 +++++ .../ValidateSyntaxNodes.swift | 11 ++ Sources/SwiftParser/Expressions.swift | 9 ++ Sources/SwiftParser/TokenPrecedence.swift | 1 + Sources/SwiftParser/Types.swift | 144 +++++++++++++++--- .../SwiftParserTest/ExpressionTypeTests.swift | 38 +++++ Tests/SwiftParserTest/TypeTests.swift | 106 ++++++++++++- 10 files changed, 336 insertions(+), 24 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift index a62d4224a60..affe9c1b03f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift +++ b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift @@ -23,6 +23,7 @@ public enum ExperimentalFeature: String, CaseIterable { case abiAttribute case keypathWithMethodMembers case oldOwnershipOperatorSpellings + case inlineArrayTypeSugar /// The name of the feature as it is written in the compiler's `Features.def` file. public var featureName: String { @@ -47,6 +48,8 @@ public enum ExperimentalFeature: String, CaseIterable { return "KeypathWithMethodMembers" case .oldOwnershipOperatorSpellings: return "OldOwnershipOperatorSpellings" + case .inlineArrayTypeSugar: + return "InlineArrayTypeSugar" } } @@ -73,6 +76,8 @@ public enum ExperimentalFeature: String, CaseIterable { return "keypaths with method members" case .oldOwnershipOperatorSpellings: return "`_move` and `_borrow` as ownership operators" + case .inlineArrayTypeSugar: + return "sugar type for InlineArray" } } diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift index 439c8b7b147..33cbefca7af 100644 --- a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift +++ b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift @@ -293,6 +293,7 @@ public enum Keyword: CaseIterable { case willSet case witness_method case wrt + case x case yield public var spec: KeywordSpec { @@ -735,6 +736,8 @@ public enum Keyword: CaseIterable { return KeywordSpec("witness_method") case .wrt: return KeywordSpec("wrt") + case .x: + return KeywordSpec("x", experimentalFeature: .inlineArrayTypeSugar) case .yield: return KeywordSpec("yield") } diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index 53867ea09bb..e4d0407204f 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -172,6 +172,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon case inheritedTypeList case initializerClause case initializerDecl + case inlineArrayType case inOutExpr case integerLiteralExpr case isExpr diff --git a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift index 65dc41bbb86..1dfac971f8b 100644 --- a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift @@ -300,6 +300,48 @@ public let TYPE_NODES: [Node] = [ ] ), + Node( + kind: .inlineArrayType, + base: .type, + experimentalFeature: .inlineArrayTypeSugar, + nameForDiagnostics: "inline array type", + documentation: "An inline array type `[3 x Int]`, sugar for `InlineArray<3, Int>`.", + children: [ + Child( + name: "leftSquare", + kind: .token(choices: [.token(.leftSquare)]) + ), + Child( + name: "count", + kind: .node(kind: .genericArgument), + nameForDiagnostics: "count", + documentation: """ + The `count` argument for the inline array type. + + - Note: In semantically valid Swift code, this is always an integer or a wildcard type, e.g `_` in `[_ x Int]`. + """ + ), + Child( + name: "separator", + kind: .token(choices: [.keyword(.x)]) + ), + Child( + name: "element", + kind: .node(kind: .genericArgument), + nameForDiagnostics: "element type", + documentation: """ + The `element` argument for the inline array type. + + - Note: In semantically valid Swift code, this is always a type. + """ + ), + Child( + name: "rightSquare", + kind: .token(choices: [.token(.rightSquare)]) + ), + ] + ), + Node( kind: .memberType, base: .type, diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift index ffb61aa66dd..dc3219f7a95 100644 --- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift +++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift @@ -380,6 +380,11 @@ class ValidateSyntaxNodes: XCTestCase { message: "child 'defaultKeyword' has a single keyword as its only token choice and is followed by a colon. It should thus be named 'defaultLabel'" ), + // 'separator' is more descriptive than 'xKeyword' + ValidationFailure( + node: .inlineArrayType, + message: "child 'separator' has a single keyword as its only token choice and should thus be named 'xKeyword'" + ), ] ) } @@ -523,6 +528,12 @@ class ValidateSyntaxNodes: XCTestCase { message: "child 'closure' is named inconsistently with 'FunctionCallExprSyntax.trailingClosure', which has the same type ('ClosureExprSyntax')" ), + // Giving these fields distinct names is more helpful. + ValidationFailure( + node: .inlineArrayType, + message: + "child 'element' is named inconsistently with 'InlineArrayTypeSyntax.count', which has the same type ('GenericArgumentSyntax')" + ), ] ) } diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 1aad77b9558..df36120f6f9 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -1591,6 +1591,15 @@ extension Parser { let (unexpectedBeforeLSquare, lsquare) = self.expect(.leftSquare) + // Check to see if we have an InlineArray type in expression position. + if self.isAtStartOfInlineArrayTypeBody() { + let type = self.parseInlineArrayType( + unexpectedBeforeLSquare: unexpectedBeforeLSquare, + leftSquare: lsquare + ) + return RawExprSyntax(RawTypeExprSyntax(type: type, arena: self.arena)) + } + if let rsquare = self.consume(if: .rightSquare) { return RawExprSyntax( RawArrayExprSyntax( diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift index 7a7e84d6bb4..a41eaa2cce4 100644 --- a/Sources/SwiftParser/TokenPrecedence.swift +++ b/Sources/SwiftParser/TokenPrecedence.swift @@ -362,6 +362,7 @@ enum TokenPrecedence: Comparable { .weak, .witness_method, .wrt, + .x, .unsafe: self = .exprKeyword #if RESILIENT_LIBRARIES diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift index 2a205011f36..4a672a1c734 100644 --- a/Sources/SwiftParser/Types.swift +++ b/Sources/SwiftParser/Types.swift @@ -577,6 +577,11 @@ extension Parser { } extension Parser { + /// Whether the parser is at the start of an InlineArray type sugar body. + func isAtStartOfInlineArrayTypeBody() -> Bool { + withLookahead { $0.canParseStartOfInlineArrayTypeBody() } + } + /// Parse an array or dictionary type.. mutating func parseCollectionType() -> RawTypeSyntax { if let remaingingTokens = remainingTokensIfMaximumNestingLevelReached() { @@ -592,6 +597,15 @@ extension Parser { } let (unexpectedBeforeLSquare, leftsquare) = self.expect(.leftSquare) + + // Check to see if we're at the start of an InlineArray type. + if self.isAtStartOfInlineArrayTypeBody() { + return self.parseInlineArrayType( + unexpectedBeforeLSquare: unexpectedBeforeLSquare, + leftSquare: leftsquare + ) + } + let firstType = self.parseType() if let colon = self.consume(if: .colon) { let secondType = self.parseType() @@ -622,6 +636,39 @@ extension Parser { ) } } + + mutating func parseInlineArrayType( + unexpectedBeforeLSquare: RawUnexpectedNodesSyntax?, + leftSquare: RawTokenSyntax + ) -> RawTypeSyntax { + precondition(self.experimentalFeatures.contains(.inlineArrayTypeSugar)) + + // We allow both values and types here and for the element type for + // better recovery in cases where the user writes e.g '[Int x 3]'. + let count = self.parseGenericArgumentType() + + let (unexpectedBeforeSeparator, separator) = self.expect( + TokenSpec(.x, allowAtStartOfLine: false) + ) + + let element = self.parseGenericArgumentType() + + let (unexpectedBeforeRightSquare, rightSquare) = self.expect(.rightSquare) + + return RawTypeSyntax( + RawInlineArrayTypeSyntax( + unexpectedBeforeLSquare, + leftSquare: leftSquare, + count: .init(argument: count, trailingComma: nil, arena: self.arena), + unexpectedBeforeSeparator, + separator: separator, + element: .init(argument: element, trailingComma: nil, arena: self.arena), + unexpectedBeforeRightSquare, + rightSquare: rightSquare, + arena: self.arena + ) + ) + } } extension Parser.Lookahead { @@ -714,15 +761,7 @@ extension Parser.Lookahead { } case TokenSpec(.leftSquare): self.consumeAnyToken() - guard self.canParseType() else { - return false - } - if self.consume(if: .colon) != nil { - guard self.canParseType() else { - return false - } - } - guard self.consume(if: .rightSquare) != nil else { + guard self.canParseCollectionTypeBody() else { return false } case TokenSpec(.wildcard): @@ -762,6 +801,59 @@ extension Parser.Lookahead { return true } + /// Checks whether we can parse the start of an InlineArray type. This does + /// not include the element type. + mutating func canParseStartOfInlineArrayTypeBody() -> Bool { + guard self.experimentalFeatures.contains(.inlineArrayTypeSugar) else { + return false + } + + // We must have at least '[ x', which cannot be any other + // kind of expression or type. We specifically look for both types and + // integers for better recovery in e.g cases where the user writes e.g + // '[Int x 2]'. We only do type-scalar since variadics would be ambiguous + // e.g 'Int...x'. + guard self.canParseTypeScalar() || self.canParseIntegerLiteral() else { + return false + } + + // We don't currently allow multi-line since that would require + // disambiguation with array literals. + return self.consume(if: TokenSpec(.x, allowAtStartOfLine: false)) != nil + } + + mutating func canParseInlineArrayTypeBody() -> Bool { + guard self.canParseStartOfInlineArrayTypeBody() else { + return false + } + // Note we look for both types and integers for better recovery in e.g cases + // where the user writes e.g '[Int x 2]'. + guard self.canParseGenericArgument() else { + return false + } + return self.consume(if: .rightSquare) != nil + } + + mutating func canParseCollectionTypeBody() -> Bool { + // Check to see if we have an InlineArray sugar type. + if self.experimentalFeatures.contains(.inlineArrayTypeSugar) { + var lookahead = self.lookahead() + if lookahead.canParseInlineArrayTypeBody() { + self = lookahead + return true + } + } + guard self.canParseType() else { + return false + } + if self.consume(if: .colon) != nil { + guard self.canParseType() else { + return false + } + } + return self.consume(if: .rightSquare) != nil + } + mutating func canParseTupleBodyType() -> Bool { guard !self.at(.rightParen, .rightBrace) && !self.atContextualPunctuator("...") @@ -863,6 +955,24 @@ extension Parser.Lookahead { return lookahead.currentToken.isGenericTypeDisambiguatingToken } + mutating func canParseIntegerLiteral() -> Bool { + if self.currentToken.tokenText == "-", self.peek(isAt: .integerLiteral) { + self.consumeAnyToken() + self.consumeAnyToken() + return true + } + if self.consume(if: .integerLiteral) != nil { + return true + } + return false + } + + mutating func canParseGenericArgument() -> Bool { + // A generic argument can either be a type or an integer literal (who is + // optionally negative). + self.canParseType() || self.canParseIntegerLiteral() + } + mutating func consumeGenericArguments() -> Bool { // Parse the opening '<'. guard self.consume(ifPrefix: "<", as: .leftAngle) != nil else { @@ -872,21 +982,9 @@ extension Parser.Lookahead { if !self.at(prefix: ">") { var loopProgress = LoopProgressCondition() repeat { - // A generic argument can either be a type or an integer literal (who is - // optionally negative). - if self.canParseType() { - continue - } else if self.currentToken.tokenText == "-", - self.peek(isAt: .integerLiteral) - { - self.consumeAnyToken() - self.consumeAnyToken() - continue - } else if self.consume(if: .integerLiteral) != nil { - continue + guard self.canParseGenericArgument() else { + return false } - - return false // Parse the comma, if the list continues. } while self.consume(if: .comma) != nil && self.hasProgressed(&loopProgress) } diff --git a/Tests/SwiftParserTest/ExpressionTypeTests.swift b/Tests/SwiftParserTest/ExpressionTypeTests.swift index 5e8676c7539..b274e41d6d9 100644 --- a/Tests/SwiftParserTest/ExpressionTypeTests.swift +++ b/Tests/SwiftParserTest/ExpressionTypeTests.swift @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +@_spi(ExperimentalLanguageFeatures) import SwiftParser import SwiftSyntax import XCTest @@ -105,4 +106,41 @@ final class ExpressionTypeTests: ParserTestCase { substructureAfterMarker: "1️⃣" ) } + + func testCanParseTypeInlineArray() { + // Make sure we can handle cases where the type is spelled first in + // an InlineArray sugar type. + let cases: [UInt: String] = [ + #line: "[3 x Int]", + #line: "[[3 x Int]]", + #line: "[[Int x 3]]", + #line: "[_ x Int]", + #line: "[Int x Int]", + #line: "[@escaping () -> Int x Int]", + #line: "[Int.Type x Int]", + #line: "[sending P & Q x Int]", + #line: "[(some P & Q) -> Int x Int]", + #line: "[~P x Int]", + #line: "[(Int, String) x Int]", + #line: "[G x Int]", + #line: "[[3 x Int] x Int]", + #line: "[[Int] x Int]", + #line: "[_ x Int]", + #line: "[_? x Int]", + #line: "[_?x Int]", + #line: "[_! x Int]", + #line: "[_!x Int]", + #line: "[Int?x Int]", + ] + for (line, type) in cases { + assertParse( + "S<\(type), 1️⃣X>.self", + { ExprSyntax.parse(from: &$0) }, + substructure: IdentifierTypeSyntax(name: .identifier("X")), + substructureAfterMarker: "1️⃣", + experimentalFeatures: [.inlineArrayTypeSugar, .valueGenerics], + line: line + ) + } + } } diff --git a/Tests/SwiftParserTest/TypeTests.swift b/Tests/SwiftParserTest/TypeTests.swift index fa679445f37..a903e440205 100644 --- a/Tests/SwiftParserTest/TypeTests.swift +++ b/Tests/SwiftParserTest/TypeTests.swift @@ -11,7 +11,7 @@ //===----------------------------------------------------------------------===// @_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftParser -@_spi(RawSyntax) import SwiftSyntax +@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftSyntax import XCTest final class TypeTests: ParserTestCase { @@ -538,3 +538,107 @@ final class TypeTests: ParserTestCase { ) } } + +final class InlineArrayTypeTests: ParserTestCase { + override var experimentalFeatures: Parser.ExperimentalFeatures { + [.inlineArrayTypeSugar, .valueGenerics] + } + + func testBasic() { + assertParse( + "[3 x Int]", + substructure: InlineArrayTypeSyntax( + count: .init(argument: .expr("3")), + separator: .keyword(.x), + element: .init(argument: .type(TypeSyntax("Int"))) + ) + ) + assertParse( + "[Int x _]", + substructure: InlineArrayTypeSyntax( + count: .init(argument: .type(TypeSyntax("Int"))), + separator: .keyword(.x), + element: .init(argument: .type(TypeSyntax("_"))) + ) + ) + } + + func testMultiline() { + // We don't currently allow multi-line. + assertParse( + """ + S<[ + 3 + 1️⃣x + Int + ]>() + """, + diagnostics: [ + DiagnosticSpec(message: "unexpected code in array") + ] + ) + assertParse( + """ + S<[3 + 1️⃣x + Int + ]>() + """, + diagnostics: [ + DiagnosticSpec(message: "unexpected code in array") + ] + ) + assertParse( + """ + S<[3 + 1️⃣x Int]>() + """, + diagnostics: [ + DiagnosticSpec(message: "unexpected code 'x Int' in array") + ] + ) + // These are okay. + assertParse( + """ + S<[3 x + Int]>() + """ + ) + assertParse( + """ + S<[ + 3 x Int + ]>() + """ + ) + } + + func testDiagnostics() { + assertParse( + "2️⃣[3 x1️⃣", + diagnostics: [ + DiagnosticSpec( + message: "expected element type and ']' to end inline array type", + fixIts: ["insert element type and ']'"] + ) + ], + fixedSource: "[3 x <#type#>]" + ) + assertParse( + "ℹ️[3 x Int1️⃣", + diagnostics: [ + DiagnosticSpec( + message: "expected ']' to end inline array type", + notes: [NoteSpec(message: "to match this opening '['")], + fixIts: ["insert ']'"] + ) + ], + fixedSource: "[3 x Int]" + ) + } + + func testEllipsis() { + // Make sure this isn't parsed as ' x ' + assertParse("[x...x]") + } +} From 8a5bebfad4e0bf2e92ab74c8f23f5199acc5d357 Mon Sep 17 00:00:00 2001 From: Hamish Knight Date: Tue, 18 Mar 2025 20:23:27 +0000 Subject: [PATCH 3/3] Re-generate generated sources --- .../generated/ExperimentalFeatures.swift | 5 + .../generated/ChildNameForDiagnostics.swift | 4 + .../SyntaxKindNameForDiagnostics.swift | 2 + .../generated/ChildNameForKeyPath.swift | 22 ++ Sources/SwiftSyntax/generated/Keyword.swift | 10 + .../generated/SyntaxAnyVisitor.swift | 10 + .../generated/SyntaxBaseNodes.swift | 4 +- .../SwiftSyntax/generated/SyntaxEnum.swift | 8 + .../SwiftSyntax/generated/SyntaxKind.swift | 4 + .../generated/SyntaxRewriter.swift | 17 ++ .../SwiftSyntax/generated/SyntaxVisitor.swift | 26 +++ .../generated/raw/RawSyntaxNodesGHI.swift | 107 +++++++++ .../generated/raw/RawSyntaxNodesTUVWXYZ.swift | 2 +- .../generated/raw/RawSyntaxValidation.swift | 16 ++ .../syntaxNodes/SyntaxNodesGHI.swift | 217 ++++++++++++++++++ 15 files changed, 452 insertions(+), 2 deletions(-) diff --git a/Sources/SwiftParser/generated/ExperimentalFeatures.swift b/Sources/SwiftParser/generated/ExperimentalFeatures.swift index 40d3939c216..e31d3628ee3 100644 --- a/Sources/SwiftParser/generated/ExperimentalFeatures.swift +++ b/Sources/SwiftParser/generated/ExperimentalFeatures.swift @@ -55,6 +55,9 @@ extension Parser.ExperimentalFeatures { /// Whether to enable the parsing of `_move` and `_borrow` as ownership operators. public static let oldOwnershipOperatorSpellings = Self (rawValue: 1 << 9) + /// Whether to enable the parsing of sugar type for InlineArray. + public static let inlineArrayTypeSugar = Self (rawValue: 1 << 10) + /// Creates a new value representing the experimental feature with the /// given name, or returns nil if the name is not recognized. public init?(name: String) { @@ -79,6 +82,8 @@ extension Parser.ExperimentalFeatures { self = .keypathWithMethodMembers case "OldOwnershipOperatorSpellings": self = .oldOwnershipOperatorSpellings + case "InlineArrayTypeSugar": + self = .inlineArrayTypeSugar default: return nil } diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift index 509f0933551..4a00dbace1f 100644 --- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift @@ -205,6 +205,10 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "function signature" case \InitializerDeclSyntax.genericWhereClause: return "generic where clause" + case \InlineArrayTypeSyntax.count: + return "count" + case \InlineArrayTypeSyntax.element: + return "element type" case \KeyPathExprSyntax.root: return "root" case \KeyPathMethodComponentSyntax.arguments: diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index c574a7f50ac..c0d1d7640b2 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -240,6 +240,8 @@ extension SyntaxKind { return "inherited type" case .initializerDecl: return "initializer" + case .inlineArrayType: + return "inline array type" case .integerLiteralExpr: return "integer literal" case .isExpr: diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index 28a410486d0..c2e22637f00 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -1898,6 +1898,28 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "body" case \InitializerDeclSyntax.unexpectedAfterBody: return "unexpectedAfterBody" + case \InlineArrayTypeSyntax.unexpectedBeforeLeftSquare: + return "unexpectedBeforeLeftSquare" + case \InlineArrayTypeSyntax.leftSquare: + return "leftSquare" + case \InlineArrayTypeSyntax.unexpectedBetweenLeftSquareAndCount: + return "unexpectedBetweenLeftSquareAndCount" + case \InlineArrayTypeSyntax.count: + return "count" + case \InlineArrayTypeSyntax.unexpectedBetweenCountAndSeparator: + return "unexpectedBetweenCountAndSeparator" + case \InlineArrayTypeSyntax.separator: + return "separator" + case \InlineArrayTypeSyntax.unexpectedBetweenSeparatorAndElement: + return "unexpectedBetweenSeparatorAndElement" + case \InlineArrayTypeSyntax.element: + return "element" + case \InlineArrayTypeSyntax.unexpectedBetweenElementAndRightSquare: + return "unexpectedBetweenElementAndRightSquare" + case \InlineArrayTypeSyntax.rightSquare: + return "rightSquare" + case \InlineArrayTypeSyntax.unexpectedAfterRightSquare: + return "unexpectedAfterRightSquare" case \IntegerLiteralExprSyntax.unexpectedBeforeLiteral: return "unexpectedBeforeLiteral" case \IntegerLiteralExprSyntax.literal: diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift index 7b85cc8e050..45fdc87921d 100644 --- a/Sources/SwiftSyntax/generated/Keyword.swift +++ b/Sources/SwiftSyntax/generated/Keyword.swift @@ -240,10 +240,19 @@ public enum Keyword: UInt8, Hashable, Sendable { case willSet case witness_method case wrt + @_spi(ExperimentalLanguageFeatures) + case x case yield @_spi(RawSyntax) public init?(_ text: SyntaxText) { switch text.count { + case 1: + switch text { + case "x": + self = .x + default: + return nil + } case 2: switch text { case "as": @@ -1034,6 +1043,7 @@ public enum Keyword: UInt8, Hashable, Sendable { "willSet", "witness_method", "wrt", + "x", "yield", ] diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 8db29e541a2..da2650dca59 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -1277,6 +1277,16 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + @_spi(ExperimentalLanguageFeatures) + override open func visit(_ node: InlineArrayTypeSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + @_spi(ExperimentalLanguageFeatures) + override open func visitPost(_ node: InlineArrayTypeSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index 4608af3c572..6740aafebce 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -1412,7 +1412,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public init?(_ node: __shared some SyntaxProtocol) { switch node.raw.kind { - case .arrayType, .attributedType, .classRestrictionType, .compositionType, .dictionaryType, .functionType, .identifierType, .implicitlyUnwrappedOptionalType, .memberType, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packElementType, .packExpansionType, .someOrAnyType, .suppressedType, .tupleType: + case .arrayType, .attributedType, .classRestrictionType, .compositionType, .dictionaryType, .functionType, .identifierType, .implicitlyUnwrappedOptionalType, .inlineArrayType, .memberType, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packElementType, .packExpansionType, .someOrAnyType, .suppressedType, .tupleType: self._syntaxNode = node._syntaxNode default: return nil @@ -1445,6 +1445,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable { .node(FunctionTypeSyntax.self), .node(IdentifierTypeSyntax.self), .node(ImplicitlyUnwrappedOptionalTypeSyntax.self), + .node(InlineArrayTypeSyntax.self), .node(MemberTypeSyntax.self), .node(MetatypeTypeSyntax.self), .node(MissingTypeSyntax.self), @@ -1661,6 +1662,7 @@ extension Syntax { .node(InheritedTypeSyntax.self), .node(InitializerClauseSyntax.self), .node(InitializerDeclSyntax.self), + .node(InlineArrayTypeSyntax.self), .node(IntegerLiteralExprSyntax.self), .node(IsExprSyntax.self), .node(IsTypePatternSyntax.self), diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index 25db44bdc3d..984dddcc7b4 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -173,6 +173,8 @@ public enum SyntaxEnum: Sendable { case inheritedType(InheritedTypeSyntax) case initializerClause(InitializerClauseSyntax) case initializerDecl(InitializerDeclSyntax) + @_spi(ExperimentalLanguageFeatures) + case inlineArrayType(InlineArrayTypeSyntax) case integerLiteralExpr(IntegerLiteralExprSyntax) case isExpr(IsExprSyntax) case isTypePattern(IsTypePatternSyntax) @@ -629,6 +631,8 @@ extension Syntax { return .initializerClause(InitializerClauseSyntax(self)!) case .initializerDecl: return .initializerDecl(InitializerDeclSyntax(self)!) + case .inlineArrayType: + return .inlineArrayType(InlineArrayTypeSyntax(self)!) case .integerLiteralExpr: return .integerLiteralExpr(IntegerLiteralExprSyntax(self)!) case .isExpr: @@ -1287,6 +1291,8 @@ public enum TypeSyntaxEnum { case functionType(FunctionTypeSyntax) case identifierType(IdentifierTypeSyntax) case implicitlyUnwrappedOptionalType(ImplicitlyUnwrappedOptionalTypeSyntax) + @_spi(ExperimentalLanguageFeatures) + case inlineArrayType(InlineArrayTypeSyntax) case memberType(MemberTypeSyntax) case metatypeType(MetatypeTypeSyntax) case missingType(MissingTypeSyntax) @@ -1319,6 +1325,8 @@ extension TypeSyntax { return .identifierType(IdentifierTypeSyntax(self)!) case .implicitlyUnwrappedOptionalType: return .implicitlyUnwrappedOptionalType(ImplicitlyUnwrappedOptionalTypeSyntax(self)!) + case .inlineArrayType: + return .inlineArrayType(InlineArrayTypeSyntax(self)!) case .memberType: return .memberType(MemberTypeSyntax(self)!) case .metatypeType: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index 249a40a682e..1d086690f59 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -173,6 +173,8 @@ public enum SyntaxKind: Sendable { case inheritedType case initializerClause case initializerDecl + @_spi(ExperimentalLanguageFeatures) + case inlineArrayType case integerLiteralExpr case isExpr case isTypePattern @@ -754,6 +756,8 @@ public enum SyntaxKind: Sendable { return InitializerClauseSyntax.self case .initializerDecl: return InitializerDeclSyntax.self + case .inlineArrayType: + return InlineArrayTypeSyntax.self case .integerLiteralExpr: return IntegerLiteralExprSyntax.self case .isExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index 362b068ba55..b5d5791640e 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -1162,6 +1162,14 @@ open class SyntaxRewriter { return DeclSyntax(InitializerDeclSyntax(unsafeCasting: visitChildren(node._syntaxNode))) } + /// Visit a `InlineArrayTypeSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + @_spi(ExperimentalLanguageFeatures) + open func visit(_ node: InlineArrayTypeSyntax) -> TypeSyntax { + return TypeSyntax(InlineArrayTypeSyntax(unsafeCasting: visitChildren(node._syntaxNode))) + } + /// Visit a ``IntegerLiteralExprSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -2943,6 +2951,11 @@ open class SyntaxRewriter { Syntax(visit(InitializerDeclSyntax(unsafeCasting: node))) } + @inline(never) + private func visitInlineArrayTypeSyntaxImpl(_ node: Syntax) -> Syntax { + Syntax(visit(InlineArrayTypeSyntax(unsafeCasting: node))) + } + @inline(never) private func visitIntegerLiteralExprSyntaxImpl(_ node: Syntax) -> Syntax { Syntax(visit(IntegerLiteralExprSyntax(unsafeCasting: node))) @@ -3973,6 +3986,8 @@ open class SyntaxRewriter { return self.visitInitializerClauseSyntaxImpl(_:) case .initializerDecl: return self.visitInitializerDeclSyntaxImpl(_:) + case .inlineArrayType: + return self.visitInlineArrayTypeSyntaxImpl(_:) case .integerLiteralExpr: return self.visitIntegerLiteralExprSyntaxImpl(_:) case .isExpr: @@ -4565,6 +4580,8 @@ open class SyntaxRewriter { return visitInitializerClauseSyntaxImpl(node) case .initializerDecl: return visitInitializerDeclSyntaxImpl(node) + case .inlineArrayType: + return visitInlineArrayTypeSyntaxImpl(node) case .integerLiteralExpr: return visitIntegerLiteralExprSyntaxImpl(node) case .isExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index f6e7cceff9b..c79186d1797 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -1859,6 +1859,20 @@ open class SyntaxVisitor { open func visitPost(_ node: InitializerDeclSyntax) { } + /// Visiting `InlineArrayTypeSyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + @_spi(ExperimentalLanguageFeatures) + open func visit(_ node: InlineArrayTypeSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `InlineArrayTypeSyntax` and its descendants. + /// - node: the node we just finished visiting. + @_spi(ExperimentalLanguageFeatures) + open func visitPost(_ node: InlineArrayTypeSyntax) { + } + /// Visiting ``IntegerLiteralExprSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -4778,6 +4792,14 @@ open class SyntaxVisitor { visitPost(InitializerDeclSyntax(unsafeCasting: node)) } + @inline(never) + private func visitInlineArrayTypeSyntaxImpl(_ node: Syntax) { + if visit(InlineArrayTypeSyntax(unsafeCasting: node)) == .visitChildren { + visitChildren(node) + } + visitPost(InlineArrayTypeSyntax(unsafeCasting: node)) + } + @inline(never) private func visitIntegerLiteralExprSyntaxImpl(_ node: Syntax) { if visit(IntegerLiteralExprSyntax(unsafeCasting: node)) == .visitChildren { @@ -6228,6 +6250,8 @@ open class SyntaxVisitor { return self.visitInitializerClauseSyntaxImpl(_:) case .initializerDecl: return self.visitInitializerDeclSyntaxImpl(_:) + case .inlineArrayType: + return self.visitInlineArrayTypeSyntaxImpl(_:) case .integerLiteralExpr: return self.visitIntegerLiteralExprSyntaxImpl(_:) case .isExpr: @@ -6820,6 +6844,8 @@ open class SyntaxVisitor { self.visitInitializerClauseSyntaxImpl(node) case .initializerDecl: self.visitInitializerDeclSyntaxImpl(node) + case .inlineArrayType: + self.visitInlineArrayTypeSyntaxImpl(node) case .integerLiteralExpr: self.visitIntegerLiteralExprSyntaxImpl(node) case .isExpr: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesGHI.swift index 0d7cdbbd7b0..e9a35bc50ac 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesGHI.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesGHI.swift @@ -2347,6 +2347,113 @@ public struct RawInitializerDeclSyntax: RawDeclSyntaxNodeProtocol { } } +@_spi(ExperimentalLanguageFeatures) +@_spi(RawSyntax) +public struct RawInlineArrayTypeSyntax: RawTypeSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .inlineArrayType + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? = nil, + leftSquare: RawTokenSyntax, + _ unexpectedBetweenLeftSquareAndCount: RawUnexpectedNodesSyntax? = nil, + count: RawGenericArgumentSyntax, + _ unexpectedBetweenCountAndSeparator: RawUnexpectedNodesSyntax? = nil, + separator: RawTokenSyntax, + _ unexpectedBetweenSeparatorAndElement: RawUnexpectedNodesSyntax? = nil, + element: RawGenericArgumentSyntax, + _ unexpectedBetweenElementAndRightSquare: RawUnexpectedNodesSyntax? = nil, + rightSquare: RawTokenSyntax, + _ unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? = nil, + arena: __shared RawSyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .inlineArrayType, uninitializedCount: 11, arena: arena) { layout in + layout.initialize(repeating: nil) + layout[0] = unexpectedBeforeLeftSquare?.raw + layout[1] = leftSquare.raw + layout[2] = unexpectedBetweenLeftSquareAndCount?.raw + layout[3] = count.raw + layout[4] = unexpectedBetweenCountAndSeparator?.raw + layout[5] = separator.raw + layout[6] = unexpectedBetweenSeparatorAndElement?.raw + layout[7] = element.raw + layout[8] = unexpectedBetweenElementAndRightSquare?.raw + layout[9] = rightSquare.raw + layout[10] = unexpectedAfterRightSquare?.raw + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeLeftSquare: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var leftSquare: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenLeftSquareAndCount: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var count: RawGenericArgumentSyntax { + layoutView.children[3].map(RawGenericArgumentSyntax.init(raw:))! + } + + public var unexpectedBetweenCountAndSeparator: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var separator: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenSeparatorAndElement: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var element: RawGenericArgumentSyntax { + layoutView.children[7].map(RawGenericArgumentSyntax.init(raw:))! + } + + public var unexpectedBetweenElementAndRightSquare: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var rightSquare: RawTokenSyntax { + layoutView.children[9].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterRightSquare: RawUnexpectedNodesSyntax? { + layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawIntegerLiteralExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift index 93d810ff8b0..f8bba4db167 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift @@ -1498,7 +1498,7 @@ public struct RawTypeSyntax: RawTypeSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .arrayType, .attributedType, .classRestrictionType, .compositionType, .dictionaryType, .functionType, .identifierType, .implicitlyUnwrappedOptionalType, .memberType, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packElementType, .packExpansionType, .someOrAnyType, .suppressedType, .tupleType: + case .arrayType, .attributedType, .classRestrictionType, .compositionType, .dictionaryType, .functionType, .identifierType, .implicitlyUnwrappedOptionalType, .inlineArrayType, .memberType, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packElementType, .packExpansionType, .someOrAnyType, .suppressedType, .tupleType: return true default: return false diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 8d385656a8d..bdd1fdc99ad 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -1775,6 +1775,20 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 15, verify(layout[15], as: RawCodeBlockSyntax?.self)) assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) } + func validateInlineArrayTypeSyntax(kind: SyntaxKind, layout: RawSyntaxBuffer) { + assert(layout.count == 11) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftSquare)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawGenericArgumentSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.keyword("x")])) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawGenericArgumentSyntax.self)) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightSquare)])) + assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self)) + } func validateIntegerLiteralExprSyntax(kind: SyntaxKind, layout: RawSyntaxBuffer) { assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -3464,6 +3478,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { validateInitializerClauseSyntax(kind: kind, layout: layout) case .initializerDecl: validateInitializerDeclSyntax(kind: kind, layout: layout) + case .inlineArrayType: + validateInlineArrayTypeSyntax(kind: kind, layout: layout) case .integerLiteralExpr: validateIntegerLiteralExprSyntax(kind: kind, layout: layout) case .isExpr: diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift index a44e3dee26f..b8daf36f8cf 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift @@ -4376,6 +4376,223 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDe ]) } +// MARK: - InlineArrayTypeSyntax + +/// An inline array type `[3 x Int]`, sugar for `InlineArray<3, Int>`. +/// +/// - Note: Requires experimental feature `inlineArrayTypeSugar`. +/// +/// ### Children +/// +/// - `leftSquare`: `[` +/// - `count`: ``GenericArgumentSyntax`` +/// - `separator`: `x` +/// - `element`: ``GenericArgumentSyntax`` +/// - `rightSquare`: `]` +@_spi(ExperimentalLanguageFeatures) +public struct InlineArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: __shared some SyntaxProtocol) { + guard node.raw.kind == .inlineArrayType else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + @_transparent + init(unsafeCasting node: Syntax) { + self._syntaxNode = node + } + + /// - Parameters: + /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + /// - count: The `count` argument for the inline array type. + /// - element: The `element` argument for the inline array type. + /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. + public init( + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax = .leftSquareToken(), + _ unexpectedBetweenLeftSquareAndCount: UnexpectedNodesSyntax? = nil, + count: GenericArgumentSyntax, + _ unexpectedBetweenCountAndSeparator: UnexpectedNodesSyntax? = nil, + separator: TokenSyntax = .keyword(.x), + _ unexpectedBetweenSeparatorAndElement: UnexpectedNodesSyntax? = nil, + element: GenericArgumentSyntax, + _ unexpectedBetweenElementAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax = .rightSquareToken(), + _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + // Extend the lifetime of all parameters so their arenas don't get destroyed + // before they can be added as children of the new arena. + self = withExtendedLifetime((RawSyntaxArena(), ( + unexpectedBeforeLeftSquare, + leftSquare, + unexpectedBetweenLeftSquareAndCount, + count, + unexpectedBetweenCountAndSeparator, + separator, + unexpectedBetweenSeparatorAndElement, + element, + unexpectedBetweenElementAndRightSquare, + rightSquare, + unexpectedAfterRightSquare + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeLeftSquare?.raw, + leftSquare.raw, + unexpectedBetweenLeftSquareAndCount?.raw, + count.raw, + unexpectedBetweenCountAndSeparator?.raw, + separator.raw, + unexpectedBetweenSeparatorAndElement?.raw, + element.raw, + unexpectedBetweenElementAndRightSquare?.raw, + rightSquare.raw, + unexpectedAfterRightSquare?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.inlineArrayType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `[`. + public var leftSquare: TokenSyntax { + get { + return Syntax(self).child(at: 1)!.cast(TokenSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + public var unexpectedBetweenLeftSquareAndCount: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + /// The `count` argument for the inline array type. + /// + /// - Note: In semantically valid Swift code, this is always an integer or a wildcard type, e.g `_` in `[_ x Int]`. + public var count: GenericArgumentSyntax { + get { + return Syntax(self).child(at: 3)!.cast(GenericArgumentSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + public var unexpectedBetweenCountAndSeparator: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `x`. + public var separator: TokenSyntax { + get { + return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + public var unexpectedBetweenSeparatorAndElement: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + /// The `element` argument for the inline array type. + /// + /// - Note: In semantically valid Swift code, this is always a type. + public var element: GenericArgumentSyntax { + get { + return Syntax(self).child(at: 7)!.cast(GenericArgumentSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + public var unexpectedBetweenElementAndRightSquare: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `]`. + public var rightSquare: TokenSyntax { + get { + return Syntax(self).child(at: 9)!.cast(TokenSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 9, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + public var unexpectedAfterRightSquare: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 10, with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(InlineArrayTypeSyntax.self) + } + } + + public static let structure: SyntaxNodeStructure = .layout([ + \Self.unexpectedBeforeLeftSquare, + \Self.leftSquare, + \Self.unexpectedBetweenLeftSquareAndCount, + \Self.count, + \Self.unexpectedBetweenCountAndSeparator, + \Self.separator, + \Self.unexpectedBetweenSeparatorAndElement, + \Self.element, + \Self.unexpectedBetweenElementAndRightSquare, + \Self.rightSquare, + \Self.unexpectedAfterRightSquare + ]) +} + // MARK: - IntegerLiteralExprSyntax /// ### Children