Merge pull request #61728 from slavapestov/pack-expansion-matching-pattern-instantiation

Instantiate pattern type when matching PackExpansionTypes

Author: slavapestov

lib/AST/PackExpansionMatcher.cpp

@@ -30,12 +30,13 @@ static Type createPackBinding(ASTContext &ctx, ArrayRef<Type> types) {
   // inside a PackExpansion, PackType(PackExpansionType()) will always
   // simplify to the pattern type.
   if (types.size() == 1) {
-    if (auto *expansion = types.front()->getAs<PackExpansionType>()) {
-      return expansion->getPatternType();
+    if (types.front()->is<PackExpansionType>()) {
+      return types.front();
     }
   }
 
-  return PackType::get(ctx, types);
+  auto *packType = PackType::get(ctx, types);
+  return PackExpansionType::get(packType, packType);
 }
 
 static Type gatherTupleElements(ArrayRef<TupleTypeElt> &elts,
@@ -84,7 +85,7 @@ bool TuplePackMatcher::match() {
              "by an unlabeled element");
 
       auto rhs = gatherTupleElements(rhsElts, lhsElt.getName(), ctx);
-      pairs.emplace_back(lhsExpansionType->getPatternType(), rhs, idx++);
+      pairs.emplace_back(lhsExpansionType, rhs, idx++);
       continue;
     }
 
@@ -104,7 +105,7 @@ bool TuplePackMatcher::match() {
              "by an unlabeled element");
 
       auto lhs = gatherTupleElements(lhsElts, rhsElt.getName(), ctx);
-      pairs.emplace_back(lhs, rhsExpansionType->getPatternType(), idx++);
+      pairs.emplace_back(lhs, rhsExpansionType, idx++);
       continue;
     }
 
@@ -189,16 +190,16 @@ bool ParamPackMatcher::match() {
   // to what remains of the right hand side.
   if (lhsParams.size() == 1) {
     auto lhsType = lhsParams[0].getPlainType();
-    if (auto *lhsExpansionType = lhsType->getAs<PackExpansionType>()) {
+    if (lhsType->is<PackExpansionType>()) {
       SmallVector<Type, 2> rhsTypes;
       for (auto rhsParam : rhsParams) {
         // FIXME: Check rhs flags
         rhsTypes.push_back(rhsParam.getPlainType());
       }
-      auto rhs = PackType::get(ctx, rhsTypes);
+      auto rhs = createPackBinding(ctx, rhsTypes);
 
       // FIXME: Check lhs flags
-      pairs.emplace_back(lhsExpansionType->getPatternType(), rhs, prefixLength);
+      pairs.emplace_back(lhsType, rhs, prefixLength);
       return false;
     }
   }
@@ -207,13 +208,13 @@ bool ParamPackMatcher::match() {
   // to what remains of the left hand side.
   if (rhsParams.size() == 1) {
     auto rhsType = rhsParams[0].getPlainType();
-    if (auto *rhsExpansionType = rhsType->getAs<PackExpansionType>()) {
+    if (rhsType->is<PackExpansionType>()) {
       SmallVector<Type, 2> lhsTypes;
       for (auto lhsParam : lhsParams) {
         // FIXME: Check lhs flags
         lhsTypes.push_back(lhsParam.getPlainType());
       }
-      auto lhs = PackType::get(ctx, lhsTypes);
+      auto lhs = createPackBinding(ctx, lhsTypes);
 
       // FIXME: Check rhs flags
       pairs.emplace_back(lhs, rhsType, prefixLength);
@@ -286,10 +287,10 @@ bool PackMatcher::match() {
   // to what remains of the right hand side.
   if (lhsTypes.size() == 1) {
     auto lhsType = lhsTypes[0];
-    if (auto *lhsExpansionType = lhsType->getAs<PackExpansionType>()) {
-      auto rhs = PackType::get(ctx, rhsTypes);
+    if (lhsType->is<PackExpansionType>()) {
+      auto rhs = createPackBinding(ctx, rhsTypes);
 
-      pairs.emplace_back(lhsExpansionType->getPatternType(), rhs, prefixLength);
+      pairs.emplace_back(lhsType, rhs, prefixLength);
       return false;
     }
   }
@@ -298,8 +299,8 @@ bool PackMatcher::match() {
   // to what remains of the left hand side.
   if (rhsTypes.size() == 1) {
     auto rhsType = rhsTypes[0];
-    if (auto *rhsExpansionType = rhsType->getAs<PackExpansionType>()) {
-      auto lhs = PackType::get(ctx, lhsTypes);
+    if (rhsType->is<PackExpansionType>()) {
+      auto lhs = createPackBinding(ctx, lhsTypes);
 
       pairs.emplace_back(lhs, rhsType, prefixLength);
       return false;

lib/Sema/CSDiagnostics.h

@@ -443,7 +443,8 @@ class SameTypeRequirementFailure final : public RequirementFailure {
 /// }
 /// ```
 ///
-/// `S.T` is not the same type as `Int`, which is required by `foo`.
+/// The generic parameter packs `T` and `U` are not known to have the same
+/// shape, which is required by `foo()`.
 class SameShapeRequirementFailure final : public RequirementFailure {
 public:
   SameShapeRequirementFailure(const Solution &solution, Type lhs, Type rhs,

lib/Sema/CSGen.cpp

@@ -2913,6 +2913,7 @@ namespace {
 
       auto elementResultType = CS.getType(expr->getPatternExpr());
       auto patternTy = CS.createTypeVariable(CS.getConstraintLocator(expr),
+                                             TVO_CanBindToPack |
                                              TVO_CanBindToHole);
       CS.addConstraint(ConstraintKind::PackElementOf, elementResultType,
                        patternTy, CS.getConstraintLocator(expr));