From 689eac7c8dfd9994e1472a76dddf82928f13c9df Mon Sep 17 00:00:00 2001 From: Stephan Schroevers Date: Wed, 25 May 2022 16:06:54 +0200 Subject: [PATCH] Ugh, classpath issues --- .../bugpatterns/CodeTransformers.java | 16 ++++++++++++ .../errorprone/bugpatterns/RefasterCheck.java | 25 +++++++++++++++---- .../javac/caching/CachingJavacCompiler.java | 2 ++ 3 files changed, 38 insertions(+), 5 deletions(-) create mode 100644 error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CodeTransformers.java diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CodeTransformers.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CodeTransformers.java new file mode 100644 index 00000000..729ba996 --- /dev/null +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CodeTransformers.java @@ -0,0 +1,16 @@ +package tech.picnic.errorprone.bugpatterns; + +import com.google.common.hash.Hashing; +import com.google.common.reflect.ClassPath; +import java.io.IOException; + +final class CodeTransformers { + // XXX: Use. + private static void foo(ClassPath.ResourceInfo resource) { + try { + resource.asByteSource().hash(Hashing.murmur3_32_fixed(0)).toString(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } +} diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RefasterCheck.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RefasterCheck.java index 163747e1..e7e06a42 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RefasterCheck.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RefasterCheck.java @@ -31,6 +31,7 @@ import com.google.errorprone.bugpatterns.BugChecker.CompilationUnitTreeMatcher; import com.google.errorprone.fixes.Replacement; import com.google.errorprone.matchers.Description; import com.sun.source.tree.CompilationUnitTree; +import com.sun.source.util.TreePath; import com.sun.tools.javac.tree.EndPosTable; import com.sun.tools.javac.tree.JCTree.JCCompilationUnit; import java.io.IOException; @@ -47,6 +48,7 @@ import java.util.concurrent.ConcurrentMap; import java.util.function.Supplier; import java.util.regex.Pattern; import java.util.stream.Stream; +import javax.naming.Context; import tech.picnic.errorprone.plexus.compiler.javac.caching.CachingJavacCompiler; /** @@ -73,7 +75,8 @@ public final class RefasterCheck extends BugChecker implements CompilationUnitTr static final Supplier> ALL_CODE_TRANSFORMERS = Suppliers.memoize(RefasterCheck::loadAllCodeTransformers); - private final CodeTransformer codeTransformer; + private final ErrorProneFlags errorProneFlags; + private final Supplier codeTransformer; /** Instantiates the default {@link RefasterCheck}. */ public RefasterCheck() { @@ -86,25 +89,37 @@ public final class RefasterCheck extends BugChecker implements CompilationUnitTr * @param flags Any provided command line flags. */ public RefasterCheck(ErrorProneFlags flags) { - codeTransformer = createCompositeCodeTransformer(flags); + errorProneFlags = flags; + codeTransformer = Suppliers.memoize(() -> createCompositeCodeTransformer(flags)); } + // XXX: Need to somehow convert `Description` to handle classloading issue. + // private BiFunction> + @Override public Description matchCompilationUnit(CompilationUnitTree tree, VisitorState state) { + // XXX Use the `codeTransformer` field only if `cache` is empty. In that case, populate the + // cache. + // XXX: Current code is wrong: doesn't respect flags. System.out.println("XXXX :" + CachingJavacCompiler.class.toString()); - ConcurrentMap cache = state.context.get(ConcurrentMap.class); + System.out.println("XXXX Path :" + TreePath.class.hashCode()); + System.out.println("XXXX Context:" + Context.class.hashCode()); + ConcurrentMap cache = state.context.get(ConcurrentMap.class); System.err.printf("XXX %s%n", cache); + CodeTransformer transformer; if (cache != null) { - cache.compute("x", (a, b) -> b == null ? 1 : b + 1); + cache.compute("x", (a, b) -> b instanceof Integer ? ((Integer) b) + 1 : 1); + transformer = (CodeTransformer) cache.computeIfAbsent("c", k -> codeTransformer.get()); } else { // We're not using the hacked compiler System.err.printf("XXX NOP!%n"); + transformer = codeTransformer.get(); } /* First, collect all matches. */ List matches = new ArrayList<>(); try { - codeTransformer.apply(state.getPath(), new SubContext(state.context), matches::add); + transformer.apply(state.getPath(), new SubContext(state.context), matches::add); } catch (LinkageError e) { // XXX: This `try/catch` block handles the issue described and resolved in // https://github.com/google/error-prone/pull/2456. Drop this block once that change is diff --git a/plexus-compiler-javac-caching/src/main/java/tech/picnic/errorprone/plexus/compiler/javac/caching/CachingJavacCompiler.java b/plexus-compiler-javac-caching/src/main/java/tech/picnic/errorprone/plexus/compiler/javac/caching/CachingJavacCompiler.java index 6233b573..720b07d4 100644 --- a/plexus-compiler-javac-caching/src/main/java/tech/picnic/errorprone/plexus/compiler/javac/caching/CachingJavacCompiler.java +++ b/plexus-compiler-javac-caching/src/main/java/tech/picnic/errorprone/plexus/compiler/javac/caching/CachingJavacCompiler.java @@ -61,6 +61,8 @@ public final class CachingJavacCompiler extends JavaxToolsCompiler { System.out.println("XXXX I'm invoked!"); Context context = new Context(); // XXX: Explain. + // XXX: This hack should be hidden in a utility class, exposed by a separate Maven module (to + // be used both here and within RefasterCheck). context.put(ConcurrentMap.class, cache); return delegate.getTask( out, fileManager, diagnosticListener, options, classes, compilationUnits, context);