Serialize Fingerprint Blobs For External Dependencies

Now that external dependencies and incremental external dependencies are
one and the same, we need to serialize the fingerprints that may or may
not be attached to them.

Author: CodaFi

Sources/SwiftDriver/IncrementalCompilation/DependencyKey.swift

@@ -4,13 +4,17 @@ import Foundation
 /// A filename from another module
 /*@_spi(Testing)*/ public struct ExternalDependency: Hashable, Comparable, CustomStringConvertible {
   let fileName: String
+  let fingerprint: String?
+
+  /*@_spi(Testing)*/ public init(_ fileName: String, fingerprint: String? = nil) {
+    self.fileName = fileName
+    self.fingerprint = fingerprint
+  }
 
   var file: VirtualPath? {
     try? VirtualPath(path: fileName)
   }
-  /*@_spi(Testing)*/ public init(_ path: String) {
-    self.fileName = path
-  }
+
   public var description: String {
     fileName.description
   }

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraph.swift

@@ -561,13 +561,17 @@ extension ModuleDependencyGraph {
           }
           self.nodeUses[key, default: []].append(Int(record.fields[0]))
         case .externalDepNode:
-          guard record.fields.count == 1,
-                record.fields[0] < identifiers.count
+          guard record.fields.count == 2,
+                record.fields[0] < identifiers.count,
+                case .blob(let fingerprintBlob) = record.payload,
+                let fingerprintStr = String(data: fingerprintBlob, encoding: .utf8)
           else {
             throw ReadError.malformedExternalDepNodeRecord
           }
           let path = identifiers[Int(record.fields[0])]
-          self.graph.externalDependencies.insert(ExternalDependency(path))
+          let hasFingerprint = Int(record.fields[1]) != 0
+          let fingerprint = hasFingerprint ? fingerprintStr : nil
+          self.graph.externalDependencies.insert(ExternalDependency(path, fingerprint: fingerprint))
         case .identifierNode:
           guard record.fields.count == 0,
                 case .blob(let identifierBlob) = record.payload,
@@ -804,6 +808,10 @@ extension ModuleDependencyGraph {
         .literal(RecordID.externalDepNode.rawValue),
         // path ID
         .vbr(chunkBitWidth: 13),
+        // fingerprint?
+        .fixed(bitWidth: 1),
+        // fingerprint bytes
+        .blob
       ])
       self.abbreviate(.identifierNode, [
         .literal(RecordID.identifierNode.rawValue),
@@ -874,10 +882,11 @@ extension ModuleDependencyGraph {
         }
 
         for dep in graph.externalDependencies {
-          serializer.stream.writeRecord(serializer.abbreviations[.externalDepNode]!) {
+          serializer.stream.writeRecord(serializer.abbreviations[.externalDepNode]!, {
             $0.append(RecordID.externalDepNode)
             $0.append(serializer.lookupIdentifierCode(for: dep.fileName))
-          }
+            $0.append((dep.fingerprint != nil) ? UInt32(1) : UInt32(0))
+          }, blob: dep.fingerprint ?? "")
         }
       }
       return ByteString(serializer.stream.data)

Tests/SwiftDriverTests/DependencyGraphSerializationTests.swift

@@ -49,7 +49,7 @@ class DependencyGraphSerializationTests: XCTestCase {
       var commands: [LoadCommand]
 
       enum LoadCommand {
-        case load(index: Int, nodes: [MockDependencyKind: [String]])
+        case load(index: Int, nodes: [MockDependencyKind: [String]], fingerprint: String? = nil)
         case reload(index: Int, nodes: [MockDependencyKind: [String]], fingerprint: String? = nil)
       }
     }
@@ -212,15 +212,19 @@ class DependencyGraphSerializationTests: XCTestCase {
         .load(index: 6, nodes: [.nominal: ["C2->"]]),
         .reload(index: 0, nodes: [.nominal: ["A1@11", "A2@2"]])
       ]),
+      GraphFixture(commands: [
+        .load(index: 0, nodes: [.externalDepend: ["/foo->", "/bar->"]], fingerprint: "ABCDEFG"),
+        .reload(index: 0, nodes: [.externalDepend: ["/foo->", "/bar->"]], fingerprint: "HIJKLMNOP"),
+      ]),
     ]
 
     for fixture in fixtures {
       let de = DiagnosticsEngine()
       let graph = ModuleDependencyGraph(mock: de)
       for loadCommand in fixture.commands {
         switch loadCommand {
-        case .load(index: let index, nodes: let nodes):
-          graph.simulateLoad(index, nodes, nil)
+        case .load(index: let index, nodes: let nodes, fingerprint: let fingerprint):
+          graph.simulateLoad(index, nodes, fingerprint)
         case .reload(index: let index, nodes: let nodes, fingerprint: let fingerprint):
           _ = graph.simulateReload(index, nodes, fingerprint)
         }