When tracing uses, include the implicit use of implementation when interface changes

Author: David Ungar

Sources/SwiftDriver/Incremental Compilation/DependencyKey.swift

@@ -94,8 +94,10 @@ public struct DependencyKey: Hashable, CustomStringConvertible {
   }
 
 
-  var correspondingImplementation: Self {
-    assert(aspect == .interface)
+var correspondingImplementation: Self? {
+    guard aspect == .interface  else {
+      return nil
+    }
     return Self(aspect: .implementation, designator: designator)
   }
 

Sources/SwiftDriver/Incremental Compilation/ModuleDependencyGraph Parts/NodeFinder.swift

@@ -47,6 +47,10 @@ extension ModuleDependencyGraph.NodeFinder {
   func findNode(_ mapKey: (Graph.SwiftDeps?, DependencyKey)) -> Graph.Node? {
     nodeMap[mapKey]
   }
+  func findCorrespondingImplementation(of n: Graph.Node) -> Graph.Node? {
+    n.dependencyKey.correspondingImplementation
+      .flatMap {findNode((n.swiftDeps, $0))}
+  }
 
   func findNodes(for swiftDeps: Graph.SwiftDeps?) -> [DependencyKey: Graph.Node]? {
     nodeMap[swiftDeps]
@@ -55,21 +59,18 @@ extension ModuleDependencyGraph.NodeFinder {
     nodeMap[key]
   }
 
-  /// Since uses must be somewhere, pass inthe swiftDeps to the function here
-  func forEachUse(_ fn: (DependencyKey, Graph.Node, Graph.SwiftDeps) -> Void) {
-    usesByDef.forEach {
-      def, use in
-      fn(def, use, useMustHaveSwiftDeps(use))
+  func forEachUse(of def: Graph.Node, _ fn: (Graph.Node, Graph.SwiftDeps) -> Void) {
+    func fnVerifyingSwiftDeps(_ use: Graph.Node) {
+      fn(use, useMustHaveSwiftDeps(use))
     }
-  }
-  func forEachUse(of def: DependencyKey, _ fn: (Graph.Node, Graph.SwiftDeps) -> Void) {
-    usesByDef[def].map {
-      $0.values.forEach { use in
-        fn(use, useMustHaveSwiftDeps(use))
-      }
+    usesByDef[def.dependencyKey].map {
+      $0.values.forEach(fnVerifyingSwiftDeps)
     }
+    // Add in implicit interface->implementation dependency
+    findCorrespondingImplementation(of: def)
+      .map(fnVerifyingSwiftDeps)
   }
-  
+
   func mappings(of n: Graph.Node) -> [(Graph.SwiftDeps?, DependencyKey)]
   {
     nodeMap.compactMap {

Sources/SwiftDriver/Incremental Compilation/ModuleDependencyGraph Parts/Tracer.swift

@@ -83,7 +83,7 @@ extension ModuleDependencyGraph.Tracer {
     let pathLengthAfterArrival = traceArrival(at: definition);
 
     // If this use also provides something, follow it
-    graph.nodeFinder.forEachUse(of: definition.dependencyKey) { use, _ in
+    graph.nodeFinder.forEachUse(of: definition) { use, _ in
       findNextPreviouslyUntracedDependent(of: use)
     }
     traceDeparture(pathLengthAfterArrival);

Sources/SwiftDriver/Incremental Compilation/ModuleDependencyGraph.swift

@@ -171,7 +171,8 @@ extension ModuleDependencyGraph {
   ) {
     // These nodes will depend on the *interface* of the external Decl.
     let key = DependencyKey(interfaceFor: externalSwiftDeps)
-    nodeFinder.forEachUse(of: key) { use, useSwiftDeps in
+    let node = Node(key: key, fingerprint: nil, swiftDeps: nil)
+    nodeFinder.forEachUse(of: node) { use, useSwiftDeps in
       if isUntraced(use) {
         fn(useSwiftDeps)
       }

Tests/SwiftDriverTests/ModuleDependencyGraphTests.swift

@@ -136,11 +136,7 @@ class ModuleDependencyGraphTests: XCTestCase {
     }
     XCTAssertTrue(graph.haveAnyNodesBeenTraversed(inMock: 0))
     XCTAssertTrue(graph.haveAnyNodesBeenTraversed(inMock: 1))
-    do {
-      let swiftDeps = graph.findSwiftDepsToRecompileWhenWholeSwiftDepsChanges(0)
-      XCTAssertEqual(1, swiftDeps.count)
-      XCTAssertTrue(swiftDeps.contains(0))
-    }
+
     XCTAssertEqual(0, graph.findSwiftDepsToRecompileWhenWholeSwiftDepsChanges(0).count)
     XCTAssertTrue(graph.haveAnyNodesBeenTraversed(inMock: 0))
     XCTAssertTrue(graph.haveAnyNodesBeenTraversed(inMock: 1))
@@ -1058,8 +1054,7 @@ fileprivate struct SourceFileDependencyGraphMocker {
     if case .sourceFileProvide = interfaceKey.designator, !allNodes.isEmpty {
       return getSourceFileNodePair()
     }
-    assert(interfaceKey.aspect == .interface)
-    let implementationKey = interfaceKey.correspondingImplementation
+    let implementationKey = try! XCTUnwrap(interfaceKey.correspondingImplementation)
     let nodePair = NodePair(
       interface: findExistingNodeOrCreateIfNew(interfaceKey, fingerprint,
                                                isProvides: true),