SILGen: Simplify delayed conformance emission

Instead of visiting all types in the ExternalDefinitions list and
queuing up their conformances, just emit conformances as needed
when they are first referenced.

Author: slavapestov

lib/SILGen/SILGen.cpp

@@ -1747,16 +1747,15 @@ SILModule::constructSIL(ModuleDecl *mod, SILOptions &options, FileUnit *SF) {
   // Emitting these may in turn force more definitions, so we have to take care
   // to keep pumping the queues.
   while (!SGM.forcedFunctions.empty()
-         || !SGM.forcedConformances.empty()) {
+         || !SGM.pendingConformances.empty()) {
     while (!SGM.forcedFunctions.empty()) {
       auto &front = SGM.forcedFunctions.front();
       front.second.emitter(SGM.getFunction(front.first, ForDefinition));
       SGM.forcedFunctions.pop_front();
     }
-    while (!SGM.forcedConformances.empty()) {
-      auto &front = SGM.forcedConformances.front();
-      SGM.getWitnessTable(front.first);
-      SGM.forcedConformances.pop_front();
+    while (!SGM.pendingConformances.empty()) {
+      SGM.getWitnessTable(SGM.pendingConformances.front());
+      SGM.pendingConformances.pop_front();
     }
   }
 

lib/SILGen/SILGen.h

@@ -77,28 +77,16 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// The most recent declaration we considered for emission.
   SILDeclRef lastEmittedFunction;
 
-  /// Set of used conformances for which witness tables need to be emitted.
-  llvm::DenseSet<RootProtocolConformance *> usedConformances;
-
   /// Bookkeeping to ensure that useConformancesFrom{ObjectiveC,}Type() is
   /// only called once for each unique type, as an optimization.
   llvm::DenseSet<TypeBase *> usedConformancesFromTypes;
   llvm::DenseSet<TypeBase *> usedConformancesFromObjectiveCTypes;
 
-  struct DelayedWitnessTable {
-    NormalProtocolConformance *insertAfter;
-  };
-
-  /// Set of conformances we delayed emitting witness tables for.
-  llvm::DenseMap<NormalProtocolConformance *, DelayedWitnessTable>
-    delayedConformances;
+  /// Queue of delayed conformances that need to be emitted.
+  std::deque<NormalProtocolConformance *> pendingConformances;
 
-  /// Queue of delayed conformances that need to be forced.
-  std::deque<std::pair<NormalProtocolConformance *, DelayedWitnessTable>>
-    forcedConformances;
-
-  /// The most recent conformance...
-  NormalProtocolConformance *lastEmittedConformance = nullptr;
+  /// Set of delayed conformances that have already been forced.
+  llvm::DenseSet<NormalProtocolConformance *> forcedConformances;
 
   /// Profiler instances for constructors, grouped by associated decl.
   /// Each profiler is shared by all member initializers for a nominal type.
@@ -279,9 +267,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// Emit SIL related to a Clang-imported declaration.
   void emitExternalDefinition(Decl *d);
 
-  /// Emit SIL related to a Clang-imported declaration.
-  void emitExternalWitnessTable(NormalProtocolConformance *d);
-
   /// Emit the ObjC-compatible entry point for a method.
   void emitObjCMethodThunk(FuncDecl *method);
 

lib/SILGen/SILGenDecl.cpp

@@ -1391,17 +1391,6 @@ CleanupHandle SILGenFunction::enterDeinitExistentialCleanup(
   return Cleanups.getTopCleanup();
 }
 
-void SILGenModule::emitExternalWitnessTable(NormalProtocolConformance *c) {
-  // Emit the witness table right now if we used it.
-  if (usedConformances.count(c)) {
-    getWitnessTable(c);
-    return;
-  }
-  // Otherwise, remember it for later.
-  delayedConformances.insert({c, {lastEmittedConformance}});
-  lastEmittedConformance = c;
-}
-
 static bool isDeclaredInPrimaryFile(SILModule &M, Decl *d) {
   auto *dc = d->getDeclContext();
   if (auto *sf = dyn_cast<SourceFile>(dc->getModuleScopeContext()))
@@ -1433,22 +1422,9 @@ void SILGenModule::emitExternalDefinition(Decl *d) {
   }
   case DeclKind::Enum:
   case DeclKind::Struct:
-  case DeclKind::Class: {
-    // Emit witness tables.
-    auto nom = cast<NominalTypeDecl>(d);
-    for (auto c : nom->getLocalConformances(ConformanceLookupKind::NonInherited,
-                                            nullptr)) {
-      auto *proto = c->getProtocol();
-      if (Lowering::TypeConverter::protocolRequiresWitnessTable(proto) &&
-          isa<NormalProtocolConformance>(c)) {
-        emitExternalWitnessTable(cast<NormalProtocolConformance>(c));
-      }
-    }
-    break;
-  }
-
+  case DeclKind::Class:
   case DeclKind::Protocol:
-    // Nothing to do in SILGen for other external types.
+    // Nothing to do in SILGen for external types.
     break;
 
   case DeclKind::Var:

lib/SILGen/SILGenLazyConformance.cpp

@@ -53,16 +53,11 @@ void SILGenModule::useConformance(ProtocolConformanceRef conformanceRef) {
   if (emittedWitnessTables.count(normal))
     return;
 
-  // If we delayed emitting this witness table, force it.
-  auto foundDelayed = delayedConformances.find(normal);
-  if (foundDelayed != delayedConformances.end()) {
-    forcedConformances.push_back(*foundDelayed);
-    delayedConformances.erase(foundDelayed);
+  // Check if we already forced this witness table but haven't emitted it yet.
+  if (!forcedConformances.insert(normal).second)
     return;
-  }
 
-  // Otherwise, just remember the fact we used this conformance.
-  usedConformances.insert(normal);
+  pendingConformances.push_back(normal);
 }
 
 void SILGenModule::useConformancesFromSubstitutions(

lib/SILGen/SILGenType.cpp

@@ -545,27 +545,6 @@ class SILGenConformance : public SILGenWitnessTable<SILGenConformance> {
 
 } // end anonymous namespace
 
-static SILWitnessTable *
-getWitnessTableToInsertAfter(SILGenModule &SGM,
-                             NormalProtocolConformance *insertAfter) {
-  while (insertAfter) {
-    // If the table was emitted, emit after it.
-    auto found = SGM.emittedWitnessTables.find(insertAfter);
-    if (found != SGM.emittedWitnessTables.end())
-      return found->second;
-
-    // Otherwise, try inserting after the table we would transitively be
-    // inserted after.
-    auto foundDelayed = SGM.delayedConformances.find(insertAfter);
-    if (foundDelayed != SGM.delayedConformances.end())
-      insertAfter = foundDelayed->second.insertAfter;
-    else
-      break;
-  }
-
-  return nullptr;
-}
-
 SILWitnessTable *
 SILGenModule::getWitnessTable(NormalProtocolConformance *conformance) {
   // If we've already emitted this witness table, return it.
@@ -576,23 +555,6 @@ SILGenModule::getWitnessTable(NormalProtocolConformance *conformance) {
   SILWitnessTable *table = SILGenConformance(*this, conformance).emit();
   emittedWitnessTables.insert({conformance, table});
 
-  // If we delayed emission of this witness table, move it to its rightful
-  // place within the module.
-  auto foundDelayed = delayedConformances.find(conformance);
-  if (foundDelayed != delayedConformances.end()) {
-    M.witnessTables.remove(table);
-    auto insertAfter = getWitnessTableToInsertAfter(*this,
-                                              foundDelayed->second.insertAfter);
-    if (!insertAfter) {
-      M.witnessTables.push_front(table);
-    } else {
-      M.witnessTables.insertAfter(insertAfter->getIterator(), table);
-    }
-  } else {
-    // We would have marked a delayed conformance as "last emitted" when it
-    // was delayed.
-    lastEmittedConformance = conformance;
-  }
   return table;
 }