Parse an ellipsis T... for type parameter packs

CodeGeneration/Sources/SyntaxSupport/gyb_generated/GenericNodes.swift

@@ -145,6 +145,12 @@ public let GENERIC_NODES: [Node] = [
                tokenChoices: [
                  "Identifier"
                ]),
+         Child(name: "Ellipsis",
+               kind: "EllipsisToken",
+               isOptional: true,
+               tokenChoices: [
+                 "Ellipsis"
+               ]),
          Child(name: "Colon",
                kind: "ColonToken",
                isOptional: true,

Sources/SwiftBasicFormat/generated/BasicFormat.swift

@@ -2304,13 +2304,15 @@ open class BasicFormat: SyntaxRewriter {
     let attributes = node.attributes.map(self.visit)?.cast(AttributeListSyntax.self)
     let unexpectedBetweenAttributesAndName = node.unexpectedBetweenAttributesAndName.map(self.visit)?.cast(UnexpectedNodesSyntax.self)
     let name = self.visit(node.name).cast(TokenSyntax.self)
-    let unexpectedBetweenNameAndColon = node.unexpectedBetweenNameAndColon.map(self.visit)?.cast(UnexpectedNodesSyntax.self)
+    let unexpectedBetweenNameAndEllipsis = node.unexpectedBetweenNameAndEllipsis.map(self.visit)?.cast(UnexpectedNodesSyntax.self)
+    let ellipsis = node.ellipsis.map(self.visit)?.cast(TokenSyntax.self)
+    let unexpectedBetweenEllipsisAndColon = node.unexpectedBetweenEllipsisAndColon.map(self.visit)?.cast(UnexpectedNodesSyntax.self)
     let colon = node.colon.map(self.visit)?.cast(TokenSyntax.self)
     let unexpectedBetweenColonAndInheritedType = node.unexpectedBetweenColonAndInheritedType.map(self.visit)?.cast(UnexpectedNodesSyntax.self)
     let inheritedType = node.inheritedType.map(self.visit)?.cast(TypeSyntax.self)
     let unexpectedBetweenInheritedTypeAndTrailingComma = node.unexpectedBetweenInheritedTypeAndTrailingComma.map(self.visit)?.cast(UnexpectedNodesSyntax.self)
     let trailingComma = node.trailingComma.map(self.visit)?.cast(TokenSyntax.self)
-    return Syntax(GenericParameterSyntax(unexpectedBeforeAttributes, attributes: attributes, unexpectedBetweenAttributesAndName, name: name, unexpectedBetweenNameAndColon, colon: colon, unexpectedBetweenColonAndInheritedType, inheritedType: inheritedType, unexpectedBetweenInheritedTypeAndTrailingComma, trailingComma: trailingComma))
+    return Syntax(GenericParameterSyntax(unexpectedBeforeAttributes, attributes: attributes, unexpectedBetweenAttributesAndName, name: name, unexpectedBetweenNameAndEllipsis, ellipsis: ellipsis, unexpectedBetweenEllipsisAndColon, colon: colon, unexpectedBetweenColonAndInheritedType, inheritedType: inheritedType, unexpectedBetweenInheritedTypeAndTrailingComma, trailingComma: trailingComma))
   }
 
   open override func visit(_ node: PrimaryAssociatedTypeListSyntax) -> Syntax {

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 cannot be variadic"
 
   public var message: String { self.rawValue }
 

Sources/SwiftParser/Lookahead.swift

@@ -250,7 +250,6 @@ extension Parser.Lookahead {
     "async",
     "Sendable",
     "unchecked",
-    "_typeSequence",
     "_local",
     "block_storage",
     "box",

Sources/SwiftParser/gyb_generated/DeclarationAttribute.swift

@@ -63,7 +63,6 @@ extension Parser {
     case _objcRuntimeName = "_objcRuntimeName"
     case _staticInitializeObjCMetadata = "_staticInitializeObjCMetadata"
     case _restatedObjCConformance = "_restatedObjCConformance"
-    case _typeSequence = "_typeSequence"
     case _optimize = "_optimize"
     case _clangImporterSynthesizedType = "_clangImporterSynthesizedType"
     case _weakLinked = "_weakLinked"

Sources/SwiftParser/gyb_generated/TypeAttribute.swift

@@ -25,7 +25,6 @@ extension Parser {
     case async = "async"
     case Sendable = "Sendable"
     case unchecked = "unchecked"
-    case _typeSequence = "_typeSequence"
     case _local = "_local"
     case _noMetadata = "_noMetadata"
     case _opaqueReturnTypeOf = "_opaqueReturnTypeOf"

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -19427,7 +19427,9 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol, RawSyntaxToSynta
     attributes: RawAttributeListSyntax?,
     _ unexpectedBetweenAttributesAndName: RawUnexpectedNodesSyntax? = nil,
     name: RawTokenSyntax,
-    _ unexpectedBetweenNameAndColon: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedBetweenNameAndEllipsis: RawUnexpectedNodesSyntax? = nil,
+    ellipsis: RawTokenSyntax?,
+    _ unexpectedBetweenEllipsisAndColon: RawUnexpectedNodesSyntax? = nil,
     colon: RawTokenSyntax?,
     _ unexpectedBetweenColonAndInheritedType: RawUnexpectedNodesSyntax? = nil,
     inheritedType: RawTypeSyntax?,
@@ -19437,19 +19439,21 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol, RawSyntaxToSynta
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .genericParameter, uninitializedCount: 11, arena: arena) { layout in
+      kind: .genericParameter, uninitializedCount: 13, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes?.raw
       layout[2] = unexpectedBetweenAttributesAndName?.raw
       layout[3] = name.raw
-      layout[4] = unexpectedBetweenNameAndColon?.raw
-      layout[5] = colon?.raw
-      layout[6] = unexpectedBetweenColonAndInheritedType?.raw
-      layout[7] = inheritedType?.raw
-      layout[8] = unexpectedBetweenInheritedTypeAndTrailingComma?.raw
-      layout[9] = trailingComma?.raw
-      layout[10] = unexpectedAfterTrailingComma?.raw
+      layout[4] = unexpectedBetweenNameAndEllipsis?.raw
+      layout[5] = ellipsis?.raw
+      layout[6] = unexpectedBetweenEllipsisAndColon?.raw
+      layout[7] = colon?.raw
+      layout[8] = unexpectedBetweenColonAndInheritedType?.raw
+      layout[9] = inheritedType?.raw
+      layout[10] = unexpectedBetweenInheritedTypeAndTrailingComma?.raw
+      layout[11] = trailingComma?.raw
+      layout[12] = unexpectedAfterTrailingComma?.raw
     }
     self.init(raw: raw)
   }
@@ -19478,47 +19482,59 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol, RawSyntaxToSynta
   public func withName(_ name: RawTokenSyntax, arena: SyntaxArena) -> RawGenericParameterSyntax {
     return layoutView.replacingChild(at: 3, with: RawSyntax(name), arena: arena).as(RawGenericParameterSyntax.self)!
   }
-  public var unexpectedBetweenNameAndColon: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenNameAndEllipsis: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-  public func withUnexpectedBetweenNameAndColon(_ unexpectedBetweenNameAndColon: RawUnexpectedNodesSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
-    return layoutView.replacingChild(at: 4, with: unexpectedBetweenNameAndColon.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+  public func withUnexpectedBetweenNameAndEllipsis(_ unexpectedBetweenNameAndEllipsis: RawUnexpectedNodesSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
+    return layoutView.replacingChild(at: 4, with: unexpectedBetweenNameAndEllipsis.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
   }
-  public var colon: RawTokenSyntax? {
+  public var ellipsis: RawTokenSyntax? {
     layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
+  public func withEllipsis(_ ellipsis: RawTokenSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
+    return layoutView.replacingChild(at: 5, with: ellipsis.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+  }
+  public var unexpectedBetweenEllipsisAndColon: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public func withUnexpectedBetweenEllipsisAndColon(_ unexpectedBetweenEllipsisAndColon: RawUnexpectedNodesSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
+    return layoutView.replacingChild(at: 6, with: unexpectedBetweenEllipsisAndColon.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+  }
+  public var colon: RawTokenSyntax? {
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
+  }
   public func withColon(_ colon: RawTokenSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
-    return layoutView.replacingChild(at: 5, with: colon.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+    return layoutView.replacingChild(at: 7, with: colon.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
   }
   public var unexpectedBetweenColonAndInheritedType: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   public func withUnexpectedBetweenColonAndInheritedType(_ unexpectedBetweenColonAndInheritedType: RawUnexpectedNodesSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
-    return layoutView.replacingChild(at: 6, with: unexpectedBetweenColonAndInheritedType.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+    return layoutView.replacingChild(at: 8, with: unexpectedBetweenColonAndInheritedType.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
   }
   public var inheritedType: RawTypeSyntax? {
-    layoutView.children[7].map(RawTypeSyntax.init(raw:))
+    layoutView.children[9].map(RawTypeSyntax.init(raw:))
   }
   public func withInheritedType(_ inheritedType: RawTypeSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
-    return layoutView.replacingChild(at: 7, with: inheritedType.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+    return layoutView.replacingChild(at: 9, with: inheritedType.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
   }
   public var unexpectedBetweenInheritedTypeAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   public func withUnexpectedBetweenInheritedTypeAndTrailingComma(_ unexpectedBetweenInheritedTypeAndTrailingComma: RawUnexpectedNodesSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
-    return layoutView.replacingChild(at: 8, with: unexpectedBetweenInheritedTypeAndTrailingComma.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+    return layoutView.replacingChild(at: 10, with: unexpectedBetweenInheritedTypeAndTrailingComma.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
   }
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw:))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
   public func withTrailingComma(_ trailingComma: RawTokenSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
-    return layoutView.replacingChild(at: 9, with: trailingComma.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+    return layoutView.replacingChild(at: 11, with: trailingComma.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
   }
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   public func withUnexpectedAfterTrailingComma(_ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax?, arena: SyntaxArena) -> RawGenericParameterSyntax {
-    return layoutView.replacingChild(at: 10, with: unexpectedAfterTrailingComma.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
+    return layoutView.replacingChild(at: 12, with: unexpectedAfterTrailingComma.map(RawSyntax.init), arena: arena).as(RawGenericParameterSyntax.self)!
   }
 }
 

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -2175,18 +2175,20 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     }
     break
   case .genericParameter:
-    assert(layout.count == 11)
+    assert(layout.count == 13)
     _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[1], as: RawAttributeListSyntax?.self)
     _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[3], as: RawTokenSyntax.self)
     _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[5], as: RawTokenSyntax?.self)
     _verify(layout[6], as: RawUnexpectedNodesSyntax?.self)
-    _verify(layout[7], as: RawTypeSyntax?.self)
+    _verify(layout[7], as: RawTokenSyntax?.self)
     _verify(layout[8], as: RawUnexpectedNodesSyntax?.self)
-    _verify(layout[9], as: RawTokenSyntax?.self)
+    _verify(layout[9], as: RawTypeSyntax?.self)
     _verify(layout[10], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[11], as: RawTokenSyntax?.self)
+    _verify(layout[12], as: RawUnexpectedNodesSyntax?.self)
     break
   case .primaryAssociatedTypeList:
     for element in layout {

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

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -6596,13 +6596,15 @@ public enum SyntaxFactory {
     return GenericParameterListSyntax(data)
   }
   @available(*, deprecated, message: "Use initializer on GenericParameterSyntax")
-  public static func makeGenericParameter(_ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, attributes: AttributeListSyntax?, _ unexpectedBetweenAttributesAndName: UnexpectedNodesSyntax? = nil, name: TokenSyntax, _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax?, _ unexpectedBetweenColonAndInheritedType: UnexpectedNodesSyntax? = nil, inheritedType: TypeSyntax?, _ unexpectedBetweenInheritedTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> GenericParameterSyntax {
+  public static func makeGenericParameter(_ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, attributes: AttributeListSyntax?, _ unexpectedBetweenAttributesAndName: UnexpectedNodesSyntax? = nil, name: TokenSyntax, _ unexpectedBetweenNameAndEllipsis: UnexpectedNodesSyntax? = nil, ellipsis: TokenSyntax?, _ unexpectedBetweenEllipsisAndColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax?, _ unexpectedBetweenColonAndInheritedType: UnexpectedNodesSyntax? = nil, inheritedType: TypeSyntax?, _ unexpectedBetweenInheritedTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, trailingComma: TokenSyntax?, _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil) -> GenericParameterSyntax {
     let layout: [RawSyntax?] = [
       unexpectedBeforeAttributes?.raw,
       attributes?.raw,
       unexpectedBetweenAttributesAndName?.raw,
       name.raw,
-      unexpectedBetweenNameAndColon?.raw,
+      unexpectedBetweenNameAndEllipsis?.raw,
+      ellipsis?.raw,
+      unexpectedBetweenEllipsisAndColon?.raw,
       colon?.raw,
       unexpectedBetweenColonAndInheritedType?.raw,
       inheritedType?.raw,
@@ -6631,6 +6633,8 @@ public enum SyntaxFactory {
       nil,
       nil,
       nil,
+      nil,
+      nil,
     ], arena: .default))
     return GenericParameterSyntax(data)
   }
@@ -9044,8 +9048,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)
   }