Add the "cascading" bit to Reference

We'll be able to delete this once we cut over to private dependencies

Author: CodaFi

include/swift/AST/EvaluatorDependencies.h

@@ -123,38 +123,41 @@ struct DependencyCollector {
 
     NominalTypeDecl *subject;
     DeclBaseName name;
+    bool cascades;
 
   private:
-    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name)
-        : kind(kind), subject(subject), name(name) {}
+    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name,
+              bool cascades)
+        : kind(kind), subject(subject), name(name), cascades(cascades) {}
 
   public:
     static Reference empty() {
       return {Kind::Empty, llvm::DenseMapInfo<NominalTypeDecl *>::getEmptyKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey()};
+              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey(), false};
     }
 
     static Reference tombstone() {
       return {Kind::Tombstone,
               llvm::DenseMapInfo<NominalTypeDecl *>::getTombstoneKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey()};
+              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey(), false};
     }
 
   public:
-    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name) {
-      return {Kind::UsedMember, subject, name};
+    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name,
+                                bool cascades) {
+      return {Kind::UsedMember, subject, name, cascades};
     }
 
-    static Reference potentialMember(NominalTypeDecl *subject) {
-      return {Kind::PotentialMember, subject, DeclBaseName()};
+    static Reference potentialMember(NominalTypeDecl *subject, bool cascades) {
+      return {Kind::PotentialMember, subject, DeclBaseName(), cascades};
     }
 
-    static Reference topLevel(DeclBaseName name) {
-      return {Kind::TopLevel, nullptr, name};
+    static Reference topLevel(DeclBaseName name, bool cascades) {
+      return {Kind::TopLevel, nullptr, name, cascades};
     }
 
-    static Reference dynamic(DeclBaseName name) {
-      return {Kind::Dynamic, nullptr, name};
+    static Reference dynamic(DeclBaseName name, bool cascades) {
+      return {Kind::Dynamic, nullptr, name, cascades};
     }
 
   public:

lib/AST/Evaluator.cpp

@@ -409,34 +409,40 @@ void evaluator::DependencyCollector::addUsedMember(NominalTypeDecl *subject,
                                                    DeclBaseName name) {
   if (parent.mode ==
       DependencyRecorder::Mode::ExperimentalPrivateDependencies) {
-    scratch.insert(Reference::usedMember(subject, name));
+    scratch.insert(
+        Reference::usedMember(subject, name, parent.isActiveSourceCascading()));
   }
-  return parent.realize(Reference::usedMember(subject, name));
+  return parent.realize(
+      Reference::usedMember(subject, name, parent.isActiveSourceCascading()));
 }
 
 void evaluator::DependencyCollector::addPotentialMember(
     NominalTypeDecl *subject) {
   if (parent.mode ==
       DependencyRecorder::Mode::ExperimentalPrivateDependencies) {
-    scratch.insert(Reference::potentialMember(subject));
+    scratch.insert(
+        Reference::potentialMember(subject, parent.isActiveSourceCascading()));
   }
-  return parent.realize(Reference::potentialMember(subject));
+  return parent.realize(
+      Reference::potentialMember(subject, parent.isActiveSourceCascading()));
 }
 
 void evaluator::DependencyCollector::addTopLevelName(DeclBaseName name) {
   if (parent.mode ==
       DependencyRecorder::Mode::ExperimentalPrivateDependencies) {
-    scratch.insert(Reference::topLevel(name));
+    scratch.insert(Reference::topLevel(name, parent.isActiveSourceCascading()));
   }
-  return parent.realize(Reference::topLevel(name));
+  return parent.realize(
+      Reference::topLevel(name, parent.isActiveSourceCascading()));
 }
 
 void evaluator::DependencyCollector::addDynamicLookupName(DeclBaseName name) {
   if (parent.mode ==
       DependencyRecorder::Mode::ExperimentalPrivateDependencies) {
-    scratch.insert(Reference::dynamic(name));
+    scratch.insert(Reference::dynamic(name, parent.isActiveSourceCascading()));
   }
-  return parent.realize(Reference::dynamic(name));
+  return parent.realize(
+      Reference::dynamic(name, parent.isActiveSourceCascading()));
 }
 
 void evaluator::DependencyRecorder::record(