Reflection: Some improvements to substitutions

The most important change is a fix for dependent member lookup in
bound generic TypeRefs.

The TypeRef logic here is a similified version of what Sema does,
and roughly works as follows:

When looking up a member type O.M for an original type O and
member type M, we first substitute O, to yield a concrete type S.
Then, we look up M in the serialized conformance info section
to yield the unsubstituted member type T', and apply substitutions
to produce the substituted member type T.

Trouble is, we were applying the wrong substitutions the second
time around.

If S is a bound generic type, the "base type substitutions" of S
are the substitutions required to turn the fully-abstracted
bound generic type into S. This might not be the same substitution
map that took us from O to S.

Apart from that, add some assertions that the result of a
substitution is always concrete and that the substitution map
must not contain all generic parameters referenced in the
original type.

Author: slavapestov

include/swift/Reflection/TypeRef.h

@@ -566,35 +566,25 @@ class TypeRefSubstitution
   TypeRefPointer visitBoundGenericTypeRef(const BoundGenericTypeRef *BG) {
     TypeRefVector GenericParams;
     for (auto Param : BG->getGenericParams())
-      if (auto Substituted = visit(Param.get()))
-        GenericParams.push_back(Substituted);
-      else return nullptr;
+      GenericParams.push_back(visit(Param.get()));
     return std::make_shared<BoundGenericTypeRef>(BG->getMangledName(),
                                                  GenericParams);
   }
 
   TypeRefPointer visitTupleTypeRef(const TupleTypeRef *T) {
     TypeRefVector Elements;
     for (auto Element : T->getElements()) {
-      if (auto SubstitutedElement = visit(Element.get()))
-        Elements.push_back(SubstitutedElement);
-      else
-        return nullptr;
+      Elements.push_back(visit(Element.get()));
     }
     return std::make_shared<TupleTypeRef>(Elements, T->isVariadic());
   }
 
   TypeRefPointer visitFunctionTypeRef(const FunctionTypeRef *F) {
     TypeRefVector SubstitutedArguments;
     for (auto Argument : F->getArguments())
-      if (auto SubstitutedArgument = visit(Argument.get()))
-        SubstitutedArguments.push_back(SubstitutedArgument);
-      else
-        return nullptr;
+      SubstitutedArguments.push_back(visit(Argument.get()));
 
     auto SubstitutedResult = visit(F->getResult().get());
-    if (!SubstitutedResult)
-      return nullptr;
 
     return std::make_shared<FunctionTypeRef>(SubstitutedArguments,
                                              SubstitutedResult);
@@ -610,30 +600,26 @@ class TypeRefSubstitution
   }
 
   TypeRefPointer visitMetatypeTypeRef(const MetatypeTypeRef *M) {
-    if (auto SubstitutedInstance = visit(M->getInstanceType().get()))
-      return MetatypeTypeRef::create(SubstitutedInstance);
-    else
-      return nullptr;
+    return MetatypeTypeRef::create(visit(M->getInstanceType().get()));
   }
 
   TypeRefPointer
   visitExistentialMetatypeTypeRef(const ExistentialMetatypeTypeRef *EM) {
-    if (auto SubstitutedInstance = visit(EM->getInstanceType().get()))
-      return MetatypeTypeRef::create(SubstitutedInstance);
-    else
-      return nullptr;
+    assert(EM->getInstanceType()->isConcrete());
+    return std::make_shared<ExistentialMetatypeTypeRef>(*EM);
   }
 
   TypeRefPointer
   visitGenericTypeParameterTypeRef(const GenericTypeParameterTypeRef *GTP) {
-    return Substitutions[{GTP->getDepth(), GTP->getIndex()}];
+    auto found = Substitutions.find({GTP->getDepth(), GTP->getIndex()});
+    assert(found != Substitutions.end());
+    assert(found->second->isConcrete());
+    return found->second;
   }
 
   TypeRefPointer
   visitDependentMemberTypeRef(const DependentMemberTypeRef *DM) {
     auto SubstBase = visit(DM->getBase().get());
-    if (!SubstBase || !SubstBase->isConcrete())
-      return nullptr;
 
     TypeRefPointer TypeWitness;
 
@@ -649,12 +635,11 @@ class TypeRefSubstitution
       break;
     }
     default:
-      return nullptr;
+      assert(false && "Unknown base type");
     }
-    if (!TypeWitness)
-      return nullptr;
 
-    return visit(TypeWitness.get());
+    assert(TypeWitness);
+    return TypeWitness->subst(RC, SubstBase->getSubstMap());
   }
 
   TypeRefPointer visitForeignClassTypeRef(const ForeignClassTypeRef *F) {
@@ -666,25 +651,16 @@ class TypeRefSubstitution
   }
 
   TypeRefPointer visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    if (auto SubstitutedType = visit(US->getType().get()))
-      return UnownedStorageTypeRef::create(SubstitutedType);
-    else
-      return nullptr;
+    return UnownedStorageTypeRef::create(visit(US->getType().get()));
   }
 
   TypeRefPointer visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    if (auto SubstitutedType = visit(WS->getType().get()))
-      return WeakStorageTypeRef::create(SubstitutedType);
-    else
-      return nullptr;
+    return WeakStorageTypeRef::create(visit(WS->getType().get()));
   }
 
   TypeRefPointer
   visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    if (auto SubstitutedType = visit(US->getType().get()))
-      return UnmanagedStorageTypeRef::create(SubstitutedType);
-    else
-      return nullptr;
+    return UnmanagedStorageTypeRef::create(visit(US->getType().get()));
   }
 
   TypeRefPointer visitOpaqueTypeRef(const OpaqueTypeRef *Op) {
@@ -695,7 +671,9 @@ class TypeRefSubstitution
 template <typename Runtime>
 TypeRefPointer
 TypeRef::subst(ReflectionContext<Runtime> &RC, GenericArgumentMap Subs) {
-  return TypeRefSubstitution<Runtime>(RC, Subs).visit(this);
+  TypeRefPointer Result = TypeRefSubstitution<Runtime>(RC, Subs).visit(this);
+  assert(Result->isConcrete());
+  return Result;
 }
 
 } // end namespace reflection