[ConstraintSystem] Implement pack expansion variable resolution

A pack expansion type variable gets bound to its original pattern
type when solver can infer a contextual type for it. This makes
sure that pack expansion types are always matched via `matchTypes`
without `simplifyType` involvement which can expand them prematurely.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -3888,6 +3888,16 @@ class ConstraintSystem {
   bool resolveClosure(TypeVariableType *typeVar, Type contextualType,
                       ConstraintLocatorBuilder locator);
 
+  /// Given the fact that contextual type is now available for the type
+  /// variable representing a pack expansion type, let's resolve the expansion.
+  ///
+  /// \param typeVar The type variable representing pack expansion type.
+  /// \param locator The locator associated with contextual type.
+  ///
+  /// \returns `true` if pack expansion has been resolved, `false` otherwise.
+  bool resolvePackExpansion(TypeVariableType *typeVar,
+                            ConstraintLocatorBuilder locator);
+
   /// Assign a fixed type to the given type variable.
   ///
   /// \param typeVar The type variable to bind.

lib/Sema/CSSimplify.cpp

@@ -4287,6 +4287,15 @@ ConstraintSystem::matchTypesBindTypeVar(
     }
   }
 
+  if (typeVar->getImpl().isPackExpansion()) {
+    if (!flags.contains(TMF_BindingTypeVariable))
+      return formUnsolvedResult();
+
+    return resolvePackExpansion(typeVar, locator)
+               ? getTypeMatchSuccess()
+               : getTypeMatchFailure(locator);
+  }
+
   // If we're attempting to bind a PackType or PackArchetypeType to a type
   // variable that doesn't support it, we have a pack reference outside of a
   // pack expansion expression.
@@ -4305,11 +4314,6 @@ ConstraintSystem::matchTypesBindTypeVar(
     type = PlaceholderType::get(typeVar->getASTContext(), typeVar);
   }
 
-  // FIXME: Add a fix for this.
-  if (typeVar->getImpl().isPackExpansion() && !type->is<PackExpansionType>()) {
-    return getTypeMatchFailure(locator);
-  }
-
   // Binding to a pack expansion type is always an error in Swift 6 mode.
   // This indicates that a pack expansion expression was used in a context
   // that doesn't support it.
@@ -11229,6 +11233,29 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
   return !generateConstraints(AnyFunctionRef{closure}, closure->getBody());
 }
 
+bool ConstraintSystem::resolvePackExpansion(TypeVariableType *typeVar,
+                                            ConstraintLocatorBuilder locator) {
+  // TODO: Pack expansion type variable can carry opened type.
+  auto expansion =
+      llvm::find_if(OpenedPackExpansionTypes, [&](const auto &expansion) {
+        return expansion.second->isEqual(typeVar);
+      });
+
+  assert(expansion != OpenedPackExpansionTypes.end());
+
+  assignFixedType(typeVar, expansion->first, getConstraintLocator(locator));
+
+  if (isDebugMode()) {
+    PrintOptions PO;
+    PO.PrintTypesForDebugging = true;
+    llvm::errs().indent(solverState->getCurrentIndent())
+        << "(pack expansion variable " << typeVar->getString(PO)
+        << " is bound to '" << expansion->first->getString(PO) << "')\n";
+  }
+
+  return true;
+}
+
 ConstraintSystem::SolutionKind
 ConstraintSystem::simplifyDynamicTypeOfConstraint(
                                         Type type1, Type type2,