Allow clients to override hashing classpath.

internal/compiler-interface/src/main/java/xsbti/compile/ExternalHooks.java

@@ -51,6 +51,8 @@ interface Lookup {
          * @return API changes
          */
         boolean shouldDoIncrementalCompilation(Set<String> changedClasses, CompileAnalysis previousAnalysis);
+
+        Optional<FileHash[]> hashClasspath(File[] classpath);
     }
 
     /**

internal/compiler-interface/src/main/mima-filters/1.0.0.backwards.excludes

@@ -0,0 +1 @@
+ProblemFilters.exclude[ReversedMissingMethodProblem]("xsbti.compile.ExternalHooks#Lookup.hashClasspath")

internal/zinc-core/src/main/scala/sbt/internal/inc/Lookup.scala

@@ -90,3 +90,12 @@ trait ExternalLookup extends ExternalHooks.Lookup {
     shouldDoIncrementalCompilation(changedClasses.iterator().asScala.toSet, previousAnalysis)
   }
 }
+
+trait NoopExternalLookup extends ExternalLookup {
+  override def changedSources(previous: CompileAnalysis): Option[Changes[File]] = None
+  override def changedBinaries(previous: CompileAnalysis): Option[Set[File]] = None
+  override def removedProducts(previous: CompileAnalysis): Option[Set[File]] = None
+  override def shouldDoIncrementalCompilation(changedClasses: Set[String],
+                                              analysis: CompileAnalysis): Boolean = true
+  override def hashClasspath(classpath: Array[File]): Optional[Array[FileHash]] = Optional.empty()
+}

zinc/src/main/scala/sbt/internal/inc/LookupImpl.scala

@@ -8,6 +8,7 @@
 package sbt.internal.inc
 
 import java.io.File
+import java.util.Optional
 
 import xsbti.compile.{ Changes, CompileAnalysis, FileHash, MiniSetup }
 
@@ -39,11 +40,8 @@ class LookupImpl(compileConfiguration: CompileConfiguration, previousSetup: Opti
 
   private val entry = MixedAnalyzingCompiler.classPathLookup(compileConfiguration)
 
-  override def lookupAnalysis(binaryClassName: String): Option[CompileAnalysis] = {
-    analyses.collectFirst {
-      case a if a.relations.productClassName._2s.contains(binaryClassName) => a
-    }
-  }
+  override def lookupAnalysis(binaryClassName: String): Option[CompileAnalysis] =
+    analyses.find(_.relations.productClassName._2s.contains(binaryClassName))
 
   override def lookupOnClasspath(binaryClassName: String): Option[File] =
     entry(binaryClassName)
@@ -64,4 +62,7 @@ class LookupImpl(compileConfiguration: CompileConfiguration, previousSetup: Opti
   override def shouldDoIncrementalCompilation(changedClasses: Set[String],
                                               analysis: CompileAnalysis): Boolean =
     externalLookup.forall(_.shouldDoIncrementalCompilation(changedClasses, analysis))
+
+  override def hashClasspath(classpath: Array[File]): Optional[Array[FileHash]] =
+    externalLookup.map(_.hashClasspath(classpath)).getOrElse(Optional.empty())
 }

zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala

@@ -181,13 +181,21 @@ object MixedAnalyzingCompiler {
       incrementalCompilerOptions: IncOptions,
       extra: List[(String, String)]
   ): CompileConfiguration = {
-    val classpathHash = classpath map { x =>
-      FileHash.of(x, Stamper.forHash(x).hashCode)
-    }
+    val lookup = incrementalCompilerOptions.externalHooks().getExternalLookup
+
+    def doHash: Array[FileHash] =
+      classpath.map(x => FileHash.of(x, Stamper.forHash(x).hashCode))(collection.breakOut)
+
+    val classpathHash =
+      if (lookup.isPresent) {
+        val computed = lookup.get().hashClasspath(classpath.toArray)
+        if (computed.isPresent) computed.get() else doHash
+      } else doHash
+
     val compileSetup = MiniSetup.of(
       output,
       MiniOptions.of(
-        classpathHash.toArray,
+        classpathHash,
         options.toArray,
         javacOptions.toArray
       ),

zinc/src/test/scala/sbt/inc/ClasspathHashingHookSpec.scala

@@ -0,0 +1,35 @@
+package sbt.inc
+
+import java.io.File
+import java.util.Optional
+
+import sbt.internal.inc.NoopExternalLookup
+import sbt.io.IO
+import xsbti.compile.DefaultExternalHooks
+import xsbti.compile.FileHash
+import xsbti.compile.IncOptions
+
+class ClasspathHashingHookSpec extends BaseCompilerSpec {
+  it should "allow client to override classpath hashing" in {
+    IO.withTemporaryDirectory { tempDir =>
+      val setup = ProjectSetup.simple(tempDir.toPath, SourceFiles.Foo :: Nil)
+
+      def hashFile(f: File): FileHash =
+        FileHash.of(f, f.hashCode() * 37 + 41) // Some deterministic random changes
+
+      val lookup = new NoopExternalLookup {
+        override def hashClasspath(classpath: Array[File]): Optional[Array[FileHash]] =
+          Optional.of(classpath.map(hashFile))
+
+      }
+      val hooks = new DefaultExternalHooks(Optional.of(lookup), Optional.empty())
+      val compiler =
+        setup.createCompiler().copy(incOptions = IncOptions.of().withExternalHooks(hooks))
+      val result = compiler.doCompile()
+
+      result.setup().options().classpathHash().foreach { original =>
+        original shouldEqual hashFile(original.file())
+      }
+    }
+  }
+}