IRGen: Move getTypeRef() to a method on IRGenModule and clean up

Author: slavapestov

lib/IRGen/GenMeta.cpp

@@ -365,8 +365,8 @@ namespace {
     }
 
     void addExtendedContext() {
-      auto string = getTypeRef(IGM,
-                               E->getSelfInterfaceType()->getCanonicalType());
+      auto string = IGM.getTypeRef(
+          E->getSelfInterfaceType()->getCanonicalType());
       B.addRelativeAddress(string);
     }
 
@@ -3841,7 +3841,7 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
 
       auto flags = GenericRequirementFlags(abiKind, false, false);
       auto typeName =
-        getTypeRef(IGM, requirement.getSecondType()->getCanonicalType());
+        IGM.getTypeRef(requirement.getSecondType()->getCanonicalType());
 
       addGenericRequirement(IGM, B, metadata, sig, flags,
                             requirement.getFirstType(),

lib/IRGen/GenReflection.cpp

@@ -164,6 +164,12 @@ class PrintMetadataSource
   }
 };
 
+llvm::Constant *IRGenModule::getTypeRef(CanType type) {
+  IRGenMangler Mangler;
+  auto SymbolicName = Mangler.mangleTypeForReflection(*this, type);
+  return getAddrOfStringForTypeRef(SymbolicName);
+}
+
 class ReflectionMetadataBuilder {
 protected:
   IRGenModule &IGM;
@@ -204,32 +210,22 @@ class ReflectionMetadataBuilder {
   /// Add a 32-bit relative offset to a mangled typeref string
   /// in the typeref reflection section.
   void addTypeRef(CanType type) {
-    assert(type);
-
-    // Generic parameters should be written in terms of interface types
-    // for the purposes of reflection metadata
-    assert(!type->hasArchetype() && "Forgot to map typeref out of context");
-
-    IRGenMangler mangler;
-    auto MangledStr = mangler.mangleTypeForReflection(IGM, type);
-    auto mangledName = IGM.getAddrOfStringForTypeRef(MangledStr);
-    B.addRelativeAddress(mangledName);
+    B.addRelativeAddress(IGM.getTypeRef(type));
   }
 
   /// Add a 32-bit relative offset to a mangled nominal type string
   /// in the typeref reflection section.
   void addNominalRef(const NominalTypeDecl *nominal) {
-    IRGenMangler mangler;
-    SymbolicMangling mangledStr;
     if (auto proto = dyn_cast<ProtocolDecl>(nominal)) {
+      IRGenMangler mangler;
+      SymbolicMangling mangledStr;
       mangledStr.String = mangler.mangleBareProtocol(proto);
+      auto mangledName = IGM.getAddrOfStringForTypeRef(mangledStr);
+      B.addRelativeAddress(mangledName);
     } else {
       CanType type = nominal->getDeclaredType()->getCanonicalType();
-      mangledStr =
-        mangler.mangleTypeForReflection(IGM, type);
+      B.addRelativeAddress(IGM.getTypeRef(type));
     }
-    auto mangledName = IGM.getAddrOfStringForTypeRef(mangledStr);
-    B.addRelativeAddress(mangledName);
   }
 
   llvm::GlobalVariable *emit(Optional<LinkEntity> entity,

lib/IRGen/IRGenModule.h

@@ -970,6 +970,7 @@ class IRGenModule {
   /// reflection metadata.
   llvm::SetVector<const StructDecl *> ImportedStructs;
 
+  llvm::Constant *getTypeRef(CanType type);
   llvm::Constant *getAddrOfStringForTypeRef(StringRef mangling);
   llvm::Constant *getAddrOfStringForTypeRef(const SymbolicMangling &mangling);
   llvm::Constant *getAddrOfFieldName(StringRef Name);

lib/IRGen/MetadataRequest.cpp

@@ -297,16 +297,6 @@ llvm::Constant *IRGenModule::getAddrOfStringForTypeRef(
   return addr;
 }
 
-// FIXME: willBeRelativelyAddressed is only needed to work around an ld64 bug
-// resolving relative references to coalesceable symbols.
-// It should be removed when fixed. rdar://problem/22674524
-llvm::Constant *irgen::getTypeRef(IRGenModule &IGM, CanType type) {
-  IRGenMangler Mangler;
-  auto SymbolicName = Mangler.mangleTypeForReflection(IGM, type);
-  
-  return IGM.getAddrOfStringForTypeRef(SymbolicName);
-}
-
 llvm::Value *irgen::emitObjCMetadataRefForMetadata(IRGenFunction &IGF,
                                                    llvm::Value *classPtr) {
   assert(IGF.IGM.Context.LangOpts.EnableObjCInterop);

lib/IRGen/MetadataRequest.h

@@ -503,8 +503,6 @@ emitInPlaceTypeMetadataAccessFunctionBody(IRGenFunction &IGF,
 llvm::Value *uniqueForeignTypeMetadataRef(IRGenFunction &IGF,
                                           llvm::Value *candidate);
 
-llvm::Constant *getTypeRef(IRGenModule &IGM, CanType type);
-
 using LazyCacheEmitter =
   llvm::function_ref<MetadataResponse(IRGenFunction &IGF, Explosion &params)>;