Speed up Refaster bug checker

pom.xml

@@ -207,7 +207,12 @@
         <version.error-prone-fork>v${version.error-prone-orig}-picnic-1</version.error-prone-fork>
         <version.error-prone-orig>2.24.0</version.error-prone-orig>
         <version.jdk>11</version.jdk>
+        <version.jmh>1.37</version.jmh>
         <version.maven>3.8.7</version.maven>
+        <!-- XXX: Consider providing our own implementation with similar
+        functionality, and designing it such that JMH classes would not need to
+        be annotated `@Open`. -->
+        <version.nopen>1.0.1</version.nopen>
         <version.pitest-git>1.1.4</version.pitest-git>
     </properties>
 
@@ -322,10 +327,15 @@
                 <artifactId>truth</artifactId>
                 <version>1.2.0</version>
             </dependency>
+            <dependency>
+                <groupId>com.jakewharton.nopen</groupId>
+                <artifactId>nopen-annotations</artifactId>
+                <version>${version.nopen}</version>
+            </dependency>
             <dependency>
                 <groupId>com.jakewharton.nopen</groupId>
                 <artifactId>nopen-checker</artifactId>
-                <version>1.0.1</version>
+                <version>${version.nopen}</version>
             </dependency>
             <dependency>
                 <groupId>com.uber.nullaway</groupId>
@@ -451,6 +461,16 @@
                     </exclusion>
                 </exclusions>
             </dependency>
+            <dependency>
+                <groupId>org.openjdk.jmh</groupId>
+                <artifactId>jmh-core</artifactId>
+                <version>${version.jmh}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.openjdk.jmh</groupId>
+                <artifactId>jmh-generator-annprocess</artifactId>
+                <version>${version.jmh}</version>
+            </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-bom</artifactId>
@@ -545,7 +565,6 @@
                     <configuration>
                         <bundledSignatures>
                             <bundledSignature>jdk-internal</bundledSignature>
-                            <bundledSignature>jdk-reflection</bundledSignature>
                             <bundledSignature>jdk-system-out</bundledSignature>
                             <!-- Other bundles are available but currently not
                             enabled:
@@ -555,6 +574,10 @@
                             - jdk-deprecated: we compile with `-Xlint:all`,
                               which causes the build to fail when _any_
                               deprecated method is called.
+                            - jdk-reflection: this bundle should probably be
+                              enabled, but currently
+                              `java.lang.reflect.AccessibleObject#setAccessible`
+                              is still called in various places.
                             - jdk-non-portable: the Error Prone integration
                               crucially relies on some of these APIs.
                             - jdk-unsafe: see
@@ -887,10 +910,19 @@
                                 <groupId>com.google.auto.value</groupId>
                                 <artifactId>auto-value</artifactId>
                             </path>
+                            <path>
+                                <groupId>com.google.auto.value</groupId>
+                                <artifactId>auto-value</artifactId>
+                                <version>${version.auto-value}</version>
+                            </path>
                             <path>
                                 <groupId>com.google.auto.service</groupId>
                                 <artifactId>auto-service</artifactId>
                             </path>
+                            <path>
+                                <groupId>org.openjdk.jmh</groupId>
+                                <artifactId>jmh-generator-annprocess</artifactId>
+                            </path>
                         </annotationProcessorPaths>
                         <compilerArgs>
                             <arg>--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
@@ -1156,6 +1188,11 @@
                     <artifactId>build-helper-maven-plugin</artifactId>
                     <version>3.5.0</version>
                 </plugin>
+                <plugin>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>exec-maven-plugin</artifactId>
+                    <version>3.1.1</version>
+                </plugin>
                 <plugin>
                     <groupId>org.codehaus.mojo</groupId>
                     <artifactId>license-maven-plugin</artifactId>
@@ -1230,6 +1267,7 @@
                                 <!-- -->
                                 GPL-2.0-with-classpath-exception
                                 | CDDL/GPLv2+CE
+                                | GNU General Public License (GPL), version 2, with the Classpath exception
                                 | GNU General Public License, version 2 (GPL2), with the classpath exception
                                 | GNU General Public License, version 2, with the Classpath Exception
                                 | GPL2 w/ CPE
@@ -1438,17 +1476,6 @@
                                 </rules>
                             </configuration>
                         </plugin>
-                        <plugin>
-                            <groupId>org.apache.maven.plugins</groupId>
-                            <artifactId>maven-surefire-plugin</artifactId>
-                            <configuration>
-                                <systemPropertyVariables>
-                                    <!-- Property used by `ErrorProneForkTest`
-                                    to verify fork identification. -->
-                                    <error-prone-fork-in-use>true</error-prone-fork-in-use>
-                                </systemPropertyVariables>
-                            </configuration>
-                        </plugin>
                     </plugins>
                 </pluginManagement>
             </build>
@@ -1942,5 +1969,66 @@
                 </plugins>
             </build>
         </profile>
+        <profile>
+            <!-- Enables execution of a JMH benchmark. Given a benchmark class
+            `tech.picnic.MyBenchmark`, the following command (executed against
+            the (sub)module in which the benchmark resides) will compile and
+            execute said benchmark:
+
+              mvn process-test-classes -Dverification.skip \
+                -Djmh.run-benchmark=tech.picnic.MyBenchmark
+            -->
+            <id>run-jmh-benchmark</id>
+            <activation>
+                <property>
+                    <name>jmh.run-benchmark</name>
+                </property>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-dependency-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <id>build-jmh-runtime-classpath</id>
+                                <goals>
+                                    <goal>build-classpath</goal>
+                                </goals>
+                                <configuration>
+                                    <outputProperty>testClasspath</outputProperty>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>exec-maven-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <id>run-jmh-benchmark</id>
+                                <goals>
+                                    <goal>java</goal>
+                                </goals>
+                                <phase>process-test-classes</phase>
+                                <configuration>
+                                    <classpathScope>test</classpathScope>
+                                    <mainClass>${jmh.run-benchmark}</mainClass>
+                                    <systemProperties>
+                                        <!-- The runtime classpath is defined
+                                        in this way so that any JVMs forked by
+                                        JMH will have the desired classpath. -->
+                                        <systemProperty>
+                                            <key>java.class.path</key>
+                                            <value>${project.build.testOutputDirectory}${path.separator}${project.build.outputDirectory}${path.separator}${testClasspath}</value>
+                                        </systemProperty>
+                                    </systemProperties>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
     </profiles>
 </project>

refaster-runner/pom.xml

@@ -29,6 +29,11 @@
             <artifactId>error_prone_check_api</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>${groupId.error-prone}</groupId>
+            <artifactId>error_prone_core</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>${groupId.error-prone}</groupId>
             <artifactId>error_prone_test_helpers</artifactId>
@@ -45,18 +50,31 @@
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>refaster-support</artifactId>
-            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.auto</groupId>
+            <artifactId>auto-common</artifactId>
+            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>com.google.auto.service</groupId>
             <artifactId>auto-service-annotations</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.auto.value</groupId>
+            <artifactId>auto-value-annotations</artifactId>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.jakewharton.nopen</groupId>
+            <artifactId>nopen-annotations</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>javax.inject</groupId>
             <artifactId>javax.inject</artifactId>
@@ -87,6 +105,11 @@
             <artifactId>junit-jupiter-params</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/Node.java

@@ -0,0 +1,126 @@
+package tech.picnic.errorprone.refaster.runner;
+
+import static java.util.Comparator.comparingInt;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.collect.Maps;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * A node in an immutable tree.
+ *
+ * <p>The tree's edges are string-labeled, while its leaves store values of type {@code T}.
+ */
+@AutoValue
+abstract class Node<T> {
+  // XXX: Review: should this method accept a `SetMultimap<V, ? extends Set<String>>`, or should
+  // there be such an overload?
+  static <T> Node<T> create(
+      Set<T> values, Function<? super T, ? extends Set<? extends Set<String>>> pathExtractor) {
+    Builder<T> tree = Builder.create();
+    tree.register(values, pathExtractor);
+    return tree.build();
+  }
+
+  abstract ImmutableMap<String, Node<T>> children();
+
+  abstract ImmutableList<T> values();
+
+  // XXX: Consider having `RefasterRuleSelector` already collect the candidate edges into a
+  // `SortedSet`, as that would likely speed up `ImmutableSortedSet#copyOf`.
+  // XXX: If this ^ proves worthwhile, then the test code and benchmark should be updated
+  // accordingly.
+  void collectReachableValues(Set<String> candidateEdges, Consumer<T> sink) {
+    collectReachableValues(ImmutableSortedSet.copyOf(candidateEdges).asList(), sink);
+  }
+
+  private void collectReachableValues(ImmutableList<String> candidateEdges, Consumer<T> sink) {
+    values().forEach(sink);
+
+    if (candidateEdges.isEmpty() || children().isEmpty()) {
+      return;
+    }
+
+    /*
+     * For performance reasons we iterate over the smallest set of edges. In case there are fewer
+     * children than candidate edges we iterate over the former, at the cost of not pruning the set
+     * of candidate edges if a transition is made.
+     */
+    int candidateEdgeCount = candidateEdges.size();
+    if (children().size() < candidateEdgeCount) {
+      for (Map.Entry<String, Node<T>> e : children().entrySet()) {
+        if (candidateEdges.contains(e.getKey())) {
+          e.getValue().collectReachableValues(candidateEdges, sink);
+        }
+      }
+    } else {
+      for (int i = 0; i < candidateEdgeCount; i++) {
+        Node<T> child = children().get(candidateEdges.get(i));
+        if (child != null) {
+          child.collectReachableValues(candidateEdges.subList(i + 1, candidateEdgeCount), sink);
+        }
+      }
+    }
+  }
+
+  @AutoValue
+  @SuppressWarnings("AutoValueImmutableFields" /* Type is used only during `Node` construction. */)
+  abstract static class Builder<T> {
+    private static <T> Builder<T> create() {
+      return new AutoValue_Node_Builder<>(new HashMap<>(), new ArrayList<>());
+    }
+
+    abstract Map<String, Builder<T>> children();
+
+    abstract List<T> values();
+
+    /**
+     * Registers all paths to each of the given values.
+     *
+     * <p>Shorter paths are registered first, so that longer paths can be skipped if a strict prefix
+     * leads to the same value.
+     */
+    private void register(
+        Set<T> values, Function<? super T, ? extends Set<? extends Set<String>>> pathsExtractor) {
+      for (T value : values) {
+        List<? extends Set<String>> paths = new ArrayList<>(pathsExtractor.apply(value));
+        /*
+         * We sort paths by length ascending, so that in case of two paths where one is an initial
+         * prefix of the other, only the former is encoded (thus saving some space).
+         */
+        paths.sort(comparingInt(Set::size));
+        paths.forEach(path -> registerPath(value, ImmutableList.sortedCopyOf(path)));
+      }
+    }
+
+    private void registerPath(T value, ImmutableList<String> path) {
+      if (values().contains(value)) {
+        /* Another (shorter) path already leads to this value. */
+        return;
+      }
+
+      if (path.isEmpty()) {
+        values().add(value);
+      } else {
+        children()
+            .computeIfAbsent(path.get(0), k -> create())
+            .registerPath(value, path.subList(1, path.size()));
+      }
+    }
+
+    private Node<T> build() {
+      return new AutoValue_Node<>(
+          ImmutableMap.copyOf(Maps.transformValues(children(), Builder::build)),
+          ImmutableList.copyOf(values()));
+    }
+  }
+}