Remove Reference::cascades

Author: CodaFi

include/swift/AST/EvaluatorDependencies.h

@@ -67,41 +67,38 @@ struct DependencyCollector {
 
     NominalTypeDecl *subject;
     DeclBaseName name;
-    bool cascades;
 
   private:
-    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name,
-              bool cascades)
-        : kind(kind), subject(subject), name(name), cascades(cascades) {}
+    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name)
+        : kind(kind), subject(subject), name(name) {}
 
   public:
     static Reference empty() {
       return {Kind::Empty, llvm::DenseMapInfo<NominalTypeDecl *>::getEmptyKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey(), false};
+              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey()};
     }
 
     static Reference tombstone() {
       return {Kind::Tombstone,
               llvm::DenseMapInfo<NominalTypeDecl *>::getTombstoneKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey(), false};
+              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey()};
     }
 
   public:
-    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name,
-                                bool cascades) {
-      return {Kind::UsedMember, subject, name, cascades};
+    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name) {
+      return {Kind::UsedMember, subject, name};
     }
 
-    static Reference potentialMember(NominalTypeDecl *subject, bool cascades) {
-      return {Kind::PotentialMember, subject, DeclBaseName(), cascades};
+    static Reference potentialMember(NominalTypeDecl *subject) {
+      return {Kind::PotentialMember, subject, DeclBaseName()};
     }
 
-    static Reference topLevel(DeclBaseName name, bool cascades) {
-      return {Kind::TopLevel, nullptr, name, cascades};
+    static Reference topLevel(DeclBaseName name) {
+      return {Kind::TopLevel, nullptr, name};
     }
 
-    static Reference dynamic(DeclBaseName name, bool cascades) {
-      return {Kind::Dynamic, nullptr, name, cascades};
+    static Reference dynamic(DeclBaseName name) {
+      return {Kind::Dynamic, nullptr, name};
     }
 
   public:
@@ -318,20 +315,6 @@ struct DependencyRecorder {
         Coll.get()->dependencySources.pop_back();
     }
   };
-
-private:
-  /// Returns \c true if the scope of the current active source cascades.
-  ///
-  /// If there is no active scope, the result always cascades.
-  bool isActiveSourceCascading() const {
-    switch (mode) {
-    case Mode::LegacyCascadingDependencies:
-      return false;
-    case Mode::DirectDependencies:
-      return false;
-    }
-    llvm_unreachable("invalid mode");
-  }
 };
 } // end namespace evaluator
 

lib/AST/Evaluator.cpp

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

lib/AST/FrontendSourceFileDepGraphFactory.cpp

@@ -580,7 +580,7 @@ class UsedDeclEnumerator {
     auto &Ctx = SF->getASTContext();
     std::unordered_set<std::string> holdersOfCascadingMembers;
     Ctx.evaluator.enumerateReferencesInFile(SF, [&](const auto &ref) {
-      const auto cascades = ref.cascades;
+      const auto cascades = false;
       std::string name = ref.name.userFacingName().str();
       const auto *nominal = ref.subject;
       using Kind = evaluator::DependencyCollector::Reference::Kind;

lib/Frontend/DependencyVerifier.cpp

@@ -429,7 +429,7 @@ bool DependencyVerifier::constructObligations(const SourceFile *SF,
   auto &Ctx = SF->getASTContext();
   Ctx.evaluator.enumerateReferencesInFile(
       SF, [&](const auto &reference) {
-        const auto isCascadingUse = reference.cascades;
+        const auto isCascadingUse = false;
         using NodeKind = evaluator::DependencyCollector::Reference::Kind;
         switch (reference.kind) {
         case NodeKind::Empty: