Derive a Fingerprint from a Module's BasicSourceFileInfo

Author: CodaFi

include/swift/AST/Module.h

@@ -734,7 +734,20 @@ class ModuleDecl : public DeclContext, public TypeDecl {
 
   /// Calls \p callback for each source file of the module.
   void collectBasicSourceFileInfo(
-      llvm::function_ref<void(const BasicSourceFileInfo &)> callback);
+      llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const;
+
+public:
+  /// Retrieve a fingerprint value that summarizes the contents of this module.
+  ///
+  /// This interface hash a of a module is guaranteed to change if the interface
+  /// hash of any of its (primary) source files changes. For example, when
+  /// building incrementally, the interface hash of this module will change when
+  /// the primaries contributing to its content changes. In contrast, when
+  /// a module is deserialized, the hash of every source file contributes to
+  /// the module's interface hash. It therefore serves as an effective, if
+  /// coarse-grained, way of determining when top-level changes to a module's
+  /// contents have been made.
+  Fingerprint getFingerprint() const;
 
   SourceRange getSourceRange() const { return SourceRange(); }
 

include/swift/Basic/Fingerprint.h

@@ -94,6 +94,11 @@ class Fingerprint final {
     return llvm::hash_value(fp.core);
   }
 
+public:
+  bool operator<(const Fingerprint &other) const {
+    return core < other.core;
+  }
+
 public:
   /// The fingerprint value consisting of 32 bytes of zeroes.
   ///

lib/AST/Module.cpp

@@ -1549,6 +1549,25 @@ void ModuleDecl::collectBasicSourceFileInfo(
   }
 }
 
+Fingerprint ModuleDecl::getFingerprint() const {
+  StableHasher hasher = StableHasher::defaultHasher();
+  SmallVector<Fingerprint, 16> FPs;
+  collectBasicSourceFileInfo([&](const BasicSourceFileInfo &bsfi) {
+    FPs.emplace_back(bsfi.InterfaceHash);
+  });
+  
+  // Sort the fingerprints lexicographically so we have a stable hash despite
+  // an unstable ordering of files across rebuilds.
+  // FIXME: If we used a commutative hash combine (say, if we could take an
+  // XOR here) we could avoid this sort.
+  std::sort(FPs.begin(), FPs.end(), std::less<Fingerprint>());
+  for (const auto &FP : FPs) {
+    hasher.combine(FP);
+  }
+
+  return Fingerprint{std::move(hasher)};
+}
+
 //===----------------------------------------------------------------------===//
 // Cross-Import Overlays
 //===----------------------------------------------------------------------===//