Workaround libraryClassName non-determinism

src/main/scala/higherkindness/rules_scala/workers/zinc/compile/FilteredRelations.scala

@@ -0,0 +1,21 @@
+package sbt.internal.inc
+
+/**
+ * Zinc's libraryClassName is a map from a library jar to class names. Problem is
+ * it's not deterministic. You only get a single class in the map and it's not always
+ * the same class. Until that bug in Zinc is fixed, we're setting the libraryClassName
+ * to an empty libraryClassName because empty is better than non-deterministic.
+ *
+ * This class is in the sbt.internal.inc package to get access to the MRelationsNameHashing
+ * class, which is private to that package. Super duper hacky, but I wasn't able to find a
+ * better way to change the libraryClassName for the relation.
+ */
+object FilteredRelations {
+  def getFilteredRelations(relations: Relations): Relations = {
+    val emptyRelations = Relations.empty
+
+    relations.asInstanceOf[MRelationsNameHashing].copy(
+      libraryClassName = emptyRelations.libraryClassName
+    )
+  }
+}

src/main/scala/higherkindness/rules_scala/workers/zinc/compile/ZincRunner.scala

@@ -20,7 +20,7 @@ import net.sourceforge.argparse4j.impl.{Arguments => Arg}
 import net.sourceforge.argparse4j.inf.Namespace
 import sbt.internal.inc.classpath.ClassLoaderCache
 import sbt.internal.inc.caching.ClasspathCache
-import sbt.internal.inc.{Analysis, CompileFailed, IncrementalCompilerImpl, Locate, PlainVirtualFile, PlainVirtualFileConverter, ZincUtil}
+import sbt.internal.inc.{Analysis, CompileFailed, FilteredRelations, IncrementalCompilerImpl, Locate, PlainVirtualFile, PlainVirtualFileConverter, Relations, ZincUtil}
 import scala.jdk.CollectionConverters._
 import scala.util.Try
 import scala.util.control.NonFatal
@@ -279,12 +279,19 @@ object ZincRunner extends WorkerMain[Namespace] {
       true,
       usePersistence,
     )
-    analysisStoreText.set(AnalysisContents.create(compileResult.analysis, compileResult.setup))
-    analysisStore.set(AnalysisContents.create(compileResult.analysis, compileResult.setup))
-
+    // Filter out libraryClassNames from the analysis because it is non-deterministic.
+    // Can stop doing this once the bug in Zinc is fixed. Check the comment on FilteredRelations
+    // for more info.
+    val resultAnalysis = {
+      val originalResultAnalysis = compileResult.analysis.asInstanceOf[Analysis]
+      originalResultAnalysis.copy(
+          relations = FilteredRelations.getFilteredRelations(originalResultAnalysis.relations)
+      )
+    }
+    analysisStoreText.set(AnalysisContents.create(resultAnalysis, compileResult.setup))
+    analysisStore.set(AnalysisContents.create(resultAnalysis, compileResult.setup))
 
     // create used deps
-    val resultAnalysis = compileResult.analysis.asInstanceOf[Analysis]
     val usedDeps =
       // Filter out the Scala standard library as that should just always be
       // implicitly available and not something we should be book keeping.