AST: Assert if mapTypeIntoContext()/mapTypeOutOfContext() used on the wrong sort of type

Also, bail out earlier if we know we have no work to do.

Author: slavapestov

lib/AST/ArchetypeBuilder.cpp

@@ -2020,13 +2020,7 @@ void ArchetypeBuilder::dump(llvm::raw_ostream &out) {
 
 Type ArchetypeBuilder::mapTypeIntoContext(const DeclContext *dc, Type type,
                                           LazyResolver *resolver) {
-  // If the type is not dependent, there's nothing to map.
-  if (!type->hasTypeParameter())
-    return type;
-
   auto genericParams = dc->getGenericParamsOfContext();
-  assert(genericParams && "Missing generic parameters for dependent context");
-  
   return mapTypeIntoContext(dc->getParentModule(), genericParams, type,
                             resolver);
 }
@@ -2035,13 +2029,15 @@ Type ArchetypeBuilder::mapTypeIntoContext(Module *M,
                                           GenericParamList *genericParams,
                                           Type type,
                                           LazyResolver *resolver) {
-  // If the type is not dependent, or we have no generic params, there's nothing
-  // to map.
-  if (!genericParams || !type->hasTypeParameter())
+  auto canType = type->getCanonicalType();
+  assert(!canType->hasArchetype() && "already have a contextual type");
+  if (!canType->hasTypeParameter())
     return type;
 
+  assert(genericParams && "dependent type in non-generic context");
+
   unsigned genericParamsDepth = genericParams->getDepth();
-  return type.transform([&](Type type) -> Type {
+  type = type.transform([&](Type type) -> Type {
     // Map a generic parameter type to its archetype.
     if (auto gpType = type->getAs<GenericTypeParamType>()) {
       auto index = gpType->getIndex();
@@ -2064,7 +2060,7 @@ Type ArchetypeBuilder::mapTypeIntoContext(Module *M,
       if (!myGenericParams->getAllArchetypes().empty())
         return myGenericParams->getPrimaryArchetypes()[index];
 
-      // During type-checking, we may try to mapTypeInContext before
+      // During type-checking, we may try to mapTypeIntoContext before
       // AllArchetypes has been built, so fall back to the generic params.
       return myGenericParams->getParams()[index]->getArchetype();
     }
@@ -2078,6 +2074,9 @@ Type ArchetypeBuilder::mapTypeIntoContext(Module *M,
 
     return type;
   });
+
+  assert(!type->hasTypeParameter() && "not fully substituted");
+  return type;
 }
 
 Type
@@ -2089,10 +2088,13 @@ ArchetypeBuilder::mapTypeOutOfContext(const DeclContext *dc, Type type) {
 Type ArchetypeBuilder::mapTypeOutOfContext(ModuleDecl *M,
                                            GenericParamList *genericParams,
                                            Type type) {
-  // If the context is non-generic, we're done.
-  if (!genericParams)
+  auto canType = type->getCanonicalType();
+  assert(!canType->hasTypeParameter() && "already have an interface type");
+  if (!canType->hasArchetype())
     return type;
 
+  assert(genericParams && "dependent type in non-generic context");
+
   // Capture the archetype -> interface type mapping.
   TypeSubstitutionMap subs;
   for (auto params = genericParams; params != nullptr;
@@ -2102,7 +2104,10 @@ Type ArchetypeBuilder::mapTypeOutOfContext(ModuleDecl *M,
     }
   }
 
-  return type.subst(M, subs, SubstFlags::AllowLoweredTypes);
+  type = type.subst(M, subs, SubstFlags::AllowLoweredTypes);
+
+  assert(!type->hasArchetype() && "not fully substituted");
+  return type;
 }
 
 bool ArchetypeBuilder::addGenericSignature(GenericSignature *sig,