Clean it up

Author: David Ungar

Sources/SwiftDriver/IncrementalCompilation/DependencyKey.swift

@@ -370,21 +370,61 @@ extension DependencyKey.Designator: Comparable {
 
 // MARK: - InvalidationReason
 extension ExternalDependency {
-  public enum InvalidationReason: String, CustomStringConvertible {
-    case added, changed, testing
-    init?(_ graph: ModuleDependencyGraph,
-          isNewToTheGraph: Bool ,
-          _ externalDependency: ExternalDependency) {
-      if isNewToTheGraph {
+  /// When explaining incremental decisions, it helps to know why a particular external dependency
+  /// was investigated.
+  public enum Why: String, CustomStringConvertible {
+    /// An `Import` of this file was added to the source code.
+    case added
+
+    /// The imported file has changed.
+    case changed
+
+    /// Used when testing invalidation
+    case testing
+
+    /// Figure out the reason to invalidate or process a dependency.
+    /// Even if invalidation won't be reported to the caller, a new or added
+    /// incremental external dependency may require integration in order to
+    /// transitively close them, (e.g. if an imported module imports a module).
+    init?(should fed: FingerprintedExternalDependency,
+          whichIsNewToTheGraph isNewToTheGraph: Bool,
+          closeOverSwiftModulesIn graph: ModuleDependencyGraph) {
+      guard graph.info.isCrossModuleIncrementalBuildEnabled
+              else { return nil }
+      self.init(should: fed,
+                whichIsSignificantlyNew: isNewToTheGraph,
+                beInvestigatedIn: graph)
+    }
+
+
+    init?(shouldUsesOf fed: FingerprintedExternalDependency,
+          whichIsNewToTheGraph isNewToTheGraph: Bool,
+          beInvalidatedIn graph: ModuleDependencyGraph) {
+      if graph.phase.isCompilingAllInputsNoMatterWhat {
+        // going to compile every input anyway, less work for callers
+        return nil
+      }
+      let isSignificantlyNew = graph.phase.shouldNewExternalDependenciesTriggerInvalidation && isNewToTheGraph
+      self.init(should: fed,
+                whichIsSignificantlyNew: isSignificantlyNew,
+                beInvestigatedIn: graph)
+    }
+
+    /// Figure out the reason to invalidate or process a dependency
+    private init?(should fed: FingerprintedExternalDependency,
+                  whichIsSignificantlyNew isSignificantlyNew: Bool,
+                  beInvestigatedIn graph: ModuleDependencyGraph) {
+      if isSignificantlyNew {
         self = .added
         return
       }
-      if graph.hasFileChanged(of: externalDependency) {
+      if graph.hasFileChanged(of: fed.externalDependency) {
         self = .changed
         return
       }
       return nil
     }
+
     public var description: String { rawValue }
   }
 }

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift

@@ -432,7 +432,7 @@ extension IncrementalCompilationState {
     func reportInvalidated<Nodes: Sequence>(
       _ nodes: Nodes,
       by externalDependency: ExternalDependency,
-      _ why: ExternalDependency.InvalidationReason
+      _ why: ExternalDependency.Why
     )
     where Nodes.Element == ModuleDependencyGraph.Node
     {

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraph.swift

@@ -265,7 +265,7 @@ extension ModuleDependencyGraph {
   /// As an optimization, only return the nodes that have not been already traced, because the traced nodes
   /// will have already been used to schedule jobs to run.
   /*@_spi(Testing)*/ public func collectUntracedNodesUsing(
-    _ why: ExternalDependency.InvalidationReason,
+    _ why: ExternalDependency.Why,
     _ fingerprintedExternalDependency: FingerprintedExternalDependency
   ) -> DirectlyInvalidatedNodeSet {
     // These nodes will depend on the *interface* of the external Decl.
@@ -336,30 +336,22 @@ extension ModuleDependencyGraph {
     isPresentInTheGraph: Bool?)
   -> DirectlyInvalidatedNodeSet {
 
+    /// Compute this up front as an optimization.
     let isNewToTheGraph = isPresentInTheGraph != true && fingerprintedExternalDependencies.insert(fed).inserted
 
-    // Even if invalidation won't be reported to the caller, a new or added
-    // incremental external dependency may require integration in order to
-    // transitively close them, (e.g. if an imported module imports a module).
-    let whyIntegrateForClosure = info.isCrossModuleIncrementalBuildEnabled
-    ? ExternalDependency.InvalidationReason(self,
-                                            isNewToTheGraph: isNewToTheGraph,
-                                            fed.externalDependency)
-    : nil
+   let whyIntegrateForClosure = ExternalDependency.Why(
+    should: fed,
+    whichIsNewToTheGraph: isNewToTheGraph,
+    closeOverSwiftModulesIn: self)
 
     let invalidatedNodesFromIncrementalExternal = whyIntegrateForClosure.flatMap { why in
       collectNodesInvalidatedByAttemptingToProcess(why, fed)
     }
 
-    if phase.isCompilingAllInputsNoMatterWhat {
-      // going to compile every input anyway, less work for callers
-      return DirectlyInvalidatedNodeSet()
-    }
-
-    guard let whyInvalidate = ExternalDependency.InvalidationReason(
-      self,
-      isNewToTheGraph: phase.shouldNewExternalDependenciesTriggerInvalidation && isNewToTheGraph,
-      fed.externalDependency)
+    guard let whyInvalidate = ExternalDependency.Why(
+      shouldUsesOf: fed,
+      whichIsNewToTheGraph: isNewToTheGraph,
+      beInvalidatedIn: self)
     else {
       return DirectlyInvalidatedNodeSet()
     }
@@ -386,7 +378,7 @@ extension ModuleDependencyGraph {
   /// Try to read and integrate an external dependency.
   /// Return nil if it's not incremental, or if an error occurs.
   private func collectNodesInvalidatedByAttemptingToProcess(
-    _ why: ExternalDependency.InvalidationReason,
+    _ why: ExternalDependency.Why,
     _ fed: FingerprintedExternalDependency
   ) -> DirectlyInvalidatedNodeSet? {
     guard let source = fed.incrementalDependencySource,