perf: improve performance of isForMissingSuperclass (again).

Author: autonomousapps

graph-support/src/main/kotlin/com/autonomousapps/graph/Graphs.kt

@@ -43,6 +43,15 @@ public object Graphs {
     }
   }
 
+  // TODO(tsr): this function hasn't been published yet.
+  /** Returns all nodes in this graph that are reachable from all nodes matching [predicate]. */
+  public fun <N : Any> Graph<N>.reachableNodesMatching(predicate: (N) -> Boolean): Set<N> {
+    return nodes().asSequence()
+      .filter(predicate)
+      .flatMap { node -> GuavaGraphs.reachableNodes(this, node) }
+      .toSet()
+  }
+
   /**
    * Returns the first node it finds that has an in-degree of 0. This is the root node if this DAG contains only one
    * such node.

src/main/kotlin/com/autonomousapps/model/internal/ProjectVariant.kt

@@ -29,6 +29,10 @@ internal data class ProjectVariant(
     sources.filterIsInstance<CodeSource>()
   }
 
+  val classNames: Set<String> by unsafeLazy {
+    codeSource.mapToOrderedSet { src -> src.className }
+  }
+
   val usedNonAnnotationClassesBySrc: Set<String> by unsafeLazy {
     codeSource.flatMapToSet {
       it.usedNonAnnotationClasses
@@ -89,11 +93,9 @@ internal data class ProjectVariant(
   val externalSupers: Set<String> by unsafeLazy {
     val supers = codeSource.mapNotNullToOrderedSet { src -> src.superClass }
     val interfaces = codeSource.flatMapToOrderedSet { src -> src.interfaces }
-    // These are all the super classes and interfaces in "this" module
-    val localClasses = codeSource.mapToOrderedSet { src -> src.className }
     // These super classes and interfaces are not available from "this" module, so must come from dependencies.
-    val externalSupers = supers - localClasses
-    val externalInterfaces = interfaces - localClasses
+    val externalSupers = supers - classNames
+    val externalInterfaces = interfaces - classNames
     val externals = externalSupers + externalInterfaces
 
     externals

src/main/kotlin/com/autonomousapps/tasks/ComputeUsagesTask.kt

@@ -17,6 +17,7 @@ import com.autonomousapps.model.internal.intermediates.DependencyTraceReport.Kin
 import com.autonomousapps.model.internal.intermediates.Reason
 import com.autonomousapps.visitor.GraphViewReader
 import com.autonomousapps.visitor.GraphViewVisitor
+import com.google.common.graph.Graphs
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.RegularFile
@@ -373,19 +374,25 @@ private class GraphVisitor(
     context: GraphViewVisitor.Context,
   ): Boolean {
     val superGraph = context.superGraph
+    val externalSupers = context.project.externalSupers
 
     // collect all the dependencies associated with external supers
-    val requiredExternalClasses = context.project.externalSupers.asSequence()
-      .flatMap { external -> superGraph.reachableNodes(false) { it.className == external } }
-      .mapNotNull { node ->
-        val deps = node.deps.filterToOrderedSet { dep ->
+    // nb: we start by iterating over `supergraph.nodes()`, and then filtering, as that is _far more efficient_
+    // then iterating over `externalSupers` and then calling `supergraph.nodes()` repeatedly: I have observed graphs
+    // with hundreds of thousands of nodes. This is why we use Guava directly here rather than going through our own
+    // Graphs wrapper. There's a yet-to-be-published update to the wrapper that does this for us.
+    val requiredExternalClasses = superGraph.nodes().asSequence()
+      .filter { superNode -> superNode.className in externalSupers }
+      .flatMap { superNode -> Graphs.reachableNodes(superGraph, superNode) }
+      .mapNotNull { superNode ->
+        val deps = superNode.deps.filterToOrderedSet { dep ->
           // If dep has just one parent and it's the root, then we must retain that edge
           val graph = context.graph.graph
           graph.parents(dep).singleOrNull { it == graph.root() } != null
         }
 
         if (deps.isNotEmpty()) {
-          SuperNode(node.className).apply { this.deps += deps }
+          SuperNode(superNode.className).apply { this.deps += deps }
         } else {
           null
         }

src/main/kotlin/com/autonomousapps/visitor/GraphViewReader.kt

@@ -37,6 +37,9 @@ internal class DefaultContext(
 ) : GraphViewVisitor.Context {
 
   override val superGraph: Graph<SuperNode> by unsafeLazy {
+    // TODO(tsr): use localClassNames to build smaller graphs? May be necessary to further improve performance of
+    //  ComputeUsagesAction::isForMissingSuperclass
+    // SuperClassGraphBuilder.of(dependencies, project.classNames)
     SuperClassGraphBuilder.of(dependencies)
   }
 }