Merge pull request #65657 from xedin/reverse-shape-of-constraint-5.9

[5.9][ConstraintSystem] Reverse direction of `ShapeOf` constraint

Author: xedin

include/swift/Sema/Constraint.h

@@ -224,7 +224,8 @@ enum class ConstraintKind : char {
   /// Binds the RHS type to a tuple of the params of a function typed LHS. Note
   /// this discards function parameter flags.
   BindTupleOfFunctionParams,
-  /// The first type is a type pack, and the second type is its reduced shape.
+  /// The first type is a reduced shape of the second type (represented as a
+  /// pack type).
   ShapeOf,
   /// Represents explicit generic arguments provided for a reference to
   /// a declaration.

include/swift/Sema/ConstraintSystem.h

@@ -4858,10 +4858,10 @@ class ConstraintSystem {
       ASTNode element, ContextualTypeInfo context, bool isDiscarded,
       TypeMatchOptions flags, ConstraintLocatorBuilder locator);
 
-  /// Simplify a shape constraint by binding the reduced shape of the
-  /// left hand side to the right hand side.
+  /// Simplify a shape constraint by binding the left-hand side to the
+  /// reduced shape of the right-hand side.
   SolutionKind simplifyShapeOfConstraint(
-      Type type1, Type type2, TypeMatchOptions flags,
+      Type shapeTy, Type packTy, TypeMatchOptions flags,
       ConstraintLocatorBuilder locator);
 
   /// Simplify an explicit generic argument constraint by equating the

lib/Sema/CSGen.cpp

@@ -3103,7 +3103,8 @@ namespace {
           llvm_unreachable("unsupported pack reference ASTNode");
         }
 
-        CS.addConstraint(ConstraintKind::ShapeOf, packType, shapeTypeVar,
+        CS.addConstraint(
+            ConstraintKind::ShapeOf, shapeTypeVar, packType,
             CS.getConstraintLocator(expr, ConstraintLocator::PackShape));
       }
 

lib/Sema/CSSimplify.cpp

@@ -13234,17 +13234,17 @@ static bool hasUnresolvedPackVars(Type type) {
 }
 
 ConstraintSystem::SolutionKind ConstraintSystem::simplifyShapeOfConstraint(
-    Type type1, Type type2, TypeMatchOptions flags,
+    Type shapeTy, Type packTy, TypeMatchOptions flags,
     ConstraintLocatorBuilder locator) {
   // Recursively replace all type variables with fixed bindings if
   // possible.
-  type1 = simplifyType(type1, flags);
+  packTy = simplifyType(packTy, flags);
 
   auto formUnsolved = [&]() {
     // If we're supposed to generate constraints, do so.
     if (flags.contains(TMF_GenerateConstraints)) {
       auto *shapeOf = Constraint::create(
-          *this, ConstraintKind::ShapeOf, type1, type2,
+          *this, ConstraintKind::ShapeOf, shapeTy, packTy,
           getConstraintLocator(locator));
 
       addUnsolvedConstraint(shapeOf);
@@ -13255,30 +13255,30 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyShapeOfConstraint(
   };
 
   // Don't try computing the shape of a type variable.
-  if (type1->isTypeVariableOrMember())
+  if (packTy->isTypeVariableOrMember())
     return formUnsolved();
 
   // We can't compute a reduced shape if the input type still
   // contains type variables that might bind to pack archetypes
   // or pack expansions.
   SmallPtrSet<TypeVariableType *, 2> typeVars;
-  type1->getTypeVariables(typeVars);
+  packTy->getTypeVariables(typeVars);
   for (auto *typeVar : typeVars) {
     if (typeVar->getImpl().canBindToPack() ||
         typeVar->getImpl().isPackExpansion())
       return formUnsolved();
   }
 
-  if (type1->hasPlaceholder()) {
+  if (packTy->hasPlaceholder()) {
     if (!shouldAttemptFixes())
       return SolutionKind::Error;
 
-    recordTypeVariablesAsHoles(type2);
+    recordTypeVariablesAsHoles(shapeTy);
     return SolutionKind::Solved;
   }
 
-  auto shape = type1->getReducedShape();
-  addConstraint(ConstraintKind::Bind, shape, type2, locator);
+  auto shape = packTy->getReducedShape();
+  addConstraint(ConstraintKind::Bind, shapeTy, shape, locator);
   return SolutionKind::Solved;
 }
 
@@ -13420,11 +13420,11 @@ ConstraintSystem::simplifyExplicitGenericArgumentsConstraint(
   auto formUnsolved = [&]() {
     // If we're supposed to generate constraints, do so.
     if (flags.contains(TMF_GenerateConstraints)) {
-      auto *shapeOf = Constraint::create(
-          *this, ConstraintKind::ShapeOf, type1, type2,
-          getConstraintLocator(locator));
+      auto *explictGenericArgs =
+          Constraint::create(*this, ConstraintKind::ExplicitGenericArguments,
+                             type1, type2, getConstraintLocator(locator));
 
-      addUnsolvedConstraint(shapeOf);
+      addUnsolvedConstraint(explictGenericArgs);
       return SolutionKind::Solved;
     }
 

test/Constraints/pack-expansion-expressions.swift

@@ -90,9 +90,9 @@ func typeReprPacks<each T: ExpressibleByIntegerLiteral>(_ t: repeat each T) {
 }
 
 func sameShapeDiagnostics<each T, each U>(t: repeat each T, u: repeat each U) {
-  _ = (repeat (each t, each u)) // expected-error {{pack expansion requires that 'each U' and 'each T' have the same shape}}
-  _ = (repeat Array<(each T, each U)>()) // expected-error {{pack expansion requires that 'each U' and 'each T' have the same shape}}
-  _ = (repeat (Array<each T>(), each u)) // expected-error {{pack expansion requires that 'each U' and 'each T' have the same shape}}
+  _ = (repeat (each t, each u)) // expected-error {{pack expansion requires that 'each T' and 'each U' have the same shape}}
+  _ = (repeat Array<(each T, each U)>()) // expected-error {{pack expansion requires that 'each T' and 'each U' have the same shape}}
+  _ = (repeat (Array<each T>(), each u)) // expected-error {{pack expansion requires that 'each T' and 'each U' have the same shape}}
 }
 
 func returnPackExpansionType<each T>(_ t: repeat each T) -> repeat each T { // expected-error {{pack expansion 'repeat each T' can only appear in a function parameter list, tuple element, or generic argument list}}