Reflection: Move field and associated type metadata parsing from ReflectionContext to TypeRefBuilder, NFC

ReflectionContext is now solely concerned with converting runtime
metadata in a remote address space into a TypeRef.

TypeRefBuilder now knows how to parse reflection metadata, and
in particular look up associated type witnesses. This decouples
the TypeRef substitution code from the ReflectionContext. Now
substitution only needs a TypeRefBuilder, which means the code
is no longer templated, and can be moved from TypeRef.h to
TypeRef.cpp.

This also allows the upcoming TypeRef lowering code to live in
a source file instead of headers.

Author: slavapestov

include/swift/Reflection/ReflectionContext.h

@@ -41,54 +41,10 @@ class ReflectionContext
   using super = remote::MetadataReader<Runtime, TypeRefBuilder>;
 
 public:
-  using super::decodeMangledType;
+  using super::getBuilder;
   using super::readTypeFromMetadata;
   using typename super::StoredPointer;
 
-private:
-
-  std::vector<ReflectionInfo> ReflectionInfos;
-
-  void dumpTypeRef(const std::string &MangledName,
-                   std::ostream &OS, bool printTypeName = false) {
-    auto TypeName = Demangle::demangleTypeAsString(MangledName);
-    OS << TypeName << '\n';
-
-    auto DemangleTree = Demangle::demangleTypeAsNode(MangledName);
-    auto TR = decodeMangledType(DemangleTree);
-    if (!TR) {
-      OS << "!!! Invalid typeref: " << MangledName << '\n';
-      return;
-    }
-    TR->dump(OS);
-    OS << '\n';
-  }
-
-  const AssociatedTypeDescriptor *
-  lookupAssociatedTypes(const std::string &MangledTypeName,
-                        const DependentMemberTypeRef *DependentMember) {
-    // Cache missed - we need to look through all of the assocty sections
-    // for all images that we've been notified about.
-    for (auto &Info : ReflectionInfos) {
-      for (const auto &AssocTyDescriptor : Info.assocty) {
-        std::string ConformingTypeName(AssocTyDescriptor.ConformingTypeName);
-        if (ConformingTypeName.compare(MangledTypeName) != 0)
-          continue;
-        std::string ProtocolMangledName(AssocTyDescriptor.ProtocolTypeName);
-        auto DemangledProto = Demangle::demangleTypeAsNode(ProtocolMangledName);
-        auto TR = decodeMangledType(DemangledProto);
-
-        auto &Conformance = *DependentMember->getProtocol();
-        if (auto Protocol = dyn_cast<ProtocolTypeRef>(TR)) {
-          if (*Protocol != Conformance)
-            continue;
-          return &AssocTyDescriptor;
-        }
-      }
-    }
-    return nullptr;
-  }
-
 public:
 
   explicit ReflectionContext(std::shared_ptr<MemoryReader> reader)
@@ -101,137 +57,13 @@ class ReflectionContext
     return *this->Reader;
   }
 
-  void dumpFieldSection(std::ostream &OS) {
-    for (const auto &sections : ReflectionInfos) {
-      for (const auto &descriptor : sections.fieldmd) {
-        auto TypeName
-          = Demangle::demangleTypeAsString(descriptor.getMangledTypeName());
-        OS << TypeName << '\n';
-        for (size_t i = 0; i < TypeName.size(); ++i)
-          OS << '-';
-        OS << '\n';
-        for (auto &field : descriptor) {
-          OS << field.getFieldName();
-          if (field.hasMangledTypeName()) {
-            OS << ": ";
-            dumpTypeRef(field.getMangledTypeName(), OS);
-          } else {
-            OS << "\n\n";
-          }
-        }
-      }
-    }
-  }
-
-  void dumpAssociatedTypeSection(std::ostream &OS) {
-    for (const auto &sections : ReflectionInfos) {
-      for (const auto &descriptor : sections.assocty) {
-        auto conformingTypeName = Demangle::demangleTypeAsString(
-          descriptor.getMangledConformingTypeName());
-        auto protocolName = Demangle::demangleTypeAsString(
-          descriptor.getMangledProtocolTypeName());
-
-        OS << "- " << conformingTypeName << " : " << protocolName;
-        OS << '\n';
-
-        for (const auto &associatedType : descriptor) {
-          OS << "typealias " << associatedType.getName() << " = ";
-          dumpTypeRef(associatedType.getMangledSubstitutedTypeName(), OS);
-        }
-      }
-    }
-  }
-
-  void dumpBuiltinTypeSection(std::ostream &OS) {
-    for (const auto &sections : ReflectionInfos) {
-      for (const auto &descriptor : sections.builtin) {
-        auto typeName = Demangle::demangleTypeAsString(
-          descriptor.getMangledTypeName());
-
-        OS << "\n- " << typeName << ":\n";
-        OS << "Size: " << descriptor.Size << "\n";
-        OS << "Alignment: " << descriptor.Alignment << "\n";
-        OS << "Stride: " << descriptor.Stride << "\n";
-        OS << "NumExtraInhabitants: " << descriptor.NumExtraInhabitants << "\n";
-      }
-    }
-  }
-
   void dumpAllSections(std::ostream &OS) {
-    OS << "FIELDS:\n";
-    OS << "=======\n";
-    dumpFieldSection(OS);
-    OS << '\n';
-    OS << "ASSOCIATED TYPES:\n";
-    OS << "=================\n";
-    dumpAssociatedTypeSection(OS);
-    OS << '\n';
-    OS << "BUILTIN TYPES:\n";
-    OS << "==============\n";
-    dumpBuiltinTypeSection(OS);
-    OS << '\n';
-  }
-
-  const TypeRef *
-  getDependentMemberTypeRef(const std::string &MangledTypeName,
-                            const DependentMemberTypeRef *DependentMember) {
-
-    if (auto AssocTys = lookupAssociatedTypes(MangledTypeName, DependentMember)) {
-      for (auto &AssocTy : *AssocTys) {
-        if (DependentMember->getMember().compare(AssocTy.getName()) != 0)
-          continue;
-
-        auto SubstitutedTypeName = AssocTy.getMangledSubstitutedTypeName();
-        auto Demangled = Demangle::demangleTypeAsNode(SubstitutedTypeName);
-        return decodeMangledType(Demangled);
-      }
-    }
-    return nullptr;
+    getBuilder().dumpAllSections();
   }
 
   std::vector<std::pair<std::string, const TypeRef *>>
   getFieldTypeRefs(const TypeRef *TR) {
-    std::string MangledName;
-    if (auto N = dyn_cast<NominalTypeRef>(TR))
-      MangledName = N->getMangledName();
-    else if (auto BG = dyn_cast<BoundGenericTypeRef>(TR))
-      MangledName = BG->getMangledName();
-    else
-      return {};
-
-    auto Subs = TR->getSubstMap();
-
-    std::vector<std::pair<std::string, const TypeRef *>> Fields;
-    for (auto Info : ReflectionInfos) {
-      for (auto &FieldDescriptor : Info.fieldmd) {
-        auto CandidateMangledName = FieldDescriptor.MangledTypeName.get();
-        if (!CandidateMangledName)
-          continue;
-        if (MangledName.compare(CandidateMangledName) != 0)
-          continue;
-        for (auto &Field : FieldDescriptor) {
-          auto FieldName = Field.getFieldName();
-
-          // Empty cases of enums do not have a type
-          if (!Field.hasMangledTypeName()) {
-            Fields.push_back({FieldName, nullptr});
-            continue;
-          }
-
-          auto Demangled
-            = Demangle::demangleTypeAsNode(Field.getMangledTypeName());
-          auto Unsubstituted = decodeMangledType(Demangled);
-          if (!Unsubstituted)
-            return {};
-
-          auto Substituted = Unsubstituted->subst(*this, Subs);
-          if (FieldName.empty())
-            FieldName = "<Redacted Field Name>";
-          Fields.push_back({FieldName, Substituted});
-        }
-      }
-    }
-    return Fields;
+    return getBuilder().getFieldTypeRefs(TR);
   }
 
   std::vector<std::pair<std::string, const TypeRef *>>
@@ -241,7 +73,7 @@ class ReflectionContext
   }
 
   void addReflectionInfo(ReflectionInfo I) {
-    ReflectionInfos.push_back(I);
+    getBuilder().addReflectionInfo(I);
   }
 
   swift_typeinfo_t getInfoForTypeRef(const TypeRef *TR) {

include/swift/Reflection/TypeRef.h

@@ -26,11 +26,6 @@
 namespace swift {
 namespace reflection {
 
-template <typename Allocator>
-class ReflectionContext;
-
-struct ReflectionInfo;
-
 using llvm::cast;
 using llvm::dyn_cast;
 
@@ -41,6 +36,7 @@ enum class TypeRefKind {
 };
 
 class TypeRef;
+class TypeRefBuilder;
 using DepthAndIndex = std::pair<unsigned, unsigned>;
 using GenericArgumentMap = llvm::DenseMap<DepthAndIndex, const TypeRef *>;
 
@@ -59,9 +55,8 @@ class alignas(void *) TypeRef {
 
   bool isConcrete() const;
 
-  template <typename Runtime>
   const TypeRef *
-  subst(ReflectionContext<Runtime> &RC, GenericArgumentMap Subs) const;
+  subst(TypeRefBuilder &Builder, GenericArgumentMap Subs) const;
 
   GenericArgumentMap getSubstMap() const;
 
@@ -520,139 +515,6 @@ class TypeRefVisitor {
   }
 };
 
-template <typename Runtime>
-class TypeRefSubstitution
-  : public TypeRefVisitor<TypeRefSubstitution<Runtime>, const TypeRef *> {
-  using StoredPointer = typename Runtime::StoredPointer;
-  ReflectionContext<Runtime> &RC;
-  GenericArgumentMap Substitutions;
-public:
-  using TypeRefVisitor<TypeRefSubstitution<Runtime>, const TypeRef *>::visit;
-  TypeRefSubstitution(ReflectionContext<Runtime> &RC,
-                      GenericArgumentMap Substitutions)
-  : RC(RC),
-    Substitutions(Substitutions) {}
-
-  const TypeRef *visitBuiltinTypeRef(const BuiltinTypeRef *B) {
-    return B;
-  }
-
-  const TypeRef *visitNominalTypeRef(const NominalTypeRef *N) {
-    return N;
-  }
-
-  const TypeRef *visitBoundGenericTypeRef(const BoundGenericTypeRef *BG) {
-    std::vector<const TypeRef *> GenericParams;
-    for (auto Param : BG->getGenericParams())
-      GenericParams.push_back(visit(Param));
-    return BoundGenericTypeRef::create(RC.Builder, BG->getMangledName(),
-                                       GenericParams);
-  }
-
-  const TypeRef *visitTupleTypeRef(const TupleTypeRef *T) {
-    std::vector<const TypeRef *> Elements;
-    for (auto Element : T->getElements()) {
-      Elements.push_back(visit(Element));
-    }
-    return TupleTypeRef::create(RC.Builder, Elements);
-  }
-
-  const TypeRef *visitFunctionTypeRef(const FunctionTypeRef *F) {
-    std::vector<const TypeRef *> SubstitutedArguments;
-    for (auto Argument : F->getArguments())
-      SubstitutedArguments.push_back(visit(Argument));
-
-    auto SubstitutedResult = visit(F->getResult());
-
-    return FunctionTypeRef::create(RC.Builder, SubstitutedArguments,
-                                   SubstitutedResult);
-  }
-
-  const TypeRef *visitProtocolTypeRef(const ProtocolTypeRef *P) {
-    return P;
-  }
-
-  const TypeRef *
-  visitProtocolCompositionTypeRef(const ProtocolCompositionTypeRef *PC) {
-    return PC;
-  }
-
-  const TypeRef *visitMetatypeTypeRef(const MetatypeTypeRef *M) {
-    return MetatypeTypeRef::create(RC.Builder, visit(M->getInstanceType()));
-  }
-
-  const TypeRef *
-  visitExistentialMetatypeTypeRef(const ExistentialMetatypeTypeRef *EM) {
-    assert(EM->getInstanceType()->isConcrete());
-    return EM;
-  }
-
-  const TypeRef *
-  visitGenericTypeParameterTypeRef(const GenericTypeParameterTypeRef *GTP) {
-    auto found = Substitutions.find({GTP->getDepth(), GTP->getIndex()});
-    assert(found != Substitutions.end());
-    assert(found->second->isConcrete());
-    return found->second;
-  }
-
-  const TypeRef *visitDependentMemberTypeRef(const DependentMemberTypeRef *DM) {
-    auto SubstBase = visit(DM->getBase());
-
-    const TypeRef *TypeWitness;
-
-    switch (SubstBase->getKind()) {
-    case TypeRefKind::Nominal: {
-      auto Nominal = cast<NominalTypeRef>(SubstBase);
-      TypeWitness = RC.getDependentMemberTypeRef(Nominal->getMangledName(), DM);
-      break;
-    }
-    case TypeRefKind::BoundGeneric: {
-      auto BG = cast<BoundGenericTypeRef>(SubstBase);
-      TypeWitness = RC.getDependentMemberTypeRef(BG->getMangledName(), DM);
-      break;
-    }
-    default:
-      assert(false && "Unknown base type");
-    }
-
-    assert(TypeWitness);
-    return TypeWitness->subst(RC, SubstBase->getSubstMap());
-  }
-
-  const TypeRef *visitForeignClassTypeRef(const ForeignClassTypeRef *F) {
-    return F;
-  }
-
-  const TypeRef *visitObjCClassTypeRef(const ObjCClassTypeRef *OC) {
-    return OC;
-  }
-
-  const TypeRef *visitUnownedStorageTypeRef(const UnownedStorageTypeRef *US) {
-    return UnownedStorageTypeRef::create(RC.Builder, visit(US->getType()));
-  }
-
-  const TypeRef *visitWeakStorageTypeRef(const WeakStorageTypeRef *WS) {
-    return WeakStorageTypeRef::create(RC.Builder, visit(WS->getType()));
-  }
-
-  const TypeRef *
-  visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
-    return UnmanagedStorageTypeRef::create(RC.Builder, visit(US->getType()));
-  }
-
-  const TypeRef *visitOpaqueTypeRef(const OpaqueTypeRef *Op) {
-    return Op;
-  }
-};
-
-template <typename Runtime>
-const TypeRef *
-TypeRef::subst(ReflectionContext<Runtime> &RC, GenericArgumentMap Subs) const {
-  const TypeRef *Result = TypeRefSubstitution<Runtime>(RC, Subs).visit(this);
-  assert(Result->isConcrete());
-  return Result;
-}
-
 } // end namespace reflection
 } // end namespace swift