Sema: Fix TypeBase::getSuperclass() for types nested in generic functions

This isn't something we care about yet, but for some reason a subsequent
patch caused some fixed compiler_crashers to regress and hit this.

Tests are in the next commit.

Author: slavapestov

lib/AST/Type.cpp

@@ -1602,7 +1602,10 @@ bool TypeBase::isSpelledLike(Type other) {
 }
 
 Type TypeBase::getSuperclass(LazyResolver *resolver) {
+  // If this type is either a bound generic type, or a nested type inside a
+  // bound generic type, we will need to fish out the generic parameters.
   Type specializedTy;
+
   ClassDecl *classDecl;
   if (auto classTy = getAs<ClassType>()) {
     classDecl = classTy->getDecl();
@@ -1622,19 +1625,31 @@ Type TypeBase::getSuperclass(LazyResolver *resolver) {
     return nullptr;
   }
 
+  // Get the superclass type. If the class is generic, the superclass type may
+  // contain generic type parameters from the signature of the class.
   Type superclassTy;
   if (classDecl)
     superclassTy = classDecl->getSuperclass();
 
-  if (!specializedTy || !superclassTy)
+  // If there's no superclass, return a null type. If the class is not in a
+  // generic context, return the original superclass type.
+  if (!superclassTy || !classDecl->isGenericContext())
     return superclassTy;
 
+  // The class is defined in a generic context, so its superclass type may refer
+  // to generic parameters of the class or some parent type of the class. Map
+  // it to a contextual type.
+
   // FIXME: Lame to rely on archetypes in the substitution below.
   superclassTy = ArchetypeBuilder::mapTypeIntoContext(classDecl, superclassTy);
 
-  // If the type is specialized, we need to gather all of the substitutions.
-  // We've already dealt with the top level, but continue gathering
-  // specializations from the parent types.
+  // If the type does not bind any generic parameters, return the superclass
+  // type as-is.
+  if (!specializedTy)
+    return superclassTy;
+
+  // If the type is specialized, we need to gather all of the substitutions
+  // for the type and any parent types.
   TypeSubstitutionMap substitutions;
   while (specializedTy) {
     if (auto nominalTy = specializedTy->getAs<NominalType>()) {
@@ -1653,7 +1668,8 @@ Type TypeBase::getSuperclass(LazyResolver *resolver) {
     specializedTy = boundTy->getParent();
   }
 
-  // Perform substitutions into the base type.
+  // Perform substitutions into the superclass type to yield the
+  // substituted superclass type.
   Module *module = classDecl->getModuleContext();
   return superclassTy.subst(module, substitutions, None);
 }