Add an API to map contextual types from the pack to element environment

I'm not really convinced that the existing implementation here is
correct in general; it might work for the type checker's use cases,
but I don't think we can rely on not seeing opened element archetypes
from other expansions in the type we're processing here.  But we can
at least tread water while offering a more convenient API.

Author: rjmccall

include/swift/AST/GenericEnvironment.h

@@ -277,10 +277,18 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// Map a generic parameter type to a contextual type.
   Type mapTypeIntoContext(GenericTypeParamType *type) const;
 
-  /// Map a type containing parameter packs to a contextual type
-  /// in the opened element generic context.
+  /// Map an interface type containing parameter packs to a contextual
+  /// type in the opened element generic context.
   Type mapPackTypeIntoElementContext(Type type) const;
 
+  /// Map a contextual type containing parameter packs to a contextual
+  /// type in the opened element generic context.
+  Type mapContextualPackTypeIntoElementContext(Type type) const;
+
+  /// Map a contextual type containing parameter packs to a contextual
+  /// type in the opened element generic context.
+  CanType mapContextualPackTypeIntoElementContext(CanType type) const;
+
   /// Map a type containing pack element type parameters to a contextual
   /// type in the pack generic context.
   Type mapElementTypeIntoPackContext(Type type) const;

lib/AST/GenericEnvironment.cpp

@@ -583,6 +583,29 @@ Type GenericEnvironment::mapTypeIntoContext(GenericTypeParamType *type) const {
   return result;
 }
 
+Type
+GenericEnvironment::mapContextualPackTypeIntoElementContext(Type type) const {
+  if (!type->hasArchetype()) return type;
+
+  // FIXME: this is potentially wrong if there are multiple
+  // openings in play at once, because we really shouldn't touch
+  // other element archetypes.
+  return mapPackTypeIntoElementContext(type->mapTypeOutOfContext());
+}
+
+CanType
+GenericEnvironment::mapContextualPackTypeIntoElementContext(CanType type) const {
+  if (!type->hasArchetype()) return type;
+
+  // FIXME: this is potentially wrong if there are multiple
+  // openings in play at once, because we really shouldn't touch
+  // other element archetypes.
+  // FIXME: if we do this properly, there's no way for this rewrite
+  // to produce a non-canonical type.
+  return mapPackTypeIntoElementContext(type->mapTypeOutOfContext())
+           ->getCanonicalType();
+}
+
 Type
 GenericEnvironment::mapPackTypeIntoElementContext(Type type) const {
   assert(getKind() == Kind::OpenedElement);

lib/IRGen/GenPack.cpp

@@ -328,8 +328,7 @@ static llvm::Value *emitPackExpansionElementMetadata(
   // Replace pack archetypes with element archetypes in the pattern type.
   auto instantiatedPatternTy =
       context.environment
-          ->mapPackTypeIntoElementContext(patternTy->mapTypeOutOfContext())
-          ->getCanonicalType();
+          ->mapContextualPackTypeIntoElementContext(patternTy);
 
   // Emit the element metadata.
   auto element = IGF.emitTypeMetadataRef(instantiatedPatternTy, request)
@@ -505,9 +504,7 @@ static llvm::Value *emitPackExpansionElementWitnessTable(
 
   // Replace pack archetypes with element archetypes in the pattern type.
   auto instantiatedPatternTy =
-      context.environment
-          ->mapPackTypeIntoElementContext(patternTy->mapTypeOutOfContext())
-          ->getCanonicalType();
+      context.environment->mapContextualPackTypeIntoElementContext(patternTy);
   auto instantiatedConformance =
       context.environment->getGenericSignature()->lookupConformance(
           instantiatedPatternTy, conformance.getRequirement());

lib/SILGen/SILGenApply.cpp

@@ -3837,8 +3837,8 @@ class ArgEmitter {
         auto loweredPatternType =
           expectedParamType.castTo<PackExpansionType>().getPatternType();
         auto loweredElementType =
-          openedElementEnv->mapPackTypeIntoElementContext(
-            loweredPatternType->mapTypeOutOfContext())->getCanonicalType();
+          openedElementEnv->mapContextualPackTypeIntoElementContext(
+            loweredPatternType);
         return SILType::getPrimitiveAddressType(loweredElementType);
       }();
 

lib/SILGen/SILGenPack.cpp

@@ -290,9 +290,7 @@ deriveOpenedElementTypeForPackExpansion(SILGenModule &SGM,
     OpenedElementContext::createForContextualExpansion(SGM.getASTContext(),
                                                        expansion);
   auto elementType =
-    context.environment->mapPackTypeIntoElementContext(
-                           patternType->mapTypeOutOfContext())
-                       ->getCanonicalType();
+    context.environment->mapContextualPackTypeIntoElementContext(patternType);
   return std::make_pair(context.environment,
                         SILType::getPrimitiveAddressType(elementType));
 }
@@ -485,8 +483,7 @@ void InPlacePackExpansionInitialization::
     // This AST-level transformation is fine on lowered types because
     // we're just replacing pack archetypes with element archetypes.
     loweredPatternTy =
-      env->mapPackTypeIntoElementContext(
-        loweredPatternTy->mapTypeOutOfContext())->getCanonicalType();
+      env->mapContextualPackTypeIntoElementContext(loweredPatternTy);
   }
   auto eltAddrTy = SILType::getPrimitiveAddressType(loweredPatternTy);