Parse an ellipsis T... for type parameter packs

In a generic parameter list, parse an ellipsis
to produce a type parameter pack. This replaces
the previous `@_typeSequence` attribute.

Author: hamishknight

Sources/SwiftParser/Declarations.swift

@@ -313,6 +313,20 @@ extension Parser {
 }
 
 extension Parser {
+  /// Attempt to consume an ellipsis prefix, splitting the current token if
+  /// necessary.
+  mutating func tryConsumeEllipsisPrefix() -> RawTokenSyntax? {
+    // It is not sufficient to check currentToken.isEllipsis here, as we may
+    // have something like '...>'.
+    // TODO: Recovery for different numbers of dots (which also needs to be
+    // done for regular variadics).
+    guard self.at(anyIn: Operator.self) != nil else { return nil }
+    let text = self.currentToken.tokenText
+    guard text.hasPrefix("...") else { return nil }
+    return self.consumePrefix(
+      SyntaxText(rebasing: text.prefix(3)), as: .ellipsis)
+  }
+
   @_spi(RawSyntax)
   public mutating func parseGenericParameters() -> RawGenericParameterClauseSyntax {
     assert(self.currentToken.starts(with: "<"))
@@ -330,6 +344,9 @@ extension Parser {
           break
         }
 
+        // Parse the ellipsis for a type parameter pack  'T...'.
+        let ellipsis = tryConsumeEllipsisPrefix()
+
         // Parse the ':' followed by a type.
         let colon = self.consume(if: .colon)
         let inherited: RawTypeSyntax?
@@ -347,6 +364,7 @@ extension Parser {
           attributes: attributes,
           unexpectedBeforeName,
           name: name,
+          ellipsis: ellipsis,
           colon: colon,
           inheritedType: inherited,
           trailingComma: keepGoing,
@@ -1102,6 +1120,13 @@ extension Parser {
         arena: self.arena)
     }
 
+    // Detect an attempt to use a type parameter pack.
+    var unexpectedAfterName: RawUnexpectedNodesSyntax?
+    if let ellipsis = tryConsumeEllipsisPrefix() {
+      unexpectedAfterName = RawUnexpectedNodesSyntax(
+        elements: [RawSyntax(ellipsis)], arena: self.arena)
+    }
+
     // Parse optional inheritance clause.
     let inheritance: RawTypeInheritanceClauseSyntax?
     if self.at(.colon) {
@@ -1137,6 +1162,7 @@ extension Parser {
       associatedtypeKeyword: assocKeyword,
       unexpectedBeforeName,
       identifier: name,
+      unexpectedAfterName,
       inheritanceClause: inheritance,
       initializer: defaultType,
       genericWhereClause: whereClause,

Sources/SwiftParser/Diagnostics/ParseDiagnosticsGenerator.swift

@@ -145,6 +145,29 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     addDiagnostic(incorrectContainer, message(misplacedTokens), fixIts: fixIts, handledNodes: [incorrectContainer.id] + correctAndMissingTokens.map(\.id))
   }
 
+  /// Utility function to remove a misplaced token with a custom error message.
+  public func removeToken(
+    _ unexpected: UnexpectedNodesSyntax?,
+    where predicate: (TokenSyntax) -> Bool,
+    message: (TokenSyntax) -> DiagnosticMessage
+  ) {
+    guard let unexpected = unexpected,
+          let misplacedToken = unexpected.onlyToken(where: predicate)
+    else {
+      // If there is no unexpected node or the unexpected doesn't have the
+      // expected token, don't emit a diagnostic.
+      return
+    }
+    let fixit = FixIt(
+      message: RemoveNodesFixIt(unexpected),
+      changes: [.remove(unexpected: unexpected)]
+    )
+    addDiagnostic(
+      unexpected, message(misplacedToken), fixIts: [fixit],
+      handledNodes: [unexpected.id]
+    )
+  }
+
   // MARK: - Generic diagnostic generation
 
   public override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind {
@@ -563,6 +586,20 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: AssociatedtypeDeclSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    // Emit a custom diagnostic for an unexpected '...' after an associatedtype
+    // name.
+    removeToken(
+      node.unexpectedBetweenIdentifierAndInheritanceClause,
+      where: { $0.tokenKind == .ellipsis },
+      message: { _ in StaticParserError.associatedTypeCannotUsePack }
+    )
+    return .visitChildren
+  }
+
   public override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift

@@ -85,6 +85,7 @@ public enum StaticParserError: String, DiagnosticMessage {
   case tryMustBePlacedOnThrownExpr = "'try' must be placed on the thrown expression"
   case tryOnInitialValueExpression = "'try' must be placed on the initial value expression"
   case unexpectedSemicolon = "unexpected ';' separator"
+  case associatedTypeCannotUsePack = "associated types may not use type parameter packs"
 
   public var message: String { self.rawValue }
 

Sources/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -185,8 +185,8 @@ public enum SyntaxFactory {
   @available(*, deprecated, message: "Use initializer on GenericParameterSyntax")
   public static func makeGenericParameter(name: TokenSyntax,
       trailingComma: TokenSyntax) -> GenericParameterSyntax {
-    return makeGenericParameter(attributes: nil, name: name, colon: nil,
-                                inheritedType: nil,
+    return makeGenericParameter(attributes: nil, name: name, ellipsis: nil,
+                                colon: nil, inheritedType: nil,
                                 trailingComma: trailingComma)
   }
 

Tests/SwiftParserTest/Types.swift

@@ -169,24 +169,187 @@ final class TypeTests: XCTestCase {
       }
       """)
   }
+}
 
-  func testPackExpansion() throws {
+final class TypeParameterPackTests: XCTestCase {
+  func testParameterPacks1() throws {
     AssertParse(
       """
-      func f1<@_typeSequence T>() -> T... {}
-      func f2<@_typeSequence T>() -> (T...) {}
-      func f3<@_typeSequence T>() -> G<T... > {}
+      func f1<T...>() -> T... {}
       """)
-
+  }
+  func testParameterPacks2() throws {
+    AssertParse(
+      """
+      func f2<T...>() -> (T...) {}
+      """)
+  }
+  func testParameterPacks3() throws {
+    AssertParse(
+      """
+      func f3<T...>() -> G<T... > {}
+      """)
+  }
+  func testParameterPacks4() throws {
+    AssertParse(
+      """
+      protocol P {
+        associatedtype T1️⃣...
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "associated types may not use type parameter packs",
+                       fixIts: ["remove '...'"])
+      ])
+  }
+  func testParameterPacks5() throws {
+    AssertParse(
+    """
+    typealias Alias<T...> = (T...)
+    """)
+  }
+  func testParameterPacks6() throws {
+    AssertParse(
+      """
+      struct S<T...> {}
+      """)
+  }
+  func testParameterPacks7() throws {
+    AssertParse(
+      """
+      struct S<T, U...> {}
+      """)
+  }
+  func testParameterPacks8() throws {
+    AssertParse(
+      """
+      struct S<T..., U> {}
+      """)
+  }
+  func testParameterPacks9() throws {
+    AssertParse(
+      """
+      struct S<T...:P, U> {}
+      """)
+  }
+  func testParameterPacks10() throws {
+    AssertParse(
+      """
+      struct S<T... :P, U> {}
+      """)
+  }
+  func testParameterPacks11() throws {
+    AssertParse(
+      """
+      struct S<T...: P> {}
+      """)
+  }
+  func testParameterPacks12() throws {
+    AssertParse(
+      """
+      struct S<T... : P> {}
+      """)
+  }
+  func testParameterPacks13() throws {
+    AssertParse(
+      """
+      func foo<T...>(_ x: T...) {}
+      """)
+  }
+  func testParameterPacks14() throws {
+    AssertParse(
+      """
+      func foo<T...:P>(_ x: T...) {}
+      """)
+  }
+  func testParameterPacks15() throws {
     AssertParse(
       """
-      enum E<@_typeSequence T> {
+      func foo<T... :P>(_ x: T...) {}
+      """)
+  }
+  func testParameterPacks16() throws {
+    AssertParse(
+      """
+      func foo<T... : P>(_ x: T...) {}
+      """)
+  }
+  func testParameterPacks17() throws {
+    AssertParse(
+      """
+      func foo<T...: P>(_ x: T...) {}
+      """)
+  }
+  func testParameterPacks18() throws {
+    AssertParse(
+      """
+      func foo<T, U, V...>(x: T, y: U, z: V...) { }
+      """)
+  }
+  func testParameterPacks19() throws {
+    AssertParse(
+      """
+      func foo<T, U..., V>(x: T, y: U..., z: V) { }
+      """)
+  }
+  func testParameterPacks20() throws {
+    AssertParse(
+      """
+      func foo<T..., U..., V...>(x: T..., y: U..., z: V...) { }
+      """)
+  }
+  func testParameterPacks21() throws {
+    AssertParse(
+      """
+      enum E<T...> {
         case f1(_: T...)
+      }
+      """)
+  }
+  func testParameterPacks22() throws {
+    AssertParse(
+      """
+      enum E<T...> {
         case f2(_: G<T... >)
+      }
+      """)
+  }
+  func testParameterPacks23() throws {
+    AssertParse(
+      """
+      enum E<T...> {
         var x: T... { fatalError() }
+      }
+      """)
+  }
+  func testParameterPacks24() throws {
+    AssertParse(
+      """
+      enum E<T...> {
         var x: (T...) { fatalError() }
+      }
+      """)
+  }
+  func testParameterPacks25() throws {
+    AssertParse(
+      """
+      enum E<T...> {
         subscript(_: T...) -> Int { fatalError() }
+      }
+      """)
+  }
+  func testParameterPacks26() throws {
+    AssertParse(
+      """
+      enum E<T...> {
         subscript() -> T... { fatalError() }
+      }
+      """)
+  }
+  func testParameterPacks27() throws {
+    AssertParse(
+      """
+      enum E<T...> {
         subscript() -> (T...) { fatalError() }
       }
       """)

gyb_syntax_support/GenericNodes.py

@@ -76,6 +76,9 @@
              Child('Attributes', kind='AttributeList',
                    collection_element_name='Attribute', is_optional=True),
              Child('Name', name_for_diagnostics='name', kind='IdentifierToken'),
+             Child('Ellipsis',
+                   name_for_diagnostics='parameter pack specifier',
+                   kind='EllipsisToken', is_optional=True),
              Child('Colon', kind='ColonToken',
                    is_optional=True),
              Child('InheritedType', name_for_diagnostics='inherited type', kind='Type',