[ConstraintSystem] Always pass in a direct instance of OpenPackElementType instead

of assigning it to std::function_ref.

std::function_ref does not own the function reference, so assigning an OpenPackElementType
to a local function_ref lead to stale constraint system references when invoking
operator () later on.

Author: hborla

include/swift/Sema/ConstraintSystem.h

@@ -6117,11 +6117,19 @@ class OpenPackElementType {
 
 public:
   explicit OpenPackElementType(ConstraintSystem &cs,
-                               ConstraintLocator *locator,
+                               const ConstraintLocatorBuilder &locator,
                                GenericEnvironment *elementEnv)
-      : cs(cs), locator(locator), elementEnv(elementEnv) {}
+      : cs(cs), elementEnv(elementEnv) {
+    this->locator = cs.getConstraintLocator(locator);
+  }
 
   Type operator()(Type packType) const {
+    // Only assert we have an element environment when invoking the function
+    // object. In cases where pack elements are referenced outside of a
+    // pack expansion, type resolution will error before opening the pack
+    // element.
+    assert(elementEnv);
+
     auto *elementType = cs.createTypeVariable(locator, TVO_CanBindToHole);
     auto elementLoc = cs.getConstraintLocator(locator,
         LocatorPathElt::OpenedPackElement(elementEnv));

lib/Sema/CSGen.cpp

@@ -1422,12 +1422,14 @@ namespace {
       // Introduce type variables for unbound generics.
       const auto genericOpener = OpenUnboundGenericType(CS, locator);
       const auto placeholderHandler = HandlePlaceholderType(CS, locator);
-      OpenPackElementFn packElementOpener = nullptr;
+
+      // Add a PackElementOf constraint for 'each T' type reprs.
+      GenericEnvironment *elementEnv = nullptr;
       if (!PackElementEnvironments.empty()) {
         options |= TypeResolutionFlags::AllowPackReferences;
-        packElementOpener = OpenPackElementType(CS,
-            CS.getConstraintLocator(locator), PackElementEnvironments.back());
+        elementEnv = PackElementEnvironments.back();
       }
+      const auto packElementOpener = OpenPackElementType(CS, locator, elementEnv);
 
       const auto result = TypeResolution::resolveContextualType(
           repr, CS.DC, options, genericOpener, placeholderHandler,
@@ -1673,17 +1675,17 @@ namespace {
       auto options =
           TypeResolutionOptions(TypeResolverContext::InExpression);
       for (auto specializationArg : specializationArgs) {
-        OpenPackElementFn packElementOpener = nullptr;
+        GenericEnvironment *elementEnv = nullptr;
         if (!PackElementEnvironments.empty()) {
           options |= TypeResolutionFlags::AllowPackReferences;
-          packElementOpener = OpenPackElementType(CS, locator, PackElementEnvironments.back());
+          elementEnv = PackElementEnvironments.back();
         }
         const auto result = TypeResolution::resolveContextualType(
             specializationArg, CurDC, options,
             // Introduce type variables for unbound generics.
             OpenUnboundGenericType(CS, locator),
             HandlePlaceholderType(CS, locator),
-            packElementOpener);
+            OpenPackElementType(CS, locator, elementEnv));
         if (result->hasError())
           return true;
 
@@ -1743,18 +1745,18 @@ namespace {
           auto options =
               TypeResolutionOptions(TypeResolverContext::InExpression);
           for (size_t i = 0, e = specializations.size(); i < e; ++i) {
-            OpenPackElementFn packElementOpener = nullptr;
+            GenericEnvironment *elementEnv = nullptr;
             if (!PackElementEnvironments.empty()) {
               options |= TypeResolutionFlags::AllowPackReferences;
-              packElementOpener = OpenPackElementType(CS, locator, PackElementEnvironments.back());
+              elementEnv = PackElementEnvironments.back();
             }
 
             const auto result = TypeResolution::resolveContextualType(
                 specializations[i], CS.DC, options,
                 // Introduce type variables for unbound generics.
                 OpenUnboundGenericType(CS, locator),
                 HandlePlaceholderType(CS, locator),
-                packElementOpener);
+                OpenPackElementType(CS, locator, elementEnv));
             if (result->hasError())
               return Type();