Merge pull request #120 from trentjeff/main

lukaseder · web-flow · commit 1db3c5feee94 · 2022-03-31T08:49:56.000+02:00
support for -proc:only compiler option
diff --git a/jOOR-java-8/pom.xml b/jOOR-java-8/pom.xml
@@ -11,7 +11,7 @@
 
     <groupId>org.jooq</groupId>
     <artifactId>joor-java-8</artifactId>
-    <version>0.9.14</version>
+    <version>0.9.14.2</version>
     <packaging>bundle</packaging>
 
     <name>jOOR</name>
diff --git a/jOOR-java-8/src/main/java/org/joor/Compile.java b/jOOR-java-8/src/main/java/org/joor/Compile.java
@@ -95,15 +95,19 @@ static Class<?> compile(String className, String content, CompileOptions compile
                     options.addAll(Arrays.asList("-classpath", classpath.toString()));
                 }
 
-                CompilationTask task = compiler.getTask(out, fileManager, null, options, null, files);
+                CompilationTask task = compiler.getTask(out, fileManager, compileOptions.diagnosticListener, options, null, files);
 
                 if (!compileOptions.processors.isEmpty())
                     task.setProcessors(compileOptions.processors);
 
                 task.call();
 
-                if (fileManager.isEmpty())
+                if (fileManager.isEmpty()) {
+                    if (compileOptions.hasOption("-proc:only")) {
+                        return null;
+                    }
                     throw new ReflectException("Compilation error: " + out);
+                }
 
                 Class<?> result = null;
 
diff --git a/jOOR-java-8/src/main/java/org/joor/CompileOptions.java b/jOOR-java-8/src/main/java/org/joor/CompileOptions.java
@@ -21,6 +21,8 @@
 import java.util.List;
 
 import javax.annotation.processing.Processor;
+import javax.tools.DiagnosticListener;
+import javax.tools.JavaFileObject;
 
 /**
  * @author Lukas Eder
@@ -29,6 +31,7 @@ public final class CompileOptions {
 
     final List<? extends Processor> processors;
     final List<String> options;
+    DiagnosticListener<JavaFileObject> diagnosticListener;
 
     public CompileOptions() {
         this(
@@ -60,5 +63,20 @@ public final CompileOptions options(String... newOptions) {
     public final CompileOptions options(List<String> newOptions) {
         return new CompileOptions(processors, newOptions);
     }
+
+    public boolean hasOption(String opt) {
+        for (String option : options) {
+            if (option.equalsIgnoreCase(opt)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public CompileOptions withDiagnosticListener(DiagnosticListener<JavaFileObject> listener) {
+        this.diagnosticListener = listener;
+        return this;
+    }
+
 }
 
diff --git a/jOOR-java-8/src/main/java/org/joor/Reflect.java b/jOOR-java-8/src/main/java/org/joor/Reflect.java
@@ -26,6 +26,7 @@
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 
 /**
@@ -198,7 +199,7 @@ public static Reflect onClass(String name, ClassLoader classLoader) throws Refle
      * @return A wrapped class object, to be used for further reflection.
      */
     public static Reflect onClass(Class<?> clazz) {
-        return new Reflect(clazz);
+        return Objects.isNull(clazz) ? null : new Reflect(clazz);
     }
 
     /**
diff --git a/jOOR-java-8/src/test/java/org/joor/test/CompileOptionsTest.java b/jOOR-java-8/src/test/java/org/joor/test/CompileOptionsTest.java
@@ -13,14 +13,11 @@
  */
 package org.joor.test;
 
-import java.io.Serializable;
 import java.util.Collections;
 
-
-
-import java.util.HashSet;
+import java.util.Locale;
 import java.util.Set;
-import java.util.function.Supplier;
+import java.util.concurrent.atomic.AtomicReference;
 
 import javax.annotation.processing.Completion;
 import javax.annotation.processing.ProcessingEnvironment;
@@ -31,11 +28,11 @@
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
 
 import org.joor.CompileOptions;
 import org.joor.Reflect;
 import org.joor.ReflectException;
-import org.junit.Assert;
 import org.junit.Test;
 
 import static org.junit.Assert.*;
@@ -159,6 +156,7 @@ public SourceVersion getSupportedSourceVersion() {
 
         @Override
         public void init(ProcessingEnvironment processingEnv) {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "running " + getClass().getName());
         }
 
         @Override
@@ -178,6 +176,24 @@ public Iterable<? extends Completion> getCompletions(Element element, Annotation
             return Collections.emptyList();
         }
     }
+
+    /**
+     * -proc:only is a standard option and should be supported.
+     * see https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javac.html
+     */
+    @Test
+    public void testProcOnlyWithDiagnostics() {
+        AtomicReference<String> diagMessage = new AtomicReference<>();
+        Object result = Reflect.compile("p.D", "package p; public class D extends B {} class B {}",
+                                        new CompileOptions().options("-proc:only")
+                                                .processors(new AProcessor())
+                                                .withDiagnosticListener(diagnostic -> {
+                                                    diagMessage.set(diagnostic.getMessage(Locale.ENGLISH));
+                                                }));
+        assertNull(result);
+        assertNotNull(diagMessage.get());
+    }
+
 }
 
 @interface A {}
