Refactor AbstractCompilerMojo by moving part of the compile method body in a separated class.

The intend is to reduce the complexity by splitting one big method into smaller methods.
It may also help external applications (e.g. IDE) to use `ToolExecutor` in their environment.

Author: desruisseaux

src/main/java/org/apache/maven/plugin/compiler/AbstractCompilerMojo.java

@@ -98,6 +98,8 @@ public class CompilerMojo extends AbstractCompilerMojo {
 
     /**
      * The directory for compiled classes.
+     *
+     * @see #getOutputDirectory()
      */
     @Parameter(defaultValue = "${project.build.outputDirectory}", required = true, readonly = true)
     protected Path outputDirectory;
@@ -137,14 +139,16 @@ public class CompilerMojo extends AbstractCompilerMojo {
     protected String debugFileName;
 
     /**
-     * Creates a new compiler MOJO.
+     * Creates a new compiler <abbr>MOJO</abbr> for the main code.
      */
     public CompilerMojo() {
         super(PathScope.MAIN_COMPILE);
     }
 
     /**
      * Runs the Java compiler on the main source code.
+     * If {@link #skipMain} is {@code true}, then this method logs a message and does nothing else.
+     * Otherwise, this method executes the steps described in the method of the parent class.
      *
      * @throws MojoException if the compiler cannot be run.
      */
@@ -163,18 +167,18 @@ public void execute() throws MojoException {
     }
 
     /**
-     * Parses the parameters declared in the MOJO.
+     * Parses the parameters declared in the <abbr>MOJO</abbr>.
      *
      * @param  compiler  the tools to use for verifying the validity of options
      * @return the options after validation
      */
     @Override
     @SuppressWarnings("deprecation")
-    protected Options acceptParameters(final OptionChecker compiler) {
-        Options compilerConfiguration = super.acceptParameters(compiler);
-        compilerConfiguration.addUnchecked(compilerArgs);
-        compilerConfiguration.addUnchecked(compilerArgument);
-        return compilerConfiguration;
+    public Options parseParameters(final OptionChecker compiler) {
+        Options configuration = super.parseParameters(compiler);
+        configuration.addUnchecked(compilerArgs);
+        configuration.addUnchecked(compilerArgument);
+        return configuration;
     }
 
     /**
@@ -245,7 +249,7 @@ protected String getDebugFileName() {
      */
     @Override
     @Deprecated(since = "4.0.0")
-    void addImplicitDependencies(
+    final void addImplicitDependencies(
             List<SourceDirectory> sourceDirectories, Map<PathType, List<Path>> addTo, boolean hasModuleDeclaration)
             throws IOException {
         if (SUPPORT_LEGACY && multiReleaseOutput) {

src/main/java/org/apache/maven/plugin/compiler/CompilerMojo.java

@@ -136,18 +136,17 @@ final class PathFilter extends SimpleFileVisitor<Path> implements Predicate<Path
     /**
      * Creates a new filter.
      *
-     * @param includes inclusion filters for the compiler, or empty for all source files
-     * @param excludes exclusion filters for the compiler
-     * @param incrementalExcludes exclusion filters for incremental build calculation
+     * @param mojo the <abbr>MOJO</abbr> from which to take the includes/excludes configuration
      */
-    PathFilter(Collection<String> includes, Collection<String> excludes, Collection<String> incrementalExcludes) {
-        useDefaultInclude = includes.isEmpty();
+    PathFilter(AbstractCompilerMojo mojo) {
+        Collection<String> specified = mojo.getIncludes();
+        useDefaultInclude = specified.isEmpty();
         if (useDefaultInclude) {
-            includes = List.of("**"); // Place-holder replaced by "**/*.java" in `test(…)`.
+            specified = List.of("**"); // Place-holder replaced by "**/*.java" in `test(…)`.
         }
-        this.includes = includes.toArray(String[]::new);
-        this.excludes = excludes.toArray(String[]::new);
-        this.incrementalExcludes = incrementalExcludes.toArray(String[]::new);
+        includes = specified.toArray(String[]::new);
+        excludes = mojo.getExcludes().toArray(String[]::new);
+        incrementalExcludes = mojo.getIncrementalExcludes().toArray(String[]::new);
     }
 
     /**

src/main/java/org/apache/maven/plugin/compiler/PathFilter.java

@@ -41,8 +41,7 @@
  */
 final class SourcesForRelease implements Closeable {
     /**
-     * The release for this set of sources. For this class, the
-     * {@link SourceVersion#RELEASE_0} value means "no version".
+     * The release for this set of sources, or {@code null} if the user did not specified a release.
      *
      * @see SourceDirectory#release
      */
@@ -80,12 +79,12 @@ final class SourcesForRelease implements Closeable {
     /**
      * Creates an initially empty instance for the given Java release.
      *
-     * @param release the release for this set of sources, or {@link SourceVersion#RELEASE_0} for no version.
+     * @param release the release for this set of sources, or {@code null} if the user did not specified a release
      */
     private SourcesForRelease(SourceVersion release) {
         this.release = release;
-        roots = new LinkedHashMap<>();
         files = new ArrayList<>(256);
+        roots = new LinkedHashMap<>();
         moduleInfos = new LinkedHashMap<>();
     }
 
@@ -103,12 +102,25 @@ private void add(SourceFile source) {
             if (moduleName == null) {
                 moduleName = "";
             }
-            roots.computeIfAbsent(moduleName, (key) -> new LinkedHashSet<>()).add(directory.root);
+            add(roots, moduleName, directory.root);
             directory.getModuleInfo().ifPresent((path) -> moduleInfos.put(directory, null));
         }
         files.add(source.file);
     }
 
+    /**
+     * Adds the given directory in the given map.
+     *
+     * @param target the map where to add the specified directory
+     * @param moduleName name of the module, or an empty string if none
+     * @param directory the directory to add, or {@code null} if none
+     */
+    private static void add(Map<String, Set<Path>> target, String moduleName, Path directory) {
+        if (directory != null) {
+            target.computeIfAbsent(moduleName, (key) -> new LinkedHashSet<>()).add(directory);
+        }
+    }
+
     /**
      * Groups all sources files first by Java release versions, then by module names.
      * The elements in the returned collection are sorted in the order of {@link SourceVersion}
@@ -117,14 +129,14 @@ private void add(SourceFile source) {
      * @param sources the sources to group.
      * @return the given sources grouped by Java release versions and module names.
      */
-    public static Collection<SourcesForRelease> groupByReleaseAndModule(List<SourceFile> sources) {
+    static Collection<SourcesForRelease> groupByReleaseAndModule(List<SourceFile> sources) {
         var result = new EnumMap<SourceVersion, SourcesForRelease>(SourceVersion.class);
         for (SourceFile source : sources) {
-            SourceVersion release = source.directory.release;
-            if (release == null) {
-                release = SourceVersion.RELEASE_0; // No release sub-directory for the compiled classes.
-            }
-            result.computeIfAbsent(release, SourcesForRelease::new).add(source);
+            final SourceVersion release = source.directory.release;
+            result.computeIfAbsent(
+                            (release != null) ? release : SourceVersion.latest(),
+                            (key) -> new SourcesForRelease(release))
+                    .add(source);
         }
         return result.values();
     }
@@ -190,6 +202,7 @@ public void close() throws IOException {
      */
     @Override
     public String toString() {
-        return getClass().getSimpleName() + '[' + release + ": " + files.size() + " files]";
+        return getClass().getSimpleName() + '[' + (release != null ? release : "default") + ": " + files.size()
+                + " files]";
     }
 }