use phase instead

Author: David Ungar

Sources/SwiftDriver/IncrementalCompilation/InitialStateComputer.swift

@@ -173,8 +173,6 @@ extension IncrementalCompilationState.InitialStateComputer {
       return nil
     }
 
-    // Every external will be an addition to the graph, but may not cause
-    // a recompile, so includeAddedExternals is false.
     var inputsInvalidatedByChangedExternals = Set<TypedVirtualPath>()
     for input in sourceFiles.currentInOrder {
        guard let invalidatedInputs = graph.collectInputsRequiringCompilationFromExternalsFoundByCompiling(input: input)

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraph.swift

@@ -100,8 +100,7 @@ extension ModuleDependencyGraph {
       return Set<TypedVirtualPath>()
     }
     return collectInputsRequiringCompilationAfterProcessing(
-      dependencySource: getSource(for: input),
-      includeAddedExternals: false)
+      dependencySource: getSource(for: input))
   }
 }
 
@@ -110,8 +109,7 @@ extension ModuleDependencyGraph {
   func collectNodesInvalidatedByChangedOrAddedExternals() -> Set<Node> {
     fingerprintedExternalDependencies.reduce(into: Set()) { invalidatedNodes, fed in
       invalidatedNodes.formUnion (
-        self.collectNodesInvalidatedByProcessing(fingerprintedExternalDependency: fed,
-                                                 includeAddedExternals: true))
+        self.collectNodesInvalidatedByProcessing(fingerprintedExternalDependency: fed))
     }
   }
 }
@@ -180,8 +178,7 @@ extension ModuleDependencyGraph {
     precondition(input.type == .swift)
     let dependencySource = getSource(for: input)
     return collectInputsRequiringCompilationAfterProcessing(
-      dependencySource: dependencySource,
-      includeAddedExternals: true)
+      dependencySource: dependencySource)
   }
 }
 
@@ -237,15 +234,9 @@ extension ModuleDependencyGraph {
 
   /// Find all the inputs known to need recompilation as a consequence of reading a swiftdeps or swiftmodule
   /// `dependencySource` - The file to read containing dependency information
-  /// `includeAddedExternals` - If `true` external dependencies read from the dependencySource cause inputs to be invalidated,
-  /// even if the external file has not changed since the last build.
-  /// (`false` when building a graph from swiftdeps, `true` when building a graph from rereading the result of a compilation,
-  /// because in that case the added external is assumed to be caused by an `import` added to the source file.)
-  /// `invalidatedOnlyByExternals` - Only return inputs invalidated because of external dependencies, vs invalidated by any dependency
   /// Returns `nil` on error
   private func collectInputsRequiringCompilationAfterProcessing(
-    dependencySource: DependencySource,
-    includeAddedExternals: Bool
+    dependencySource: DependencySource
   ) -> Set<TypedVirtualPath>? {
     guard let sourceGraph = dependencySource.read(in: info.fileSystem,
                                                   reporter: info.reporter)
@@ -256,16 +247,12 @@ extension ModuleDependencyGraph {
           because: "malformed dependencies file '\(dependencySource.typedFile)'"))
       return nil
     }
-    let results = Integrator.integrate(from: sourceGraph,
-                                       into: self,
-                                       includeAddedExternals: includeAddedExternals)
-
-    /// When reading from a swiftdeps file ( includeAddedExternals is false), any changed input files are
-    /// computed separately. (TODO: fix this? by finding changed inputs in a callee?),
-    /// so the only invalidates that matter are the ones caused by
-    /// changed external dependencies.
-    /// When reading a swiftdeps file after compiling, any invalidated node matters.
-    let invalidatedNodes = includeAddedExternals
+    let results = Integrator.integrate(from: sourceGraph, into: self)
+
+    /// If reading for the first time, the driver is compiling all outdated source files anyway, so only
+    /// nodes invalidated by external dependencies matter.
+    /// But when updating, all invalidations matter.
+    let invalidatedNodes = phase.isUpdating
       ? results.allInvalidatedNodes
       : results.nodesInvalidatedByUsingSomeExternal
 
@@ -288,12 +275,9 @@ extension ModuleDependencyGraph {
 
   /// Process a possibly-fingerprinted external dependency by reading and integrating, if applicable.
   /// Return the nodes thus invalidated.
-  /// includeAddedExternals - return the changes arising merely because the external was new to the graph,
-  /// as opposed to changes from changed externals.
   /// But always integrate, in order to detect future changes.
   func collectNodesInvalidatedByProcessing(
-    fingerprintedExternalDependency fed: FingerprintedExternalDependency,
-    includeAddedExternals: Bool)
+    fingerprintedExternalDependency fed: FingerprintedExternalDependency)
   -> Set<Node> {
 
     let isNewToTheGraph = fingerprintedExternalDependencies.insert(fed).inserted
@@ -308,11 +292,10 @@ extension ModuleDependencyGraph {
       (isNewToTheGraph || lazyModTimer.hasExternalFileChanged)
 
     let invalidatedNodesFromIncrementalExternal = shouldTryToProcess
-      ? collectNodesInvalidatedByAttemptingToProcess(
-        fed, info, includeAddedExternals: includeAddedExternals)
+      ? collectNodesInvalidatedByAttemptingToProcess(fed, info)
       : nil
 
-    let callerWantsTheseChanges = (includeAddedExternals && isNewToTheGraph) ||
+    let callerWantsTheseChanges = (phase.isUpdating && isNewToTheGraph) ||
       lazyModTimer.hasExternalFileChanged
 
     return !callerWantsTheseChanges
@@ -330,17 +313,12 @@ extension ModuleDependencyGraph {
 
   private func collectNodesInvalidatedByAttemptingToProcess(
     _ fed: FingerprintedExternalDependency,
-    _ info: IncrementalCompilationState.InitialStateComputer,
-    includeAddedExternals: Bool
-  ) -> Set<Node>? {
+    _ info: IncrementalCompilationState.InitialStateComputer) -> Set<Node>? {
     fed.incrementalDependencySource?
       .read(in: info.fileSystem, reporter: info.reporter)
       .map { unserializedDepGraph in
         info.reporter?.report("Integrating changes from: \(fed.externalDependency)")
-        return Integrator.integrate(
-          from: unserializedDepGraph,
-          into: self,
-          includeAddedExternals: includeAddedExternals)
+        return Integrator.integrate(from: unserializedDepGraph, into: self)
           .allInvalidatedNodes
       }
   }

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraphParts/Integrator.swift

@@ -31,20 +31,15 @@ extension ModuleDependencyGraph {
     /// the graph to be integrated into
     let destination: ModuleDependencyGraph
 
-    /// The graph already includes externalDeps from prior compilations
-    let includeAddedExternals: Bool
-
     /// Starts with all nodes in dependencySource. Nodes that persist will be removed.
     /// After integration is complete, contains the nodes that have disappeared.
     var disappearedNodes = [DependencyKey: Graph.Node]()
 
     init(sourceGraph: SourceFileDependencyGraph,
-         destination: ModuleDependencyGraph,
-         includeAddedExternals: Bool)
+         destination: ModuleDependencyGraph)
     {
       self.sourceGraph = sourceGraph
       self.destination = destination
-      self.includeAddedExternals = includeAddedExternals
       self.disappearedNodes = destination.nodeFinder
         .findNodes(for: sourceGraph.dependencySource)
         ?? [:]
@@ -64,12 +59,9 @@ extension ModuleDependencyGraph.Integrator {
   /// Common to scheduling both waves.
   /*@_spi(Testing)*/ public static func integrate(
     from g: SourceFileDependencyGraph,
-    into destination: Graph,
-    includeAddedExternals: Bool
+    into destination: Graph
   ) -> Results {
-    var integrator = Self(sourceGraph: g,
-                          destination: destination,
-                          includeAddedExternals: includeAddedExternals)
+    var integrator = Self(sourceGraph: g, destination: destination)
     integrator.integrate()
 
     if destination.info.verifyDependencyGraphAfterEveryImport {
@@ -205,8 +197,7 @@ extension ModuleDependencyGraph.Integrator {
     moduleFileGraphUseNode moduleUseNode: Graph.Node) {
 
     let invalidated = destination.collectNodesInvalidatedByProcessing(
-      fingerprintedExternalDependency: fingerprintedExternalDependency,
-      includeAddedExternals: includeAddedExternals)
+      fingerprintedExternalDependency: fingerprintedExternalDependency)
     results.addNodesInvalidatedByUsingSomeExternal(invalidated)
   }
 }

Tests/SwiftDriverTests/ModuleDependencyGraphTests.swift

@@ -754,8 +754,7 @@ class ModuleDependencyGraphTests: XCTestCase {
     let graph = ModuleDependencyGraph(mock: de)
     _ = graph.getInvalidatedNodesForSimulatedLoad(
       0,
-      [MockDependencyKind.nominal: ["A@1"]],
-      includeAddedExternals: false)
+      [MockDependencyKind.nominal: ["A@1"]])
   }
 
   func testUseFingerprints() {
@@ -955,7 +954,6 @@ extension ModuleDependencyGraph {
   {
     _ = getInvalidatedNodesForSimulatedLoad(
       swiftDepsIndex, dependencyDescriptions,
-      includeAddedExternals: false,
       interfaceHash,
       includePrivateDeps: includePrivateDeps,
       hadCompilationError: hadCompilationError)
@@ -971,7 +969,6 @@ extension ModuleDependencyGraph {
     let invalidatedNodes = getInvalidatedNodesForSimulatedLoad(
       swiftDepsIndex,
       dependencyDescriptions,
-      includeAddedExternals: true,
       interfaceHash,
       includePrivateDeps: includePrivateDeps,
       hadCompilationError: hadCompilationError)
@@ -984,7 +981,6 @@ extension ModuleDependencyGraph {
   func getInvalidatedNodesForSimulatedLoad(
     _ swiftDepsIndex: Int,
     _ dependencyDescriptions: [MockDependencyKind: [String]],
-    includeAddedExternals: Bool,
     _ interfaceHashIfPresent: String? = nil,
     includePrivateDeps: Bool = true,
     hadCompilationError: Bool = false
@@ -1003,9 +999,7 @@ extension ModuleDependencyGraph {
       interfaceHash: interfaceHash,
       dependencyDescriptions)
 
-    let results = Integrator.integrate(from: sfdg,
-                                      into: self,
-                                      includeAddedExternals: includeAddedExternals)
+    let results = Integrator.integrate(from: sfdg, into: self)
 
     return results.allInvalidatedNodes
   }