Parse InlineArray type sugar

Parse e.g `[3 x Int]` as type sugar for InlineArray. Gated behind
an experimental feature flag for now.

Author: hamishknight

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

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

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

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,

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

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(

Sources/SwiftParser/TokenPrecedence.swift

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

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 '[<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)
     }

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<T> 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
+      )
+    }
+  }
 }