Sema: Remove OpenParameterPackElements

slavapestov · slavapestov · commit 3adb1dd1d02f · 2022-10-27T17:00:22.000-04:00
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -1402,120 +1402,6 @@ class AllowLabelMismatches : public MatchCallArgumentListener {
   }
 };
 
-namespace {
-class OpenParameterPackElements {
-  ConstraintSystem &CS;
-  int64_t argIdx;
-  Type patternTy;
-
-  // A map that relates a type variable opened for a reference to a parameter
-  // pack to an array of parallel type variables, one for each argument.
-  llvm::MapVector<TypeVariableType *, SmallVector<TypeVariableType *, 2>> PackElementCache;
-
-  // A map from argument index to the corresponding shape type for pack
-  // expansion arguments. When the parameter pack is expanded by a
-  // pack expansion argument, the corresponding pattern type is also
-  // wrapped in a pack expansion. Each pack reference in the pattern
-  // type will be bound to a pack expansion in the aggregated pack type
-  // created in 'intoPackTypes'.
-  llvm::SmallDenseMap<int64_t, Type> Expansions;
-
-public:
-  OpenParameterPackElements(ConstraintSystem &CS, PackExpansionType *PET)
-      : CS(CS), argIdx(-1), patternTy(PET->getPatternType()) {}
-
-public:
-  Type expandParameter(Type argType) {
-    argIdx += 1;
-    auto pattern = patternTy.transform(*this);
-
-    // If the argument that invoked expansion is itself a pack
-    // expansion, wrap the pattern type in a pack expansion type
-    // of the same shape.
-    if (auto expansion = argType->getAs<PackExpansionType>()) {
-      Expansions[argIdx] = expansion->getCountType();
-      pattern = PackExpansionType::get(pattern, expansion->getCountType());
-    }
-
-    return pattern;
-  }
-
-  void intoPackTypes(llvm::function_ref<void(TypeVariableType *, Type)> fn) && {
-    if (argIdx == -1) {
-      // No arguments. Each pack in the pattern will have no elements.
-      patternTy.visit([&](Type type) {
-        auto *typeVar = type->getAs<TypeVariableType>();
-        if (!typeVar || !typeVar->getImpl().getGenericParameter()->isParameterPack())
-          return;
-
-        this->PackElementCache[typeVar].clear();
-      });
-    }
-
-    for (const auto &entry : PackElementCache) {
-      SmallVector<Type, 8> elements;
-      for (int64_t i = 0; i < (int64_t)entry.second.size(); ++i) {
-        auto *typeVar = entry.second[i];
-
-        // If this argument is a pack expansion, wrap the corresponding
-        // type variable in a pack expansion to distinguish it from
-        // a scalar type argument. The type variable itself represents
-        // the argument pattern.
-        if (auto shape = Expansions[i]) {
-          elements.push_back(PackExpansionType::get(typeVar, shape));
-          continue;
-        }
-
-        elements.push_back(typeVar);
-      }
-
-      auto packType = PackType::get(CS.getASTContext(), elements);
-      fn(entry.first, packType);
-    }
-  }
-
-  Type operator()(Type Ty) {
-    if (!Ty || !Ty->isTypeVariableOrMember())
-      return Ty;
-
-    auto *TV = Ty->getAs<TypeVariableType>();
-    if (!TV)
-      return Ty;
-
-    // Leave plain opened type variables alone.
-    if (!TV->getImpl().getGenericParameter()->isParameterPack())
-      return TV;
-
-    // Create a clone of the parameter pack type variable.
-    auto *clonedTV = CS.createTypeVariable(TV->getImpl().getLocator(),
-                                           TV->getImpl().getRawOptions());
-
-    // Is there an entry for this parameter pack?
-    const auto &entries = PackElementCache.find(TV);
-    if (entries == PackElementCache.end()) {
-      // We're just seeing this parameter pack fresh, so enter a new type
-      // variable in its place and cache down the fact we just saw it.
-      PackElementCache[TV] = {clonedTV};
-    } else if ((int64_t)entries->second.size() <= argIdx) {
-      // We've seen this pack before, but we have a brand new element.
-      // Expand the cache entry.
-      PackElementCache[TV].push_back(clonedTV);
-    } else {
-      // Not only have we seen this pack before, we've seen this
-      // argument index before. Extract the old cache entry, emplace the new
-      // one, and bind them together.
-      auto *oldEntry = PackElementCache[TV][argIdx];
-      PackElementCache[TV][argIdx] = clonedTV;
-
-      CS.addConstraint(ConstraintKind::Bind, oldEntry, clonedTV,
-                       TV->getImpl().getLocator());
-    }
-
-    return clonedTV;
-  }
-};
-}
-
 namespace {
   /// Flags that should be applied to the existential argument type after
   /// opening.
@@ -1860,31 +1746,20 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
     // inout and @autoclosure.
     if (cs.getASTContext().LangOpts.hasFeature(Feature::VariadicGenerics) &&
         paramInfo.isVariadicGenericParameter(paramIdx)) {
-      auto *PET = paramTy->castTo<PackExpansionType>();
-      OpenParameterPackElements openParameterPack{cs, PET};
-      for (auto argIdx : parameterBindings[paramIdx]) {
-        const auto &argument = argsWithLabels[argIdx];
-        auto argTy = argument.getPlainType();
+      auto *paramPackExpansion = paramTy->castTo<PackExpansionType>();
 
-        // First, expand the opened parameter pack for this argument.
-        // This will open a new type variable for each pack reference
-        // in the pattern type of the parameter, and substitute the type
-        // variables into the pattern type.
-        auto substParamTy = openParameterPack.expandParameter(argTy);
-
-        cs.addConstraint(
-            subKind, argTy, substParamTy, loc, /*isFavored=*/false);
+      SmallVector<Type, 2> argTypes;
+      for (auto argIdx : parameterBindings[paramIdx]) {
+        auto argType = argsWithLabels[argIdx].getPlainType();
+        argTypes.push_back(argType);
       }
 
-      // Now that we have the pack mappings, bind the raw list to the
-      // whole parameter pack. This ensures references to the pack in
-      // return position refer to the whole pack of elements we just gathered.
-      std::move(openParameterPack)
-          .intoPackTypes([&](TypeVariableType *tsParam, Type pack) {
-            cs.addConstraint(ConstraintKind::Bind, pack, tsParam, loc,
-                             /*isFavored=*/false);
-          });
+      auto *argPack = PackType::get(cs.getASTContext(), argTypes);
+      auto *argPackExpansion = PackExpansionType::get(argPack, argPack);
 
+      cs.addConstraint(
+          subKind, argPackExpansion, paramPackExpansion,
+          loc, /*isFavored=*/false);
       continue;
     }
 
@@ -2529,23 +2404,29 @@ static PackType *replaceTypeVariablesWithFreshPacks(ConstraintSystem &cs,
   PackTypeVariableCollector collector;
   pattern.walk(collector);
 
+  if (collector.typeVars.empty())
+    return nullptr;
+
   auto *loc = cs.getConstraintLocator(locator);
 
   // For each pack type variable occurring in the pattern type, compute a
   // binding pack type comprised of fresh type variables.
   for (auto *typeVar : collector.typeVars) {
     auto &freshTypeVars = typeVars[typeVar];
     for (unsigned i = 0, e = pack->getNumElements(); i < e; ++i) {
+      auto *packExpansionElt = pack->getElementType(i)->getAs<PackExpansionType>();
+
       // Preserve the pack expansion structure of the original pack. If the ith
       // element was a pack expansion type, create a new pack expansion type
       // wrapping a pack type variable. Otherwise, create a new scalar
       // type variable.
       //
       // FIXME: Locator for diagnostics
       // FIXME: Other TVO_* flags for type variables?
-      if (pack->getElementType(i)->is<PackExpansionType>()) {
+      if (packExpansionElt != nullptr) {
         auto *freshTypeVar = cs.createTypeVariable(loc, TVO_CanBindToPack);
-        freshTypeVars.push_back(PackExpansionType::get(freshTypeVar, freshTypeVar));
+        freshTypeVars.push_back(PackExpansionType::get(
+            freshTypeVar, packExpansionElt->getCountType()));
       } else {
         freshTypeVars.push_back(cs.createTypeVariable(loc, /*options=*/0));
       }
@@ -2627,35 +2508,22 @@ ConstraintSystem::matchPackExpansionTypes(PackExpansionType *expansion1,
   auto pattern1 = expansion1->getPatternType();
   auto pattern2 = expansion2->getPatternType();
 
-  // A pattern is 'expanded' if it is a pack type, pack archetype or
-  // pack type variable. Otherwise, it is a concrete type which can be
-  // instantiated by replacing any pack type variables that occur within.
-  auto isFullyExpanded = [](Type t) -> bool {
-    return (t->is<PackType>() ||
-            t->is<PackArchetypeType>() ||
-            (t->is<TypeVariableType>() &&
-             t->castTo<TypeVariableType>()->getImpl().canBindToPack()));
-  };
-
-  bool isExpanded1 = isFullyExpanded(pattern1);
-  bool isExpanded2 = isFullyExpanded(pattern2);
-
   // If both sides are expanded or neither side is, just match them
   // directly.
-  if ((isExpanded1 && isExpanded2) ||
-      (!isExpanded1 && !isExpanded2)) {
+  if (pattern1->is<PackType>() == pattern2->is<PackType>()) {
     return matchTypes(pattern1, pattern2, kind, flags, locator);
 
   // If the right hand side is expanded, we have something like
   // Foo<$T0>... vs Pack{Foo<Int>, Foo<String>}...; We're going to
   // bind $T0 to Pack{Int, String}.
-  } else if (!isExpanded1 && isExpanded2) {
+  } else if (!pattern1->is<PackType>() && pattern2->is<PackType>()) {
     if (auto *pack2 = pattern2->getAs<PackType>()) {
-      auto *pack1 = replaceTypeVariablesWithFreshPacks(
-          *this, pattern1, pack2, locator);
-      // FIXME: Locator for diagnostics.
-      addConstraint(kind, pack1, pack2, locator);
-      return getTypeMatchSuccess();
+      if (auto *pack1 = replaceTypeVariablesWithFreshPacks(
+             *this, pattern1, pack2, locator)) {
+        // FIXME: Locator for diagnostics.
+        addConstraint(kind, pack1, pack2, locator);
+        return getTypeMatchSuccess();
+      }
     }
 
     return getTypeMatchFailure(locator);
@@ -2664,13 +2532,14 @@ ConstraintSystem::matchPackExpansionTypes(PackExpansionType *expansion1,
   // Pack{Foo<Int>, Foo<String>}... vs Foo<$T0>...; We're going to
   // bind $T0 to Pack{Int, String}.
   } else {
-    assert(isExpanded1 && !isExpanded2);
+    assert(pattern1->is<PackType>() && !pattern2->is<PackType>());
     if (auto *pack1 = pattern1->getAs<PackType>()) {
-      auto *pack2 = replaceTypeVariablesWithFreshPacks(
-          *this, pattern2, pack1, locator);
-      // FIXME: Locator for diagnostics.
-      addConstraint(kind, pack1, pack2, locator);
-      return getTypeMatchSuccess();
+      if (auto *pack2 = replaceTypeVariablesWithFreshPacks(
+              *this, pattern2, pack1, locator)) {
+        // FIXME: Locator for diagnostics.
+        addConstraint(kind, pack1, pack2, locator);
+        return getTypeMatchSuccess();
+      }
     }
 
     return getTypeMatchFailure(locator);
diff --git a/test/Constraints/pack_expansion_types.swift b/test/Constraints/pack_expansion_types.swift
@@ -8,13 +8,13 @@ func returnTupleLabel1<T...>() -> (x: T...) { fatalError() }
 
 func returnTupleLabel2<T...>() -> (Int, x: T...) { fatalError() }
 
-func returnTupleLabel3<T...>() -> (Int, T..., y: Float) { fatalError() } // expected-note {{in call to function 'returnTupleLabel3()'}}
+func returnTupleLabel3<T...>() -> (Int, T..., y: Float) { fatalError() }
 
-func returnTupleLabel4<T...>() -> (Int, x: T..., y: Float) { fatalError() }
+func returnTupleLabel4<T...>() -> (Int, x: T..., y: Float) { fatalError() } // expected-note {{in call to function 'returnTupleLabel4()'}}
 
-func returnTupleLabel5<T..., U...>() -> (Int, T..., y: U...) { fatalError() } // expected-note {{in call to function 'returnTupleLabel5()'}}
+func returnTupleLabel5<T..., U...>() -> (Int, T..., y: U...) { fatalError() }
 
-func returnTupleLabel6<T..., U...>() -> (Int, x: T..., y: U...) { fatalError() }
+func returnTupleLabel6<T..., U...>() -> (Int, x: T..., y: U...) { fatalError() } // expected-note {{in call to function 'returnTupleLabel6()'}}
 
 func concreteReturnTupleValid() {
   let _: () = returnTuple1()
@@ -103,20 +103,22 @@ func genericReturnTupleInvalid<T...>(_: T...) {
   let _: (x: T...) = returnTupleLabel2() // expected-error {{type of expression is ambiguous without more context}}
   let _: (Int, y: String, T...) = returnTupleLabel2() // expected-error {{type of expression is ambiguous without more context}}
 
-  let _: (T..., y: Float) = returnTupleLabel3() // expected-error {{'(Int, T..., y: Float)' is not convertible to '(T..., y: Float)', tuples have a different number of elements}}
-  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+  let _: (T..., y: Float) = returnTupleLabel3() // expected-error {{type of expression is ambiguous without more context}}
 
   let _: (Int, String, T..., x: Float) = returnTupleLabel3() // expected-error {{type of expression is ambiguous without more context}}
 
-  let _: (T..., y: Float) = returnTupleLabel4() // expected-error {{cannot convert value of type '(Int, y: Float)' to specified type '(T..., y: Float)'}}
+  let _: (T..., y: Float) = returnTupleLabel4() // expected-error {{'(Int, x: T..., y: Float)' is not convertible to '(T..., y: Float)', tuples have a different number of elements}}
+  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+
   let _: (Int, x: String, y: T...) = returnTupleLabel4() // expected-error {{cannot convert value of type '(Int, x: String, y: Float)' to specified type '(Int, x: String, y: T...)'}}
 
   let _: (Int, T..., x: T...) = returnTupleLabel5() // expected-error {{type of expression is ambiguous without more context}}
 
-  let _: (T..., y: Float, T...) = returnTupleLabel5() // expected-error {{'(Int, T..., y: Float, T...)' is not convertible to '(T..., y: Float, T...)', tuples have a different number of elements}}
-  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+  let _: (T..., y: Float, T...) = returnTupleLabel5() // expected-error {{type of expression is ambiguous without more context}}
 
-  let _: (T..., y: Int) = returnTupleLabel6() // expected-error {{cannot convert value of type '(Int, y: Int)' to specified type '(T..., y: Int)'}}
+  let _: (T..., y: Int) = returnTupleLabel6() // expected-error {{'(Int, x: T..., y: U...)' is not convertible to '(T..., y: Int)', tuples have a different number of elements}}
+  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+  // expected-error@-2 {{generic parameter 'U' could not be inferred}}
 }
 
 func returnFunction1<T...>() -> (T...) -> () {}
diff --git a/test/Constraints/variadic_generic_constraints.swift b/test/Constraints/variadic_generic_constraints.swift
@@ -56,7 +56,7 @@ takesParallelSequences(t: Array<String>(), Set<Int>(), u: Array<Int>(), Set<Stri
 // Same-shape requirements
 
 func zip<T..., U...>(t: T..., u: U...) -> ((T, U)...) {}
-// expected-note@-1 {{where 'T' = 'U', 'U' = 'T'}}
+// expected-note@-1 {{where 'T' = 'T', 'U' = 'U'}}
 
 let _ = zip()  // ok
 let _ = zip(t: 1, u: "hi")  // ok
@@ -72,5 +72,5 @@ func goodCallToZip<T..., U...>(t: T..., u: U...) where ((T, U)...): Any {
 
 func badCallToZip<T..., U...>(t: T..., u: U...) {
   _ = zip(t: t..., u: u...)
-  // expected-error@-1 {{global function 'zip(t:u:)' requires the type packs 'U' and 'T' have the same shape}}
-}
+  // expected-error@-1 {{global function 'zip(t:u:)' requires the type packs 'T' and 'U' have the same shape}}
+}
