Create defined class to perform analysis within thread (#338)

When refactoring from an Anonymous class to a lambda, an infinite
recursion occurred because each analysis was required to then
fork and create a new analysis when it was done because it defined
a new anonymous class.

This change defines the class specifically to avoid it analyzing
itself. A follow up should be to filter anonymous classes unrelated
to ParSeq.

Author: cbrentharris

gradle.properties

@@ -1,3 +1,3 @@
-version=5.1.14
+version=5.1.15
 group=com.linkedin.parseq
 org.gradle.parallel=true

subprojects/parseq-lambda-names/src/main/java/com/linkedin/parseq/lambda/ASMBasedTaskDescriptor.java

@@ -183,6 +183,49 @@ private static void add(String lambdaClassName, String description) {
 
   public static class Analyzer implements ClassFileTransformer {
 
+    /**
+     * Defining this class as not anonymous to avoid analyzing the runnable that is created to
+     * perform analysis. Without this, it is easy for an infinite loop to occur when using a lambda,
+     * which would result in a {@link StackOverflowError}, because when performing an analysis of the lambda
+     * would then require a new analysis of a new lambda.
+     *
+     * TODO: Avoid analyzing anonymous classes unrelated to parseq
+     */
+    static class AnalyzerRunnable implements Runnable {
+      private final byte[] byteCode;
+      private final ClassLoader loader;
+      private final Exception e;
+
+      private AnalyzerRunnable(byte[] byteCode, ClassLoader loader, Exception e) {
+        this.byteCode = byteCode;
+        this.loader = loader;
+        this.e = e;
+      }
+
+      public static AnalyzerRunnable of(byte[] byteCode, ClassLoader loader, Exception e) {
+        return new AnalyzerRunnable(byteCode, loader, e);
+      }
+
+      @Override
+      public void run() {
+        try {
+          doAnalyze(byteCode, loader, e);
+        } catch (Throwable t) {
+          /*
+           * We need to catch  everything because other
+           * threads may be blocked on CountDownLatch.
+           */
+          System.out.println("WARNING: Parseq cannot doAnalyze");
+          t.printStackTrace();
+        }
+        if (_count.decrementAndGet() == 0) {
+          CountDownLatch latch = _latchRef.getAndSet(null);
+          latch.countDown();
+        }
+
+      }
+    }
+
     @Override
     public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
         ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
@@ -205,22 +248,7 @@ public static void analyze(byte[] byteCode, ClassLoader loader) {
         }
       }
       final Exception e = new Exception();
-      ForkJoinPool.commonPool().execute(() -> {
-        try {
-          doAnalyze(byteCode, loader, e);
-        } catch (Throwable t) {
-          /*
-           * We need to catch  everything because other
-           * threads may be blocked on CountDownLatch.
-           */
-          System.out.println("WARNING: Parseq cannot doAnalyze");
-          t.printStackTrace();
-        }
-        if (_count.decrementAndGet() == 0) {
-          CountDownLatch latch = _latchRef.getAndSet(null);
-          latch.countDown();
-        }
-      });
+      ForkJoinPool.commonPool().execute(AnalyzerRunnable.of(byteCode, loader, e));
     }
 
     public static void doAnalyze(byte[] byteCode, ClassLoader loader, Exception exception) {