swiftlang · airspeedswift · Mar 23, 2025 · Mar 18, 2025 · Mar 18, 2025 · Mar 18, 2025
@@ -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"
     }
   }
 

@@ -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")
     }

@@ -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

@@ -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,

@@ -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')"
+        ),
       ]
     )
   }

@@ -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(

@@ -362,6 +362,7 @@ enum TokenPrecedence: Comparable {
       .weak,
       .witness_method,
       .wrt,
+      .x,
       .unsafe:
       self = .exprKeyword
     #if RESILIENT_LIBRARIES

@@ -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,10 +636,46 @@ 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 {
   mutating func canParseType() -> Bool {
+    // 'repeat' starts a pack expansion type
+    self.consume(if: .keyword(.repeat))
+
     guard self.canParseTypeScalar() else {
       return false
     }
@@ -656,9 +706,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 {
@@ -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 '[<type-or-integer> 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)
     }