Implement Generic Argument Binding for Variadic Types

The algorithm is detailed below:

Suppose we encounter a type T<..., U, V..., W, ...> for V... the _sole_ variadic generic parameter.

When we encounter an argument list <A, B, C, D, E, F, ...> to T, we must work in three steps

- Bind all generic parameters up to U in parallel with the argument list until we encounter V...
- Measure the tail of parameters after V... and call it `t`. Assuming `m` type variables hav been bound already, we must bind `n - t - m` type arguments to V...
- Finally, bind the remaining `t` arguments.

This procedure is often called "Saturation" in the literature. Variadic generics have a special saturation property where unlike normal generic parameters it is possible to bind zero arguments to them. In such a case, the result is an empty pack type, which is semantically well-formed.

Author: CodaFi

include/swift/AST/DiagnosticsSema.def

@@ -3700,8 +3700,8 @@ NOTE(specialize_explicit_type_instead,none,
      "did you mean to explicitly reference %0 instead?", (Type))
 ERROR(type_parameter_count_mismatch,none,
       "generic type %0 specialized with %select{too many|too few}3 type "
-      "parameters (got %2, but expected %1)",
-      (Identifier, unsigned, unsigned, bool))
+      "parameters (got %2, but expected %select{%1|at least %1}4)",
+      (Identifier, unsigned, unsigned, bool, bool))
 ERROR(generic_type_requires_arguments,none,
       "reference to generic type %0 requires arguments in <...>", (Type))
 NOTE(descriptive_generic_type_declared_here,none,
@@ -4813,6 +4813,8 @@ ERROR(tuple_single_element,none,
       "cannot create a single-element tuple with an element label", ())
 ERROR(tuple_ellipsis,none,
       "cannot create a variadic tuple", ())
+ERROR(expansion_not_variadic,none,
+      "cannot create expansion with non-variadic type %0", (Type))
 ERROR(tuple_duplicate_label,none,
       "cannot create a tuple with a duplicate element label", ())
 ERROR(enum_element_ellipsis,none,

lib/Sema/CSGen.cpp

@@ -1605,11 +1605,12 @@ namespace {
           if (specializations.size() > typeVars.size()) {
             de.diagnose(expr->getSubExpr()->getLoc(),
                         diag::type_parameter_count_mismatch,
-                        bgt->getDecl()->getName(),
-                        typeVars.size(), specializations.size(),
-                        false)
-              .highlight(SourceRange(expr->getLAngleLoc(),
-                                     expr->getRAngleLoc()));
+                        bgt->getDecl()->getName(), typeVars.size(),
+                        specializations.size(),
+                        /*too many arguments*/ false,
+                        /*type sequence?*/ false)
+                .highlight(
+                    SourceRange(expr->getLAngleLoc(), expr->getRAngleLoc()));
             de.diagnose(bgt->getDecl(), diag::kind_declname_declared_here,
                         DescriptiveDeclKind::GenericType,
                         bgt->getDecl()->getName());
@@ -2779,7 +2780,7 @@ namespace {
 
       CS.addConstraint(ConstraintKind::ApplicableFunction,
                        FunctionType::get(params, resultType, extInfo),
-                       CS.getType(expr->getFn()),
+                       CS.getType(fnExpr),
         CS.getConstraintLocator(expr, ConstraintLocator::ApplyFunction));
 
       // If we ended up resolving the result type variable to a concrete type,

lib/Sema/TypeCheckType.cpp

@@ -623,15 +623,41 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
   auto *decl = unboundType->getDecl();
 
   // Make sure we have the right number of generic arguments.
+  //
+  // For generic types without type sequence parameters, we require
+  // the number of declared generic parameters match the number of
+  // arguments.
+  //
+  // For generic types with type sequence parameters, we only require
+  // that the number of arguments is enough to saturate the number of
+  // regular generic parameters. The type sequence parameter will absorb
+  // any excess parameters, or will have a substitution of `Void` if there
+  // is nothing to bind. This Void-binding behavior of type sequences
+  // also explains the offset of one that isn't otherwise present in
+  // the plain generic parameter case.
+  //
+  // struct Foo<Prefix, T..., Suffix> {}
+  // typealias X = Foo<String, Int, Float, Double> // Prefix -> String, Suffix
+  // -> Double, T... -> (Int, Float) typealias X = Foo<String, Int> // Prefix ->
+  // String, Suffix -> Int, T... -> Void typealias Y = Foo<String> // error: Not
+  // enough arguments to bind Suffix.
+  //
   // FIXME: If we have fewer arguments than we need, that might be okay, if
-  // we're allowed to deduce the remaining arguments from context.
+  // we're allowed to deduce the remaining arguments from context. The
+  // expression checker certainly only cares about the case where too many
+  // arguments are given.
   auto genericArgs = generic->getGenericArgs();
   auto genericParams = decl->getGenericParams();
-  if (genericParams->size() != genericArgs.size()) {
+  auto hasTypeSequence = llvm::any_of(
+      *genericParams, [](const auto *GPT) { return GPT->isTypeSequence(); });
+  if ((!hasTypeSequence && genericArgs.size() != genericParams->size()) ||
+      (hasTypeSequence && genericArgs.size() < genericParams->size() - 1)) {
     if (!options.contains(TypeResolutionFlags::SilenceErrors)) {
-      diags.diagnose(loc, diag::type_parameter_count_mismatch, decl->getName(),
-                     genericParams->size(), genericArgs.size(),
-                     genericArgs.size() < genericParams->size())
+      diags
+          .diagnose(loc, diag::type_parameter_count_mismatch, decl->getName(),
+                    genericParams->size() - (hasTypeSequence ? 1 : 0),
+                    genericArgs.size(),
+                    genericArgs.size() < genericParams->size(), hasTypeSequence)
           .highlight(generic->getAngleBrackets());
       decl->diagnose(diag::kind_declname_declared_here,
                      DescriptiveDeclKind::GenericType, decl->getName());
@@ -728,8 +754,15 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
 Type TypeResolution::applyUnboundGenericArguments(
     GenericTypeDecl *decl, Type parentTy, SourceLoc loc,
     ArrayRef<Type> genericArgs) const {
-  assert(genericArgs.size() == decl->getGenericParams()->size() &&
-         "invalid arguments, use applyGenericArguments for diagnostic emitting");
+  const bool hasTypeSequence =
+      llvm::any_of(*decl->getGenericParams(),
+                   [](const auto *GPT) { return GPT->isTypeSequence(); });
+  assert(
+      ((!hasTypeSequence &&
+        genericArgs.size() == decl->getGenericParams()->size()) ||
+       (hasTypeSequence &&
+        genericArgs.size() >= decl->getGenericParams()->size() - 1)) &&
+      "invalid arguments, use applyGenericArguments for diagnostic emitting");
 
   auto genericSig = decl->getGenericSignature();
   assert(!genericSig.isNull());
@@ -777,16 +810,62 @@ Type TypeResolution::applyUnboundGenericArguments(
 
   // Realize the types of the generic arguments and add them to the
   // substitution map.
-  for (const unsigned i : indices(genericArgs)) {
-    auto origTy = genericSig.getInnermostGenericParams()[i];
-    auto substTy = genericArgs[i];
+  auto innerParams = genericSig.getInnermostGenericParams();
+  for (unsigned i = 0; i < innerParams.size(); ++i) {
+    auto origTy = innerParams[i];
+    auto origGP = origTy->getCanonicalType()->castTo<GenericTypeParamType>();
+
+    if (!origGP->isTypeSequence()) {
+      auto substTy = genericArgs[i];
+
+      // Enter a substitution.
+      subs[origGP] = substTy;
+
+      skipRequirementsCheck |=
+          substTy->hasTypeVariable() || substTy->hasUnboundGenericType();
+
+      continue;
+    }
 
-    // Enter a substitution.
-    subs[origTy->getCanonicalType()->castTo<GenericTypeParamType>()] =
-      substTy;
+    // Scan backwards to find the bounds of the longest run of
+    // types we can bind to this type sequence parameter.
+    unsigned tail;
+    for (tail = 1; tail <= innerParams.size(); ++tail) {
+      auto tailTy = innerParams[innerParams.size() - tail];
+      auto tailGP = tailTy->getCanonicalType()->castTo<GenericTypeParamType>();
+      if (tailGP->isTypeSequence()) {
+        assert(tailGP->isEqual(origGP) &&
+               "Found multiple type sequence parameters!");
 
-    skipRequirementsCheck |=
-        substTy->hasTypeVariable() || substTy->hasUnboundGenericType();
+        // Saturate the type sequence. Take care that if the prefix and suffix
+        // have bound all available arguments that we bind the type sequence
+        // parameter to `Void`.
+        const size_t sequenceLength = tail + i <= genericArgs.size()
+                                          ? genericArgs.size() - tail - i + 1
+                                          : 0;
+
+        auto substTy = PackType::get(getASTContext(),
+                                     genericArgs.slice(i, sequenceLength));
+
+        // Enter a substitution.
+        subs[origGP] = substTy;
+
+        skipRequirementsCheck |=
+            substTy->hasTypeVariable() || substTy->hasUnboundGenericType();
+
+        break;
+      }
+
+      auto substTy = genericArgs[genericArgs.size() - tail];
+
+      // Enter a substitution.
+      subs[tailGP] = substTy;
+
+      skipRequirementsCheck |=
+          substTy->hasTypeVariable() || substTy->hasUnboundGenericType();
+    }
+
+    break;
   }
 
   // Check the generic arguments against the requirements of the declaration's

test/Constraints/type_sequence.swift

@@ -25,3 +25,46 @@ func min<@_typeSequence T: Comparable>(_ values: T...) -> T? {
 
 func badParameter<T>(_ : @_typeSequence T) {} // expected-error {{attribute does not apply to type}}
 
+func directAliases() {
+  typealias Tuple<@_typeSequence Ts> = (Ts...)
+
+  typealias Many<T, U, V, @_typeSequence Ws> = Tuple<T, U, V, Ws>
+
+  let _: Many<Int, String, Double, Void, Void, Void, Void> = 42 // expected-error {{cannot convert value of type 'Int' to specified type}}
+}
+
+func bindPrefix() {
+  struct Bind<Prefix, @_typeSequence U> {}
+
+  typealias TooFew0 = Bind<> // expected-error {{expected type}}
+  typealias TooFew1 = Bind<String> // OK
+  typealias TooFew2 = Bind<String, String> // OK
+  typealias JustRight = Bind<String, String, String> // OK
+  typealias Oversaturated = Bind<String, String, String, String, String, String, String, String> // OK
+}
+
+func bindSuffix() {
+  struct Bind<@_typeSequence U, Suffix> {}
+
+  typealias TooFew0 = Bind<> // expected-error {{expected type}}
+  typealias TooFew1 = Bind<String> // OK
+  typealias TooFew2 = Bind<String, String> // OK
+  typealias JustRight = Bind<String, String, String> // OK
+  typealias Oversaturated = Bind<String, String, String, String, String, String, String, String> // OK
+}
+
+func bindPrefixAndSuffix() {
+  struct Bind<Prefix, @_typeSequence U, Suffix> {} // expected-note {{generic type 'Bind' declared here}}
+
+  typealias TooFew0 = Bind<> // expected-error {{expected type}}
+  typealias TooFew1 = Bind<String> // expected-error {{generic type 'Bind' specialized with too few type parameters (got 1, but expected at least 2)}}
+  typealias TooFew2 = Bind<String, String> // OK
+  typealias JustRight = Bind<String, String, String> // OK
+  typealias Oversaturated = Bind<String, String, String, String, String, String, String, String> // OK
+}
+
+func invalidPacks() {
+  func monovariadic1() -> (String...) {} // expected-error {{cannot create expansion with non-variadic type 'String'}}
+  func monovariadic2<T>() -> (T...) {} // expected-error 2 {{cannot create expansion with non-variadic type 'T'}}
+  func monovariadic3<T, U>() -> (T, U...) {} // expected-error {{cannot create a variadic tuple}}
+}