AST: Factor out mapLocalArchetypesOutOfContext() utility function

Author: slavapestov

include/swift/AST/LocalArchetypeRequirementCollector.h

@@ -54,6 +54,10 @@ struct MapLocalArchetypesOutOfContext {
   Type operator()(SubstitutableType *type) const;
 };
 
+Type mapLocalArchetypesOutOfContext(Type type,
+                                    GenericSignature baseGenericSig,
+                                    ArrayRef<GenericEnvironment *> capturedEnvs);
+
 struct MapIntoLocalArchetypeContext {
   GenericEnvironment *baseGenericEnv;
   ArrayRef<GenericEnvironment *> capturedEnvs;

include/swift/SIL/SILCloner.h

@@ -60,9 +60,8 @@ struct SubstitutionMapWithLocalArchetypes {
 
         // Map the local archetype to an interface type in the new generic
         // signature.
-        MapLocalArchetypesOutOfContext mapOutOfContext(BaseGenericSig,
-                                                       CapturedEnvs);
-        auto interfaceTy = mapOutOfContext(local);
+        auto interfaceTy = mapLocalArchetypesOutOfContext(
+            local, BaseGenericSig, CapturedEnvs);
 
         // Map this interface type into the new generic environment to get
         // a primary archetype.

lib/AST/ASTMangler.cpp

@@ -3796,12 +3796,8 @@ void ASTMangler::appendClosureComponents(CanType Ty, unsigned discriminator,
   appendContext(parentContext, base, StringRef());
 
   auto Sig = parentContext->getGenericSignatureOfContext();
-
-  Ty = Ty.subst(MapLocalArchetypesOutOfContext(Sig, capturedEnvs),
-                MakeAbstractConformanceForGenericType(),
-                SubstFlags::PreservePackExpansionLevel |
-                SubstFlags::SubstitutePrimaryArchetypes |
-                SubstFlags::SubstituteLocalArchetypes)->getCanonicalType();
+  Ty = mapLocalArchetypesOutOfContext(Ty, Sig, capturedEnvs)
+      ->getCanonicalType();
 
   appendType(Ty, Sig);
   appendOperator(isImplicit ? "fu" : "fU", Index(discriminator));

lib/AST/LocalArchetypeRequirementCollector.cpp

@@ -203,6 +203,17 @@ Type MapLocalArchetypesOutOfContext::operator()(SubstitutableType *type) const {
   return getInterfaceType(archetypeTy->getInterfaceType(), genericEnv);
 }
 
+Type swift::mapLocalArchetypesOutOfContext(
+    Type type,
+    GenericSignature baseGenericSig,
+    ArrayRef<GenericEnvironment *> capturedEnvs) {
+  return type.subst(MapLocalArchetypesOutOfContext(baseGenericSig, capturedEnvs),
+                    MakeAbstractConformanceForGenericType(),
+                    SubstFlags::PreservePackExpansionLevel |
+                    SubstFlags::SubstitutePrimaryArchetypes |
+                    SubstFlags::SubstituteLocalArchetypes);
+}
+
 static Type mapIntoLocalContext(GenericTypeParamType *param, unsigned baseDepth,
                                 ArrayRef<GenericEnvironment *> capturedEnvs) {
   assert(!param->isParameterPack());

lib/SIL/IR/SILFunctionType.cpp

@@ -1967,14 +1967,11 @@ lowerCaptureContextParameters(TypeConverter &TC, SILDeclRef function,
   auto mapTypeOutOfContext = [&](Type t) -> CanType {
     LLVM_DEBUG(llvm::dbgs() << "-- capture with contextual type " << t << "\n");
 
-    t = t.subst(MapLocalArchetypesOutOfContext(origGenericSig, capturedEnvs),
-                MakeAbstractConformanceForGenericType(),
-                SubstFlags::PreservePackExpansionLevel |
-                SubstFlags::SubstitutePrimaryArchetypes |
-                SubstFlags::SubstituteLocalArchetypes);
-
-    LLVM_DEBUG(llvm::dbgs() << "-- maps to " << t->getCanonicalType() << "\n");
-    return t->getCanonicalType();
+    auto result = mapLocalArchetypesOutOfContext(t, origGenericSig, capturedEnvs)
+        ->getCanonicalType();
+
+    LLVM_DEBUG(llvm::dbgs() << "-- maps to " << result << "\n");
+    return result;
   };
 
   for (auto capture : loweredCaptures.getCaptures()) {
@@ -3004,26 +3001,17 @@ CanSILFunctionType swift::buildSILFunctionThunkType(
                                      interfaceSubs);
   }
 
-  MapLocalArchetypesOutOfContext mapOutOfContext(baseGenericSig, capturedEnvs);
   auto substFormalTypeIntoThunkContext =
       [&](CanType t) -> CanType {
     return genericEnv->mapTypeIntoContext(
-        t.subst(mapOutOfContext,
-                MakeAbstractConformanceForGenericType(),
-                SubstFlags::PreservePackExpansionLevel |
-                SubstFlags::SubstitutePrimaryArchetypes |
-                SubstFlags::SubstituteLocalArchetypes))
+        mapLocalArchetypesOutOfContext(t, baseGenericSig, capturedEnvs))
                ->getCanonicalType();
   };
   auto substLoweredTypeIntoThunkContext =
       [&](CanSILFunctionType t) -> CanSILFunctionType {
     return cast<SILFunctionType>(
         genericEnv->mapTypeIntoContext(
-          Type(t).subst(mapOutOfContext,
-                        MakeAbstractConformanceForGenericType(),
-                        SubstFlags::PreservePackExpansionLevel |
-                        SubstFlags::SubstitutePrimaryArchetypes |
-                        SubstFlags::SubstituteLocalArchetypes))
+          mapLocalArchetypesOutOfContext(t, baseGenericSig, capturedEnvs))
               ->getCanonicalType());
   };
 

lib/SIL/IR/TypeLowering.cpp

@@ -3905,12 +3905,8 @@ getAnyFunctionRefInterfaceType(TypeConverter &TC,
 
   if (funcType->hasArchetype()) {
     assert(isa<FunctionType>(funcType));
-    auto substType = Type(funcType).subst(
-        MapLocalArchetypesOutOfContext(sig.baseGenericSig, sig.capturedEnvs),
-        MakeAbstractConformanceForGenericType(),
-        SubstFlags::PreservePackExpansionLevel |
-        SubstFlags::SubstitutePrimaryArchetypes |
-        SubstFlags::SubstituteLocalArchetypes);
+    auto substType = mapLocalArchetypesOutOfContext(
+        funcType, sig.baseGenericSig, sig.capturedEnvs);
     funcType = cast<FunctionType>(substType->getCanonicalType());
   }
 
@@ -4964,15 +4960,10 @@ TypeConverter::getInterfaceBoxTypeForCapture(ValueDecl *captured,
   SmallSetVector<GenericEnvironment *, 2> boxCapturedEnvs;
   findCapturedEnvironments(loweredContextType, boxCapturedEnvs);
 
-  MapLocalArchetypesOutOfContext mapOutOfContext(baseGenericSig,
-                                                 boxCapturedEnvs.getArrayRef());
-
-  auto loweredInterfaceType = loweredContextType.subst(
-      mapOutOfContext,
-      MakeAbstractConformanceForGenericType(),
-      SubstFlags::PreservePackExpansionLevel |
-      SubstFlags::SubstitutePrimaryArchetypes |
-      SubstFlags::SubstituteLocalArchetypes)->getCanonicalType();
+  auto loweredInterfaceType =
+      mapLocalArchetypesOutOfContext(loweredContextType, baseGenericSig,
+                                     boxCapturedEnvs.getArrayRef())
+      ->getCanonicalType();
 
   // If the type is not dependent at all, we can form a concrete box layout.
   // We don't need to capture the generic environment.

lib/SILGen/ResultPlan.cpp

@@ -121,10 +121,7 @@ mapTypeOutOfOpenedExistentialContext(CanType t, GenericEnvironment *genericEnv)
     forwardingSubs = genericEnv->getForwardingSubstitutionMap();
   }
 
-  MapLocalArchetypesOutOfContext mapOutOfContext(baseGenericSig, capturedEnvs);
-  auto mappedTy = t.subst(mapOutOfContext,
-                          MakeAbstractConformanceForGenericType(),
-                          SubstFlags::SubstituteLocalArchetypes);
+  auto mappedTy = mapLocalArchetypesOutOfContext(t, baseGenericSig, capturedEnvs);
 
   auto genericSig = buildGenericSignatureWithCapturedEnvironments(
       ctx, baseGenericSig, capturedEnvs);