[ConstraintSystem] Model pack expansion types via type variables

include/swift/AST/DiagnosticsSema.def

@@ -5423,6 +5423,15 @@ ERROR(tuple_duplicate_label,none,
       "cannot create a tuple with a duplicate element label", ())
 ERROR(multiple_ellipsis_in_tuple,none,
       "only a single element can be variadic", ())
+ERROR(cannot_convert_tuple_into_pack_expansion_parameter,none,
+      "value pack expansion at parameter #%0 expects %1 separate arguments"
+      "%select{|; remove extra parentheses to change tuple into separate arguments}2",
+      (unsigned, unsigned, bool))
+NOTE(cannot_convert_tuple_into_pack_expansion_parameter_note,none,
+     "value pack expansion at parameter #%0 expects %1 separate arguments",
+     (unsigned, unsigned))
+ERROR(value_expansion_not_variadic,none,
+      "value pack expansion must contain at least one pack reference", ())
 
 ERROR(expansion_not_same_shape,none,
       "pack expansion %0 requires that %1 and %2 have the same shape",

include/swift/AST/PackExpansionMatcher.h

@@ -54,10 +54,13 @@ class TypeListPackMatcher {
   ArrayRef<Element> lhsElements;
   ArrayRef<Element> rhsElements;
 
+  std::function<bool(Type)> IsPackExpansionType;
 protected:
   TypeListPackMatcher(ASTContext &ctx, ArrayRef<Element> lhs,
-                      ArrayRef<Element> rhs)
-      : ctx(ctx), lhsElements(lhs), rhsElements(rhs) {}
+                      ArrayRef<Element> rhs,
+                      std::function<bool(Type)> isPackExpansionType)
+      : ctx(ctx), lhsElements(lhs), rhsElements(rhs),
+        IsPackExpansionType(isPackExpansionType) {}
 
 public:
   SmallVector<MatchedPair, 4> pairs;
@@ -86,8 +89,8 @@ class TypeListPackMatcher {
       auto lhsType = getElementType(lhsElt);
       auto rhsType = getElementType(rhsElt);
 
-      if (lhsType->template is<PackExpansionType>() ||
-          rhsType->template is<PackExpansionType>()) {
+      if (IsPackExpansionType(lhsType) ||
+          IsPackExpansionType(rhsType)) {
         break;
       }
 
@@ -115,8 +118,8 @@ class TypeListPackMatcher {
       auto lhsType = getElementType(lhsElt);
       auto rhsType = getElementType(rhsElt);
 
-      if (lhsType->template is<PackExpansionType>() ||
-          rhsType->template is<PackExpansionType>()) {
+      if (IsPackExpansionType(lhsType) ||
+          IsPackExpansionType(rhsType)) {
         break;
       }
 
@@ -139,7 +142,7 @@ class TypeListPackMatcher {
     // to what remains of the right hand side.
     if (lhsElts.size() == 1) {
       auto lhsType = getElementType(lhsElts[0]);
-      if (auto *lhsExpansion = lhsType->template getAs<PackExpansionType>()) {
+      if (IsPackExpansionType(lhsType)) {
         unsigned lhsIdx = prefixLength;
         unsigned rhsIdx = prefixLength;
 
@@ -154,7 +157,7 @@ class TypeListPackMatcher {
         auto rhs = createPackBinding(rhsTypes);
 
         // FIXME: Check lhs flags
-        pairs.emplace_back(lhsExpansion, rhs, lhsIdx, rhsIdx);
+        pairs.emplace_back(lhsType, rhs, lhsIdx, rhsIdx);
         return false;
       }
     }
@@ -163,7 +166,7 @@ class TypeListPackMatcher {
     // to what remains of the left hand side.
     if (rhsElts.size() == 1) {
       auto rhsType = getElementType(rhsElts[0]);
-      if (auto *rhsExpansion = rhsType->template getAs<PackExpansionType>()) {
+      if (IsPackExpansionType(rhsType)) {
         unsigned lhsIdx = prefixLength;
         unsigned rhsIdx = prefixLength;
 
@@ -178,7 +181,7 @@ class TypeListPackMatcher {
         auto lhs = createPackBinding(lhsTypes);
 
         // FIXME: Check rhs flags
-        pairs.emplace_back(lhs, rhsExpansion, lhsIdx, rhsIdx);
+        pairs.emplace_back(lhs, rhsType, lhsIdx, rhsIdx);
         return false;
       }
     }
@@ -197,14 +200,11 @@ class TypeListPackMatcher {
   Type getElementType(const Element &) const;
   ParameterTypeFlags getElementFlags(const Element &) const;
 
-  PackExpansionType *createPackBinding(ArrayRef<Type> types) const {
+  Type createPackBinding(ArrayRef<Type> types) const {
     // If there is only one element and it's a PackExpansionType,
     // return it directly.
-    if (types.size() == 1) {
-      if (auto *expansionType = types.front()->getAs<PackExpansionType>()) {
-        return expansionType;
-      }
-    }
+    if (types.size() == 1 && IsPackExpansionType(types.front()))
+      return types.front();
 
     // Otherwise, wrap the elements in PackExpansionType(PackType(...)).
     auto *packType = PackType::get(ctx, types);
@@ -220,10 +220,12 @@ class TypeListPackMatcher {
 /// other side.
 class TuplePackMatcher : public TypeListPackMatcher<TupleTypeElt> {
 public:
-  TuplePackMatcher(TupleType *lhsTuple, TupleType *rhsTuple)
-      : TypeListPackMatcher(lhsTuple->getASTContext(),
-                            lhsTuple->getElements(),
-                            rhsTuple->getElements()) {}
+  TuplePackMatcher(
+      TupleType *lhsTuple, TupleType *rhsTuple,
+      std::function<bool(Type)> isPackExpansionType =
+          [](Type T) { return T->is<PackExpansionType>(); })
+      : TypeListPackMatcher(lhsTuple->getASTContext(), lhsTuple->getElements(),
+                            rhsTuple->getElements(), isPackExpansionType) {}
 };
 
 /// Performs a structural match of two lists of (unlabeled) function
@@ -235,9 +237,12 @@ class TuplePackMatcher : public TypeListPackMatcher<TupleTypeElt> {
 /// other side.
 class ParamPackMatcher : public TypeListPackMatcher<AnyFunctionType::Param> {
 public:
-  ParamPackMatcher(ArrayRef<AnyFunctionType::Param> lhsParams,
-                   ArrayRef<AnyFunctionType::Param> rhsParams, ASTContext &ctx)
-      : TypeListPackMatcher(ctx, lhsParams, rhsParams) {}
+  ParamPackMatcher(
+      ArrayRef<AnyFunctionType::Param> lhsParams,
+      ArrayRef<AnyFunctionType::Param> rhsParams, ASTContext &ctx,
+      std::function<bool(Type)> isPackExpansionType =
+          [](Type T) { return T->is<PackExpansionType>(); })
+      : TypeListPackMatcher(ctx, lhsParams, rhsParams, isPackExpansionType) {}
 };
 
 /// Performs a structural match of two lists of types.
@@ -248,8 +253,11 @@ class ParamPackMatcher : public TypeListPackMatcher<AnyFunctionType::Param> {
 /// other side.
 class PackMatcher : public TypeListPackMatcher<Type> {
 public:
-  PackMatcher(ArrayRef<Type> lhsTypes, ArrayRef<Type> rhsTypes, ASTContext &ctx)
-      : TypeListPackMatcher(ctx, lhsTypes, rhsTypes) {}
+  PackMatcher(
+      ArrayRef<Type> lhsTypes, ArrayRef<Type> rhsTypes, ASTContext &ctx,
+      std::function<bool(Type)> isPackExpansionType =
+          [](Type T) { return T->is<PackExpansionType>(); })
+      : TypeListPackMatcher(ctx, lhsTypes, rhsTypes, isPackExpansionType) {}
 };
 
 } // end namespace swift

include/swift/AST/Types.h

@@ -400,12 +400,12 @@ class alignas(1 << TypeAlignInBits) TypeBase
     NumProtocols : 16
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(TypeVariableType, TypeBase, 6+32,
+  SWIFT_INLINE_BITFIELD_FULL(TypeVariableType, TypeBase, 7+31,
     /// Type variable options.
-    Options : 6,
+    Options : 7,
     : NumPadBits,
     /// The unique number assigned to this type variable.
-    ID : 32
+    ID : 31
   );
 
   SWIFT_INLINE_BITFIELD(SILFunctionType, TypeBase, NumSILExtInfoBits+1+4+1+2+1+1,

include/swift/Sema/CSFix.h

@@ -434,6 +434,13 @@ enum class FixKind : uint8_t {
 
   /// Allow pack expansion expressions in a context that does not support them.
   AllowInvalidPackExpansion,
+
+  /// Allow a pack expansion parameter of N elements to be matched
+  /// with a single tuple literal argument of the same arity.
+  DestructureTupleToMatchPackExpansionParameter,
+
+  /// Allow value pack expansion without pack references.
+  AllowValueExpansionWithoutPackReferences,
 };
 
 class ConstraintFix {
@@ -3416,6 +3423,64 @@ class AllowGlobalActorMismatch final : public ContextualMismatch {
   }
 };
 
+/// Passing an argument of tuple type to a value pack expansion parameter
+/// that expected N distinct elements.
+class DestructureTupleToMatchPackExpansionParameter final
+    : public ConstraintFix {
+  PackType *ParamShape;
+
+  DestructureTupleToMatchPackExpansionParameter(ConstraintSystem &cs,
+                                                PackType *paramShapeTy,
+                                                ConstraintLocator *locator)
+      : ConstraintFix(cs,
+                      FixKind::DestructureTupleToMatchPackExpansionParameter,
+                      locator),
+        ParamShape(paramShapeTy) {
+    assert(locator->isLastElement<LocatorPathElt::ApplyArgToParam>());
+  }
+
+public:
+  std::string getName() const override {
+    return "allow pack expansion to match tuple argument";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static DestructureTupleToMatchPackExpansionParameter *
+  create(ConstraintSystem &cs, PackType *paramShapeTy,
+         ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() ==
+           FixKind::DestructureTupleToMatchPackExpansionParameter;
+  }
+};
+
+class AllowValueExpansionWithoutPackReferences final : public ConstraintFix {
+  AllowValueExpansionWithoutPackReferences(ConstraintSystem &cs,
+                                           ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowValueExpansionWithoutPackReferences,
+                      locator) {}
+
+public:
+  std::string getName() const override {
+    return "allow value pack expansion without pack references";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
+  static AllowValueExpansionWithoutPackReferences *
+  create(ConstraintSystem &cs, ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowValueExpansionWithoutPackReferences;
+  }
+};
+
 } // end namespace constraints
 } // end namespace swift
 

include/swift/Sema/Constraint.h

@@ -233,6 +233,8 @@ enum class ConstraintKind : char {
   /// an overload. The second type is a PackType containing the explicit
   /// generic arguments.
   ExplicitGenericArguments,
+  /// Both (first and second) pack types should have the same reduced shape.
+  SameShape,
 };
 
 /// Classification of the different kinds of constraints.
@@ -701,6 +703,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::DefaultClosureType:
     case ConstraintKind::UnresolvedMemberChainBase:
     case ConstraintKind::PackElementOf:
+    case ConstraintKind::SameShape:
       return ConstraintClassification::Relational;
 
     case ConstraintKind::ValueMember:

include/swift/Sema/ConstraintLocator.h

@@ -1177,6 +1177,22 @@ class LocatorPathElt::AnyPatternDecl final
   }
 };
 
+class LocatorPathElt::PackExpansionType final
+    : public StoredPointerElement<swift::PackExpansionType> {
+public:
+  PackExpansionType(swift::PackExpansionType *openedPackExpansionTy)
+      : StoredPointerElement(PathElementKind::PackExpansionType,
+                             openedPackExpansionTy) {
+    assert(openedPackExpansionTy);
+  }
+
+  swift::PackExpansionType *getOpenedType() const { return getStoredPointer(); }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == PathElementKind::PackExpansionType;
+  }
+};
+
 namespace details {
   template <typename CustomPathElement>
   class PathElement {

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -202,6 +202,9 @@ CUSTOM_LOCATOR_PATH_ELT(PackElement)
 /// The shape of a parameter pack.
 SIMPLE_LOCATOR_PATH_ELT(PackShape)
 
+/// The type of an "opened" pack expansion
+CUSTOM_LOCATOR_PATH_ELT(PackExpansionType)
+
 /// The pattern  of a pack expansion.
 SIMPLE_LOCATOR_PATH_ELT(PackExpansionPattern)