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,18 @@ 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 '...>'.
+    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 +342,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 +362,7 @@ extension Parser {
           attributes: attributes,
           unexpectedBeforeName,
           name: name,
+          ellipsis: ellipsis,
           colon: colon,
           inheritedType: inherited,
           trailingComma: keepGoing,
@@ -1102,6 +1118,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 +1160,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 AssociatedTypeCannotUsePack() }
+    )
+    return .visitChildren
+  }
+
   public override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift

@@ -97,6 +97,12 @@ public enum StaticParserError: String, DiagnosticMessage {
 
 // MARK: - Diagnostics (please sort alphabetically)
 
+public struct AssociatedTypeCannotUsePack: ParserError {
+  public var message: String {
+    "associated types may not use type parameter packs"
+  }
+}
+
 public struct EffectsSpecifierAfterArrow: ParserError {
   public let effectsSpecifiersAfterArrow: [TokenSyntax]
 

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

@@ -173,14 +173,49 @@ final class TypeTests: XCTestCase {
   func testPackExpansion() throws {
     AssertParse(
       """
-      func f1<@_typeSequence T>() -> T... {}
-      func f2<@_typeSequence T>() -> (T...) {}
-      func f3<@_typeSequence T>() -> G<T... > {}
+      func f1<T...>() -> T... {}
+      func f2<T...>() -> (T...) {}
+      func f3<T...>() -> G<T... > {}
       """)
 
     AssertParse(
       """
-      enum E<@_typeSequence T> {
+      protocol P {
+        associatedtype T1️⃣...
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "associated types may not use type parameter packs",
+                       fixIts: ["remove '...'"])
+      ])
+
+    AssertParse(
+    """
+    typealias Alias<T...> = (T...)
+
+    struct S1<T...> {}
+    struct S2<T, U...> {}
+    struct S3<T..., U> {}
+    struct S4<T...:P, U> {}
+    struct S5<T... :P, U> {}
+    struct S6<T...: P> {}
+    struct S7<T... : P> {}
+
+    func foo<T...>(_ x: T...) {}
+
+    func bar<T...:P>(_ x: T...) {}
+    func baz<T... :P>(_ x: T...) {}
+    func qux<T... : P>(_ x: T...) {}
+    func quux<T...: P>(_ x: T...) {}
+
+    func foobar<T, U, V...>(x: T, y: U, z: V...) { }
+    func foobaz<T, U..., V>(x: T, y: U..., z: V) { }
+    func fooqux<T..., U..., V...>(x: T..., y: U..., z: V...) { }
+    """)
+
+    AssertParse(
+      """
+      enum E<T...> {
         case f1(_: T...)
         case f2(_: G<T... >)
         var x: 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',