[IRGen] Skip reemitting fields referenced by type context descriptor.

When reemitting a type context descriptor, several fields
- method lookup function
- dispatch thunk
- nonoverride method descriptor
were previously being reemitted.

In a couple of earlier commits, that behavior was altered to delete the
fields before reemitting them.

  3ad2777 [IRGen] Erase nonoverride descriptor on emission.
  c25c180 [IRGen] Erase thunks before emission.

Here, the behavior is changed to simply exit early when these fields are
being reemitted.  Also an assertion is added that these fields are
redefined only when reemitting the type context descriptor.

Author: nate-chandler

lib/IRGen/GenDecl.cpp

@@ -1168,6 +1168,7 @@ static void
 deleteAndReenqueueForEmissionValuesDependentOnCanonicalPrespecializedMetadataRecords(
     IRGenModule &IGM, CanType typeWithCanonicalMetadataPrespecialization,
     NominalTypeDecl &decl) {
+  IGM.IRGen.noteLazyReemissionOfNominalTypeDescriptor(&decl);
   // The type context descriptor depends on canonical metadata records because
   // pointers to them are attached as trailing objects to it.
   //

lib/IRGen/GenMeta.cpp

@@ -301,10 +301,12 @@ static void buildMethodDescriptorFields(IRGenModule &IGM,
 void IRGenModule::emitNonoverriddenMethodDescriptor(const SILVTable *VTable,
                                                     SILDeclRef declRef) {
   auto entity = LinkEntity::forMethodDescriptor(declRef);
-
   auto *var = cast<llvm::GlobalVariable>(getAddrOfLLVMVariable(entity, ConstantInit(), DebugTypeInfo()));
-  var->setInitializer(nullptr);
- 
+  if (!var->isDeclaration()) {
+    assert(IRGen.isLazilyReemittingNominalTypeDescriptor(VTable->getClass()));
+    return;
+  }
+
   ConstantInitBuilder ib(*this);
   ConstantStructBuilder sb(ib.beginStruct(MethodDescriptorStructTy));
 

lib/IRGen/GenThunk.cpp

@@ -103,7 +103,7 @@ static FunctionPointer lookupMethod(IRGenFunction &IGF, SILDeclRef declRef) {
 void IRGenModule::emitDispatchThunk(SILDeclRef declRef) {
   auto *f = getAddrOfDispatchThunk(declRef, ForDefinition);
   if (!f->isDeclaration()) {
-    f->deleteBody();
+    return;
   }
 
   IRGenFunction IGF(*this, f);
@@ -167,7 +167,8 @@ IRGenModule::getAddrOfMethodLookupFunction(ClassDecl *classDecl,
 void IRGenModule::emitMethodLookupFunction(ClassDecl *classDecl) {
   auto *f = getAddrOfMethodLookupFunction(classDecl, ForDefinition);
   if (!f->isDeclaration()) {
-    f->deleteBody();
+    assert(IRGen.isLazilyReemittingNominalTypeDescriptor(classDecl));
+    return;
   }
 
   IRGenFunction IGF(*this, f);

lib/IRGen/IRGenModule.h

@@ -279,6 +279,8 @@ class IRGenerator {
   llvm::SmallVector<std::pair<CanType, TypeMetadataCanonicality>, 4>
       LazySpecializedTypeMetadataRecords;
 
+  llvm::SmallPtrSet<NominalTypeDecl *, 4> LazilyReemittedTypeContextDescriptors;
+
   /// The queue of metadata accessors to emit.
   ///
   /// The accessors must be emitted after everything else which might result in
@@ -436,6 +438,15 @@ class IRGenerator {
     return MetadataPrespecializationsForGenericTypes.lookup(type);
   }
 
+  void noteLazyReemissionOfNominalTypeDescriptor(NominalTypeDecl *decl) {
+    LazilyReemittedTypeContextDescriptors.insert(decl);
+  }
+
+  bool isLazilyReemittingNominalTypeDescriptor(NominalTypeDecl *decl) {
+    return LazilyReemittedTypeContextDescriptors.find(decl) !=
+           std::end(LazilyReemittedTypeContextDescriptors);
+  }
+
   void noteUseOfMetadataAccessor(NominalTypeDecl *decl) {
     if (LazyMetadataAccessors.count(decl) == 0) {
       LazyMetadataAccessors.insert(decl);