Start Keeping Track of Files With Dependencies in the DependencyCollector

This completely obviates the need for the referenced name trackers

rdar://59076016

Author: CodaFi

include/swift/AST/Evaluator.h

@@ -262,6 +262,12 @@ class Evaluator {
   void registerRequestFunctions(Zone zone,
                                 ArrayRef<AbstractRequestFunction *> functions);
 
+  void enumerateReferencesInFile(
+      const SourceFile *SF,
+      evaluator::DependencyRecorder::ReferenceEnumerator f) const {
+    return recorder.enumerateReferencesInFile(SF, f);
+  }
+
   /// Retrieve the result produced by evaluating a request that can
   /// be cached.
   template<typename Request,

include/swift/AST/EvaluatorDependencies.h

@@ -253,6 +253,8 @@ struct DependencyRecorder {
 private:
   /// A stack of dependency sources in the order they were evaluated.
   llvm::SmallVector<evaluator::DependencySource, 8> dependencySources;
+  llvm::DenseMap<SourceFile *, DependencyCollector::ReferenceSet>
+      fileReferences;
   llvm::DenseMap<AnyRequest, DependencyCollector::ReferenceSet>
       requestReferences;
   Mode mode;
@@ -269,6 +271,12 @@ struct DependencyRecorder {
   void record(const llvm::SetVector<swift::ActiveRequest> &stack,
               llvm::function_ref<void(DependencyCollector &)> rec);
 
+public:
+  using ReferenceEnumerator =
+      llvm::function_ref<void(const DependencyCollector::Reference &)>;
+  void enumerateReferencesInFile(const SourceFile *SF,
+                                 ReferenceEnumerator f) const ;
+
 public:
   /// Returns the scope of the current active scope.
   ///
@@ -331,25 +339,6 @@ struct DependencyRecorder {
     return dependencySources.front().getPointer();
   }
 
-  /// If there is an active dependency source, returns its
-  /// \c ReferencedNameTracker. Else, returns \c nullptr.
-  ReferencedNameTracker *getActiveDependencyTracker() const {
-    SourceFile *source = nullptr;
-    switch (mode) {
-    case Mode::StatusQuo:
-      source = getActiveDependencySourceOrNull();
-      break;
-    case Mode::ExperimentalPrivateDependencies:
-      source = getFirstDependencySourceOrNull();
-      break;
-    }
-    
-    if (!source)
-      return nullptr;
-
-    return source->getRequestBasedReferencedNameTracker();
-  }
-
   /// Returns \c true if the scope of the current active source cascades.
   ///
   /// If there is no active scope, the result always cascades.

lib/AST/Evaluator.cpp

@@ -381,28 +381,12 @@ void Evaluator::dumpDependenciesGraphviz() const {
 
 void evaluator::DependencyRecorder::realize(
     const DependencyCollector::Reference &ref) {
-  auto *tracker = getActiveDependencyTracker();
-  assert(tracker && "cannot realize dependency without name tracker!");
-
-  using Kind = evaluator::DependencyCollector::Reference::Kind;
-  switch (ref.kind) {
-  case Kind::Empty:
-  case Kind::Tombstone:
-    llvm_unreachable("cannot record empty dependency");
-  case Kind::UsedMember:
-    tracker->addUsedMember({ref.subject, ref.name}, isActiveSourceCascading());
-    break;
-  case Kind::PotentialMember:
-    tracker->addUsedMember({ref.subject, Identifier()},
-                           isActiveSourceCascading());
-    break;
-  case Kind::TopLevel:
-    tracker->addTopLevelName(ref.name, isActiveSourceCascading());
-    break;
-  case Kind::Dynamic:
-    tracker->addDynamicLookupName(ref.name, isActiveSourceCascading());
-    break;
+  auto *source = getActiveDependencySourceOrNull();
+  assert(source && "cannot realize dependency without associated file!");
+  if (!source->hasInterfaceHash()) {
+    return;
   }
+  fileReferences[source].insert(ref);
 }
 
 void evaluator::DependencyCollector::addUsedMember(NominalTypeDecl *subject,
@@ -449,7 +433,8 @@ void evaluator::DependencyRecorder::record(
     const llvm::SetVector<swift::ActiveRequest> &stack,
     llvm::function_ref<void(DependencyCollector &)> rec) {
   assert(!isRecording && "Probably not a good idea to allow nested recording");
-  if (!getActiveDependencyTracker()) {
+  auto *source = getActiveDependencySourceOrNull();
+  if (!source || !source->hasInterfaceHash()) {
     return;
   }
 
@@ -480,7 +465,8 @@ void evaluator::DependencyRecorder::record(
 void evaluator::DependencyRecorder::replay(const swift::ActiveRequest &req) {
   assert(!isRecording && "Probably not a good idea to allow nested recording");
 
-  if (mode == Mode::StatusQuo || !getActiveDependencyTracker()) {
+  auto *source = getActiveDependencySourceOrNull();
+  if (mode == Mode::StatusQuo || !source || !source->hasInterfaceHash()) {
     return;
   }
 
@@ -497,3 +483,26 @@ void evaluator::DependencyRecorder::replay(const swift::ActiveRequest &req) {
     realize(ref);
   }
 }
+
+using namespace swift;
+
+void evaluator::DependencyRecorder::enumerateReferencesInFile(
+    const SourceFile *SF, ReferenceEnumerator f) const {
+  auto entry = fileReferences.find(SF);
+  if (entry == fileReferences.end()) {
+    return;
+  }
+
+  for (const auto &ref : entry->getSecond()) {
+    switch (ref.kind) {
+    case DependencyCollector::Reference::Kind::Empty:
+    case DependencyCollector::Reference::Kind::Tombstone:
+      llvm_unreachable("Cannot enumerate dead reference!");
+    case DependencyCollector::Reference::Kind::UsedMember:
+    case DependencyCollector::Reference::Kind::PotentialMember:
+    case DependencyCollector::Reference::Kind::TopLevel:
+    case DependencyCollector::Reference::Kind::Dynamic:
+      f(ref);
+    }
+  }
+}