Add a custom compile argument replaceProcessorPathWithProcessorModulePath to force the plugin replace processorPath with processormodulepath

Closes #191 #192

Author: vipcxj

plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus/compiler/eclipse/EclipseJavaCompiler.java

@@ -24,24 +24,12 @@
  * SOFTWARE.
  */
 
-import org.codehaus.plexus.compiler.AbstractCompiler;
-import org.codehaus.plexus.compiler.Compiler;
-import org.codehaus.plexus.compiler.CompilerConfiguration;
-import org.codehaus.plexus.compiler.CompilerException;
-import org.codehaus.plexus.compiler.CompilerMessage;
-import org.codehaus.plexus.compiler.CompilerOutputStyle;
-import org.codehaus.plexus.compiler.CompilerResult;
-import org.codehaus.plexus.component.annotations.Component;
-import org.codehaus.plexus.util.DirectoryScanner;
-import org.codehaus.plexus.util.StringUtils;
-import org.eclipse.jdt.core.compiler.CompilationProgress;
-import org.eclipse.jdt.core.compiler.batch.BatchCompiler;
-
 import javax.tools.Diagnostic;
 import javax.tools.DiagnosticListener;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
+
 import java.io.File;
 import java.io.PrintWriter;
 import java.io.StringWriter;
@@ -56,6 +44,19 @@
 import java.util.ServiceLoader;
 import java.util.Set;
 
+import org.codehaus.plexus.compiler.AbstractCompiler;
+import org.codehaus.plexus.compiler.Compiler;
+import org.codehaus.plexus.compiler.CompilerConfiguration;
+import org.codehaus.plexus.compiler.CompilerException;
+import org.codehaus.plexus.compiler.CompilerMessage;
+import org.codehaus.plexus.compiler.CompilerOutputStyle;
+import org.codehaus.plexus.compiler.CompilerResult;
+import org.codehaus.plexus.component.annotations.Component;
+import org.codehaus.plexus.util.DirectoryScanner;
+import org.codehaus.plexus.util.StringUtils;
+import org.eclipse.jdt.core.compiler.CompilationProgress;
+import org.eclipse.jdt.core.compiler.batch.BatchCompiler;
+
 /**
  *
  */
@@ -206,7 +207,14 @@ public CompilerResult performCompile( CompilerConfiguration config )
 
  if ( processorPathEntries != null && processorPathEntries.size() > 0 )
  {
- args.add( "-processorpath" );
+ if ( isReplaceProcessorPath( config ) )
+ {
+ args.add( "--processor-module-path" );
+ }
+ else
+ {
+ args.add( "-processorpath" );
+ }
  args.add( getPathString( processorPathEntries ) );
  }
 
@@ -478,6 +486,22 @@ public void worked( int i, int i1 )
  }
  }
 
+ private static final String OPT_REPLACE_PROCESSOR_PATH = "replaceProcessorPathWithProcessorModulePath";
+ private static final String OPT_REPLACE_PROCESSOR_PATH_ = "-" + OPT_REPLACE_PROCESSOR_PATH;
+
+ static boolean isReplaceProcessorPath( CompilerConfiguration config )
+ {
+ for ( Entry<String, String> entry : config.getCustomCompilerArgumentsEntries() )
+ {
+ String opt = entry.getKey();
+ if ( opt.equals( OPT_REPLACE_PROCESSOR_PATH ) || opt.equals( OPT_REPLACE_PROCESSOR_PATH_ ) )
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
  static List<String> resortSourcesToPutModuleInfoFirst( List<String> allSources )
  {
  ArrayList<String> resorted = new ArrayList<>();
@@ -538,46 +562,49 @@ static boolean processCustomArguments( CompilerConfiguration config, List<String
  continue;
  }
 
- /*
- * The compiler mojo makes quite a mess of passing arguments, depending on exactly WHICH
- * way is used to pass them. The method method using <compilerArguments> uses the tag names
- * of its contents to denote option names, and so the compiler mojo happily adds a '-' to
- * all of the names there and adds them to the "custom compiler arguments" map as a
- * name, value pair where the name always contains a single '-'. The Eclipse compiler (and
- * javac too, btw) has options with two dashes (like --add-modules for java 9). These cannot
- * be passed using a <compilerArguments> tag.
- *
- * The other method is to use <compilerArgs>, where each SINGLE argument needs to be passed
- * using an <arg>xxxx</arg> tag. In there the xxx is not manipulated by the compiler mojo, so
- * if it starts with a dash or more dashes these are perfectly preserved. But of course these
- * single <arg> entries are not a pair. So the compiler mojo adds them as pairs of (xxxx, null).
- *
- * We use that knowledge here: if a pair has a null value then do not mess up the key but
- * render it as a single value. This should ensure that something like:
- * <compilerArgs>
- * <arg>--add-modules</arg>
- * <arg>java.se.ee</arg>
- * </compilerArgs>
- *
- * is actually added to the command like as such.
- *
- * (btw: the above example will still give an error when using ecj <= 4.8M6:
- * invalid module name: java.se.ee
- * but that seems to be a bug in ecj).
- */
- if ( null == optionValue )
- {
- //-- We have an option from compilerArgs: use the key as-is as a single option value
- args.add( opt );
- }
- else
+ if ( !opt.equals( OPT_REPLACE_PROCESSOR_PATH ) && !opt.equals( OPT_REPLACE_PROCESSOR_PATH_ ) )
  {
- if ( !opt.startsWith( "-" ) )
+ /*
+ * The compiler mojo makes quite a mess of passing arguments, depending on exactly WHICH
+ * way is used to pass them. The method method using <compilerArguments> uses the tag names
+ * of its contents to denote option names, and so the compiler mojo happily adds a '-' to
+ * all of the names there and adds them to the "custom compiler arguments" map as a
+ * name, value pair where the name always contains a single '-'. The Eclipse compiler (and
+ * javac too, btw) has options with two dashes (like --add-modules for java 9). These cannot
+ * be passed using a <compilerArguments> tag.
+ *
+ * The other method is to use <compilerArgs>, where each SINGLE argument needs to be passed
+ * using an <arg>xxxx</arg> tag. In there the xxx is not manipulated by the compiler mojo, so
+ * if it starts with a dash or more dashes these are perfectly preserved. But of course these
+ * single <arg> entries are not a pair. So the compiler mojo adds them as pairs of (xxxx, null).
+ *
+ * We use that knowledge here: if a pair has a null value then do not mess up the key but
+ * render it as a single value. This should ensure that something like:
+ * <compilerArgs>
+ * <arg>--add-modules</arg>
+ * <arg>java.se.ee</arg>
+ * </compilerArgs>
+ *
+ * is actually added to the command like as such.
+ *
+ * (btw: the above example will still give an error when using ecj <= 4.8M6:
+ * invalid module name: java.se.ee
+ * but that seems to be a bug in ecj).
+ */
+ if ( null == optionValue )
+ {
+ //-- We have an option from compilerArgs: use the key as-is as a single option value
+ args.add( opt );
+ }
+ else
  {
- opt = "-" + opt;
+ if ( !opt.startsWith( "-" ) )
+ {
+ opt = "-" + opt;
+ }
+ args.add( opt );
+ args.add( optionValue );
  }
- args.add( opt );
- args.add( optionValue );
  }
  }
  return result;