Merge pull request swiftlang#34011 from CodaFi/dont-go-chasing-waterfalls

Excise Remaining Usages of Legacy Cascading Dependencies From Frontend

Author: CodaFi

docs/DependencyAnalysis.md

@@ -56,33 +56,6 @@ Note:
 > may change its members drastically.
 
 
-Cascading vs. Non-Cascading Dependencies
-========================================
-
-If file A depends on file B, and file B depends on file C, does file A depend
-on file C? The answer is: maybe! It depends how file B is using file C. If all
-uses are inside function bodies, for example, then changing file C only
-requires rebuilding file B, not file A. The terminology here is that file B has
-a *non-cascading* dependency on file C.
-
-By contrast, if changing file C affects the interface of file B, then the
-dependency is said to be *cascading,* and changing file C would require
-rebuilding both file B and file A.
-
-The various dependency tracking throughout the compiler will look at the
-context in which information is being used and attempt to determine whether or
-not a particular dependency should be considered cascading. If there's not
-enough context to decide, the compiler has to go with the conservative choice
-and record it as cascading.
-
-
-Note:
-
-> In the current on-disk representation of dependency information, cascading
-> dependencies are the default. Non-cascading dependencies are marked
-> `private` by analogy with the Swift `private` keyword.
-
-
 External Dependencies
 =====================
 

docs/Lexicon.md

@@ -100,18 +100,6 @@ These can usually be directly compared to test whether two types are the
 same; the exception is when generics get involved. In this case you'll need
 a [generic environment](#generic-environment). Contrast with [sugared type](#sugared-type).
 
-## cascading dependency
-
-A kind of dependency edge relevant to the incremental name tracking
-subsystem. A cascading dependency (as opposed to a
-[private dependency](#private-dependency) requires the Swift driver to
-transitively consider dependency edges in the file that defines the used
-name when incremental compilation is enabled. A cascading dependency is much
-safer to produce than its private counterpart, but it comes at the cost of
-increased usage of compilation resources - even if those resources are being
-wasted on rebuilding a file that didn't actually require rebuilding.
-See [DependencyAnalysis.md](DependencyAnalysis.md).
-
 ## Clang importer
 
 The part of the compiler that reads C and Objective-C declarations and
@@ -452,18 +440,6 @@ The file currently being compiled, as opposed to the other files that are
 only needed for context. See also
 [Whole-Module Optimization](#wmo-whole-module-optimization).
 
-## private dependency
-
-A kind of dependency edge relevant to the incremental name tracking
-subsystem. A private dependency (as opposed to a
-[cascading dependency](#cascading-dependency)) declares a dependency edge
-from one file to a name referenced in that file that does not
-require further transitive evaluation of dependency edges by the Swift
-driver. Private dependencies are therefore cheaper than cascading
-dependencies, but must be used with the utmost care or dependent files will
-fail to rebuild and the result will most certainly be a miscompile.
-See [DependencyAnalysis](DependencyAnalysis.md).
-
 ## QoI
 
 "Quality of implementation." The term is meant to describe not how

include/swift/AST/DiagnosticsFrontend.def

@@ -399,22 +399,14 @@ REMARK(interface_file_lock_timed_out,none,
       "timed out waiting to acquire lock file for module interface '%0'", (StringRef))
 
 // Dependency Verifier Diagnostics
-ERROR(dependency_cascading_mismatch,none,
-      "expected %select{non-cascading|cascading}0 dependency; found "
-      "%select{non-cascading|cascading}1 dependency instead",
-      (bool, bool))
-ERROR(potential_dependency_cascading_mismatch,none,
-      "expected %select{non-cascading|cascading}0 potential member dependency; "
-      "found %select{non-cascading|cascading}1 potential member dependency "
-      "instead", (bool, bool))
 ERROR(missing_member_dependency,none,
       "expected "
       "%select{%error|provided|member|potential member|dynamic member}0 "
       "dependency does not exist: %1",
       (/*Expectation::Kind*/uint8_t, StringRef))
 ERROR(unexpected_dependency,none,
-      "unexpected %0 %select{%error|%error|member|potential member|dynamic member}1 "
-      "dependency: %2", (StringRef, /*Expectation::Kind*/uint8_t, StringRef))
+      "unexpected %select{%error|%error|member|potential member|dynamic member}0 "
+      "dependency: %1", (/*Expectation::Kind*/uint8_t, StringRef))
 ERROR(unexpected_provided_entity,none,
       "unexpected provided entity: %0", (StringRef))
 ERROR(negative_expectation_violated,none,

include/swift/AST/FineGrainedDependencies.h

@@ -393,14 +393,6 @@ template <typename NodeT> class InterfaceAndImplementationPair {
 
   NodeT *getInterface() const { return interface; }
   NodeT *getImplementation() const { return implementation; }
-
-  /// When creating an arc to represent a link from def to use, the use end of
-  /// the arc depends on if the dependency is a cascading one. Centralize that
-  /// choice here.
-  /// ("use" in the name represents the noun, not the verb.)
-  NodeT *useDependingOnCascading(bool ifCascades) {
-    return ifCascades ? interface : implementation;
-  }
 };
 
 //==============================================================================
@@ -501,13 +493,6 @@ class DependencyKey {
   template <NodeKind kind, typename Entity>
   static std::string computeNameForProvidedEntity(Entity);
 
-  /// Given some type of depended-upon entity create the key.
-  static DependencyKey createDependedUponKey(StringRef mangledHolderName,
-                                             StringRef memberBaseName);
-
-  template <NodeKind kind>
-  static DependencyKey createDependedUponKey(StringRef);
-
   static DependencyKey createKeyForWholeSourceFile(DeclAspect,
                                                    StringRef swiftDeps);
 

lib/AST/FrontendSourceFileDepGraphFactory.cpp

@@ -232,47 +232,6 @@ std::string DependencyKey::computeNameForProvidedEntity<
   return getBaseName(holderAndMember.second);
 }
 
-//==============================================================================
-// MARK: createDependedUponKey
-//==============================================================================
-
-template <>
-DependencyKey
-DependencyKey::createDependedUponKey<NodeKind::topLevel>(StringRef name) {
-  return DependencyKey(NodeKind::topLevel, DeclAspect::interface, "",
-                       name.str());
-}
-
-template <>
-DependencyKey
-DependencyKey::createDependedUponKey<NodeKind::dynamicLookup>(StringRef name) {
-  return DependencyKey(NodeKind::dynamicLookup, DeclAspect::interface, "",
-                       name.str());
-}
-
-template <>
-DependencyKey
-DependencyKey::createDependedUponKey<NodeKind::externalDepend>(StringRef name) {
-  return DependencyKey(NodeKind::externalDepend, DeclAspect::interface, "",
-                       name.str());
-}
-
-template <>
-DependencyKey
-DependencyKey::createDependedUponKey<NodeKind::nominal>(StringRef mangledName) {
-  return DependencyKey(NodeKind::nominal, DeclAspect::interface,
-                       mangledName.str(), "");
-}
-
-DependencyKey DependencyKey::createDependedUponKey(StringRef mangledHolderName,
-                                                   StringRef memberBaseName) {
-  const bool isMemberBlank = memberBaseName.empty();
-  const auto kind =
-      isMemberBlank ? NodeKind::potentialMember : NodeKind::member;
-  return DependencyKey(kind, DeclAspect::interface, mangledHolderName.str(),
-                       isMemberBlank ? "" : memberBaseName.str());
-}
-
 //==============================================================================
 // MARK: Entry point into frontend graph construction
 //==============================================================================
@@ -579,7 +538,6 @@ class UsedDeclEnumerator {
   void enumerateAllUses() {
     auto &Ctx = SF->getASTContext();
     Ctx.evaluator.enumerateReferencesInFile(SF, [&](const auto &ref) {
-      const auto cascades = false;
       std::string name = ref.name.userFacingName().str();
       const auto *nominal = ref.subject;
       using Kind = evaluator::DependencyCollector::Reference::Kind;
@@ -589,19 +547,19 @@ class UsedDeclEnumerator {
       case Kind::Tombstone:
         llvm_unreachable("Cannot enumerate dead reference!");
       case Kind::TopLevel:
-        return enumerateUse<NodeKind::topLevel>("", name, cascades);
+        return enumerateUse<NodeKind::topLevel>("", name);
       case Kind::Dynamic:
-        return enumerateUse<NodeKind::dynamicLookup>("", name, cascades);
+        return enumerateUse<NodeKind::dynamicLookup>("", name);
       case Kind::PotentialMember: {
         std::string context = DependencyKey::computeContextForProvidedEntity<
             NodeKind::potentialMember>(nominal);
-        return enumerateUse<NodeKind::potentialMember>(context, "", cascades);
+        return enumerateUse<NodeKind::potentialMember>(context, "");
       }
       case Kind::UsedMember: {
         std::string context =
             DependencyKey::computeContextForProvidedEntity<NodeKind::member>(
                 nominal);
-        return enumerateUse<NodeKind::member>(context, name, cascades);
+        return enumerateUse<NodeKind::member>(context, name);
       }
       }
     });
@@ -611,11 +569,11 @@ class UsedDeclEnumerator {
 
 private:
   template <NodeKind kind>
-  void enumerateUse(StringRef context, StringRef name, bool isCascadingUse) {
+  void enumerateUse(StringRef context, StringRef name) {
     // Assume that what is depended-upon is the interface
     createDefUse(
         DependencyKey(kind, DeclAspect::interface, context.str(), name.str()),
-        isCascadingUse ? sourceFileInterface : sourceFileImplementation);
+        sourceFileImplementation);
   }
 
   void enumerateNominalUses() {
@@ -634,14 +592,13 @@ class UsedDeclEnumerator {
       std::string context =
           DependencyKey::computeContextForProvidedEntity<NodeKind::nominal>(
               subject);
-      enumerateUse<NodeKind::nominal>(context, "", /*isCascadingUse*/ false);
+      enumerateUse<NodeKind::nominal>(context, "");
     });
   }
 
   void enumerateExternalUses() {
-    // external dependencies always cascade
     for (StringRef s : depTracker.getDependencies())
-      enumerateUse<NodeKind::externalDepend>("", s, true);
+      enumerateUse<NodeKind::externalDepend>("", s);
   }
 };
 } // end namespace

lib/Driver/FineGrainedDependencyDriverGraph.cpp

@@ -220,9 +220,8 @@ void ModuleDepGraph::forEachUntracedJobDirectlyDependentOnExternalSwiftDeps(
     StringRef externalSwiftDeps, function_ref<void(const Job *)> fn) {
   // TODO move nameForDep into key
   // These nodes will depend on the *interface* of the external Decl.
-  DependencyKey key =
-      DependencyKey::createDependedUponKey<NodeKind::externalDepend>(
-          externalSwiftDeps.str());
+  DependencyKey key(NodeKind::externalDepend, DeclAspect::interface, "",
+                    externalSwiftDeps.str());
   for (const ModuleDepGraphNode *useNode : usesByDef[key]) {
     if (!useNode->getHasBeenTraced())
       fn(getJob(useNode->getSwiftDepsOfProvides()));