AST: Use GenericEnvironment in ArchetypeBuilder::mapType{Into,OutOf}Context()

When we call the DeclContext variants of these, use the
DeclContext's GenericEnvironment instead of GenericParamList.

Also, these functions would take a resolver argument, but we
always passed in nullptr, so just remove it now.

The old GenericParamList-based versions are still there
since they're called directly from SIL. They will go away
once SILFunction::ContextGenericParams is replaced with
a GenericEnvironment.

Author: slavapestov

include/swift/AST/ArchetypeBuilder.h

@@ -329,18 +329,26 @@ class ArchetypeBuilder {
   ArrayRef<ArchetypeType *> getAllArchetypes();
 
   /// Map an interface type to a contextual type.
-  static Type mapTypeIntoContext(const DeclContext *dc, Type type,
-                                 LazyResolver *resolver = nullptr);
+  static Type mapTypeIntoContext(const DeclContext *dc, Type type);
 
   /// Map an interface type to a contextual type.
   static Type mapTypeIntoContext(ModuleDecl *M,
-                                 GenericParamList *genericParams,
-                                 Type type,
-                                 LazyResolver *resolver = nullptr);
+                                 GenericEnvironment *genericEnv,
+                                 Type type);
 
   /// Map a contextual type to an interface type.
   static Type mapTypeOutOfContext(const DeclContext *dc, Type type);
 
+  /// Map a contextual type to an interface type.
+  static Type mapTypeOutOfContext(ModuleDecl *M,
+                                  GenericEnvironment *genericEnv,
+                                  Type type);
+
+  /// Map an interface type to a contextual type.
+  static Type mapTypeIntoContext(ModuleDecl *M,
+                                 GenericParamList *genericParams,
+                                 Type type);
+
   /// Map a contextual type to an interface type.
   static Type mapTypeOutOfContext(ModuleDecl *M,
                                   GenericParamList *genericParams,

lib/AST/ArchetypeBuilder.cpp

@@ -2011,17 +2011,49 @@ void ArchetypeBuilder::dump(llvm::raw_ostream &out) {
   out << "\n";
 }
 
-Type ArchetypeBuilder::mapTypeIntoContext(const DeclContext *dc, Type type,
-                                          LazyResolver *resolver) {
-  auto genericParams = dc->getGenericParamsOfContext();
-  return mapTypeIntoContext(dc->getParentModule(), genericParams, type,
-                            resolver);
+Type ArchetypeBuilder::mapTypeIntoContext(const DeclContext *dc, Type type) {
+  return mapTypeIntoContext(dc->getParentModule(),
+                            dc->getGenericEnvironmentOfContext(),
+                            type);
+}
+
+Type ArchetypeBuilder::mapTypeIntoContext(ModuleDecl *M,
+                                          GenericEnvironment *env,
+                                          Type type) {
+  auto canType = type->getCanonicalType();
+  assert(!canType->hasArchetype() && "already have a contextual type");
+  if (!canType->hasTypeParameter())
+    return type;
+
+  assert(env && "dependent type in non-generic context");
+
+  return env->mapTypeIntoContext(M, type);
+}
+
+Type
+ArchetypeBuilder::mapTypeOutOfContext(const DeclContext *dc, Type type) {
+  return mapTypeOutOfContext(dc->getParentModule(),
+                             dc->getGenericEnvironmentOfContext(),
+                             type);
+}
+
+Type
+ArchetypeBuilder::mapTypeOutOfContext(ModuleDecl *M,
+                                      GenericEnvironment *env,
+                                      Type type) {
+  auto canType = type->getCanonicalType();
+  assert(!canType->hasTypeParameter() && "already have an interface type");
+  if (!canType->hasArchetype())
+    return type;
+
+  assert(env && "dependent type in non-generic context");
+
+  return env->mapTypeOutOfContext(M, type);
 }
 
 Type ArchetypeBuilder::mapTypeIntoContext(Module *M,
                                           GenericParamList *genericParams,
-                                          Type type,
-                                          LazyResolver *resolver) {
+                                          Type type) {
   auto canType = type->getCanonicalType();
   assert(!canType->hasArchetype() && "already have a contextual type");
   if (!canType->hasTypeParameter())
@@ -2053,8 +2085,8 @@ Type ArchetypeBuilder::mapTypeIntoContext(Module *M,
     // Map a dependent member to the corresponding nested archetype.
     if (auto dependentMember = type->getAs<DependentMemberType>()) {
       auto base = mapTypeIntoContext(M, genericParams,
-                                     dependentMember->getBase(), resolver);
-      return dependentMember->substBaseType(M, base, resolver);
+                                     dependentMember->getBase());
+      return dependentMember->substBaseType(M, base);
     }
 
     return type;
@@ -2064,12 +2096,6 @@ Type ArchetypeBuilder::mapTypeIntoContext(Module *M,
   return type;
 }
 
-Type
-ArchetypeBuilder::mapTypeOutOfContext(const DeclContext *dc, Type type) {
-  GenericParamList *genericParams = dc->getGenericParamsOfContext();
-  return mapTypeOutOfContext(dc->getParentModule(), genericParams, type);
-}
-
 Type ArchetypeBuilder::mapTypeOutOfContext(ModuleDecl *M,
                                            GenericParamList *genericParams,
                                            Type type) {

lib/IRGen/GenMeta.cpp

@@ -236,7 +236,7 @@ static void emitPolymorphicParametersFromArray(IRGenFunction &IGF,
   array = IGF.Builder.CreateElementBitCast(array, IGF.IGM.TypeMetadataPtrTy);
 
   auto getInContext = [&](CanType type) -> CanType {
-    return ArchetypeBuilder::mapTypeIntoContext(typeDecl, type, nullptr)
+    return ArchetypeBuilder::mapTypeIntoContext(typeDecl, type)
              ->getCanonicalType();
   };
 
@@ -2767,7 +2767,7 @@ irgen::emitFieldTypeAccessor(IRGenModule &IGM,
     auto declCtxt = type;
     if (auto generics = declCtxt->getGenericSignatureOfContext()) {
       auto getInContext = [&](CanType type) -> CanType {
-        return ArchetypeBuilder::mapTypeIntoContext(declCtxt, type, nullptr)
+        return ArchetypeBuilder::mapTypeIntoContext(declCtxt, type)
             ->getCanonicalType();
       };
       bindArchetypeAccessPaths(IGF, generics, getInContext);

lib/IRGen/GenProto.cpp

@@ -1281,7 +1281,7 @@ class AccessorConformanceInfo : public ConformanceInfo {
       auto declCtx = Conformance.getDeclContext();
       if (auto generics = declCtx->getGenericSignatureOfContext()) {
         auto getInContext = [&](CanType type) -> CanType {
-          return ArchetypeBuilder::mapTypeIntoContext(declCtx, type, nullptr)
+          return ArchetypeBuilder::mapTypeIntoContext(declCtx, type)
               ->getCanonicalType();
         };
         bindArchetypeAccessPaths(IGF, generics, getInContext);

lib/SILGen/SILGenBridging.cpp

@@ -1282,8 +1282,9 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
     auto fnType = fn->getType().castTo<SILFunctionType>();
     fnType = fnType->substGenericArgs(SGM.M, SGM.SwiftModule, subs);
 
-    CanType substResultTy{
-        ArchetypeBuilder::mapTypeIntoContext(fd, nativeFormalResultTy)};
+    auto substResultTy =
+        ArchetypeBuilder::mapTypeIntoContext(fd, nativeFormalResultTy)
+            ->getCanonicalType();
 
     auto resultMV = emitApply(fd, ManagedValue::forUnmanaged(fn),
                        subs, args, fnType,