src/main/java/org/apache/maven/plugin/compiler/CompilerMojo.java - maven-compiler-plugin - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.maven.plugin.compiler;

 import javax.lang.model.SourceVersion;
 import javax.tools.DiagnosticListener;
 import javax.tools.JavaFileObject;
 import javax.tools.OptionChecker;

 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.module.ModuleDescriptor;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.stream.Stream;

 import org.apache.maven.api.JavaPathType;
 import org.apache.maven.api.PathScope;
 import org.apache.maven.api.PathType;
 import org.apache.maven.api.ProducedArtifact;
 import org.apache.maven.api.SourceRoot;
 import org.apache.maven.api.Type;
 import org.apache.maven.api.annotations.Nonnull;
 import org.apache.maven.api.annotations.Nullable;
 import org.apache.maven.api.plugin.MojoException;
 import org.apache.maven.api.plugin.annotations.Mojo;
 import org.apache.maven.api.plugin.annotations.Parameter;

 import static org.apache.maven.plugin.compiler.SourceDirectory.CLASS_FILE_SUFFIX;
 import static org.apache.maven.plugin.compiler.SourceDirectory.JAVA_FILE_SUFFIX;
 import static org.apache.maven.plugin.compiler.SourceDirectory.MODULE_INFO;

 /**
  * Compiles application sources.
  * Each instance shall be used only once, then discarded.
  *
  * @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
  * @author Martin Desruisseaux
  * @see <a href="https://docs.oracle.com/en/java/javase/17/docs/specs/man/javac.html">javac Command</a>
  * @since 2.0
  */
 @Mojo(name = "compile", defaultPhase = "compile")
 public class CompilerMojo extends AbstractCompilerMojo {
     /**
      * Set this to {@code true} to bypass compilation of main sources.
      * Its use is not recommended, but quite convenient on occasion.
      */
     @Parameter(property = "maven.main.skip")
     protected boolean skipMain;

     /**
      * Specify where to place generated source files created by annotation processing.
      *
      * @since 2.2
      */
     @Parameter(defaultValue = "${project.build.directory}/generated-sources/annotations")
     protected Path generatedSourcesDirectory;

     /**
      * A set of inclusion filters for the compiler.
      */
     @Parameter
     protected Set<String> includes;

     /**
      * A set of exclusion filters for the compiler.
      */
     @Parameter
     protected Set<String> excludes;

     /**
      * A set of exclusion filters for the incremental calculation.
      * Updated source files, if excluded by this filter, will not cause the project to be rebuilt.
      *
      * <h4>Limitation</h4>
      * In the current implementation, those exclusion filters are applied for added or removed files,
      * but not yet for removed files.
      *
      * @since 3.11
      */
     @Parameter
     protected Set<String> incrementalExcludes;

     /**
      * The directory for compiled classes.
      *
      * @see #getOutputDirectory()
      */
     @Parameter(defaultValue = "${project.build.outputDirectory}", required = true, readonly = true)
     protected Path outputDirectory;

     /**
      * Projects main artifact.
      */
     @Parameter(defaultValue = "${project.mainArtifact}", readonly = true, required = true)
     protected ProducedArtifact projectArtifact;

     /**
      * When set to {@code true}, the classes will be placed in {@code META-INF/versions/${release}}.
      * <p>
      * <strong>Note:</strong> A jar is only a multi-release jar if {@code META-INF/MANIFEST.MF} contains
      * {@code Multi-Release: true}. You need to set this by configuring the <a href=
      * "https://maven.apache.org/plugins/maven-jar-plugin/examples/manifest-customization.html">maven-jar-plugin</a>.
      * This implies that you cannot test a multi-release jar using the {@link #outputDirectory}.
      * </p>
      *
      * @since 3.7.1
      *
      * @deprecated Replaced by specifying the {@code <targetVersion>} value inside a {@code <source>} element.
      */
     @Parameter
     @Deprecated(since = "4.0.0")
     protected boolean multiReleaseOutput;

     /**
      * The file where to dump the command-line when debug is activated or when the compilation failed.
      * For example, if the value is {@code "javac"}, then the Java compiler can be launched from the
      * command-line by typing {@code javac @target/javac.args}.
      * The debug file will contain the compiler options together with the list of source files to compile.
      *
      * <p>By default, this debug file is written only if the compilation of main code failed.
      * The writing of the debug files can be forced by setting the {@link #verbose} flag to {@code true}
      * or by specifying the {@code --verbose} option to Maven on the command-line.</p>
      *
      * @since 3.10.0
      */
     @Parameter(defaultValue = "javac.args")
     protected String debugFileName;

     /**
      * Target directory that have been temporarily created as symbolic link before compilation.
      * This is used as a workaround for the fact that, when compiling a modular project with
      * all the module-related compiler options, the classes are written in a directory with
      * the module name. It does not fit in the {@code META-INF/versions/<release>} pattern.
      * Temporary symbolic link is a workaround for this problem.
      *
      * <h4>Example</h4>
      * When compiling the {@code my.app} module for Java 17, the desired output directory is:
      *
      * <blockquote>{@code target/classes/META-INF/versions/17}</blockquote>
      *
      * But {@code javac}, when used with the {@code --module-source-path} option,
      * will write the classes in the following directory:
      *
      * <blockquote>{@code target/classes/META-INF/versions/17/my.app}</blockquote>
      *
      * We workaround this problem with a symbolic link which redirects {@code 17/my.app} to {@code 17}.
      * We need to do this only when compiling multi-release project in the old deprecated way.
      * When using the recommended {@code <sources>} approach, the plugins are designed to work
      * with the directory layout produced by {@code javac} instead of fighting against it.
      *
      * @deprecated For compatibility with the previous way to build multi-release JAR file.
      *             May be removed after we drop support of the old way to do multi-release.
      */
     @Deprecated(since = "4.0.0")
     private ModuleDirectoryRemover directoryLevelToRemove;

     /**
      * 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.
      */
     @Override
     public void execute() throws MojoException {
         if (skipMain) {
             logger.info("Not compiling main sources");
             return;
         }
         try {
             super.execute();
         } finally {
             try (ModuleDirectoryRemover r = directoryLevelToRemove) {
                 // Implicit call to directoryLevelToRemove.close().
             } catch (IOException e) {
                 throw new CompilationFailureException("I/O error while organizing multi-release classes.", e);
             }
         }
         @SuppressWarnings("LocalVariableHidesMemberVariable")
         Path outputDirectory = getOutputDirectory();
         if (Files.isDirectory(outputDirectory) && projectArtifact != null) {
             artifactManager.setPath(projectArtifact, outputDirectory);
         }
     }

     /**
      * 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")
     public Options parseParameters(final OptionChecker compiler) {
         Options configuration = super.parseParameters(compiler);
         configuration.addUnchecked(compilerArgs);
         configuration.addUnchecked(compilerArgument);
         return configuration;
     }

     /**
      * {@return the path where to place generated source files created by annotation processing on the main classes}
      */
     @Nullable
     @Override
     protected Path getGeneratedSourcesDirectory() {
         return generatedSourcesDirectory;
     }

     /**
      * {@return the inclusion filters for the compiler, or an empty set for all Java source files}
      */
     @Override
     protected Set<String> getIncludes() {
         return (includes != null) ? includes : Set.of();
     }

     /**
      * {@return the exclusion filters for the compiler, or an empty set if none}
      */
     @Override
     protected Set<String> getExcludes() {
         return (excludes != null) ? excludes : Set.of();
     }

     /**
      * {@return the exclusion filters for the incremental calculation, or an empty set if none}
      */
     @Override
     protected Set<String> getIncrementalExcludes() {
         return (incrementalExcludes != null) ? incrementalExcludes : Set.of();
     }

     /**
      * {@return the destination directory for main class files}
      * If {@link #multiReleaseOutput} is true <em>(deprecated)</em>,
      * the output will be in a {@code META-INF/versions} subdirectory.
      */
     @Nonnull
     @Override
     protected Path getOutputDirectory() {
         if (SUPPORT_LEGACY && multiReleaseOutput && release != null) {
             return DirectoryHierarchy.PACKAGE
                     .outputDirectoryForReleases(outputDirectory)
                     .resolve(release);
         }
         return outputDirectory;
     }

     /**
      * {@return the file where to dump the command-line when debug is activated or when the compilation failed}
      *
      * @see #debugFileName
      */
     @Nullable
     @Override
     protected String getDebugFileName() {
         return debugFileName;
     }

     /**
      * Creates a new task for compiling the main classes.
      *
      * @param listener where to send compilation warnings, or {@code null} for the Maven logger
      * @throws MojoException if this method identifies an invalid parameter in this <abbr>MOJO</abbr>
      * @return the task to execute for compiling the main code using the configuration in this <abbr>MOJO</abbr>
      * @throws IOException if an error occurred while creating the output directory or scanning the source directories
      */
     @Override
     public ToolExecutor createExecutor(DiagnosticListener<? super JavaFileObject> listener) throws IOException {
         ToolExecutor executor = super.createExecutor(listener);
         if (SUPPORT_LEGACY && multiReleaseOutput) {
             addImplicitDependencies(executor);
         }
         return executor;
     }

     /**
      * {@return whether the project has at least one module-info file}
      * If no such file is found in the code to be compiled by this <abbr>MOJO</abbr> execution,
      * then this method searches in the multi-release codes compiled by previous executions.
      *
      * @param roots root directories of the sources to compile
      * @throws IOException if this method needed to read a module descriptor and failed
      *
      * @deprecated For compatibility with the previous way to build multi-release JAR file.
      *             May be removed after we drop support of the old way to do multi-release.
      */
     @Override
     @Deprecated(since = "4.0.0")
     final boolean hasModuleDeclaration(final List<SourceDirectory> roots) throws IOException {
         boolean hasModuleDeclaration = super.hasModuleDeclaration(roots);
         if (SUPPORT_LEGACY && !hasModuleDeclaration && multiReleaseOutput) {
             String type = project.getPackaging().type().id();
             if (!Type.CLASSPATH_JAR.equals(type)) {
                 for (Path p : getOutputDirectoryPerVersion().values()) {
                     p = p.resolve(SourceDirectory.MODULE_INFO + SourceDirectory.CLASS_FILE_SUFFIX);
                     if (Files.exists(p)) {
                         return true;
                     }
                 }
             }
         }
         return hasModuleDeclaration;
     }

     /**
      * {@return the output directory of each target Java version}
      * By convention, {@link SourceVersion#RELEASE_0} stands for the base version.
      *
      * @throws IOException if this method needs to walk through directories and that operation failed
      *
      * @deprecated For compatibility with the previous way to build multi-release JAR file.
      *             May be removed after we drop support of the old way to do multi-release.
      */
     @Deprecated(since = "4.0.0")
     private TreeMap<SourceVersion, Path> getOutputDirectoryPerVersion() throws IOException {
         final Path root = DirectoryHierarchy.PACKAGE.outputDirectoryForReleases(outputDirectory);
         if (Files.notExists(root)) {
             return null;
         }
         final var paths = new TreeMap<SourceVersion, Path>();
         Files.walk(root, 1).forEach((path) -> {
             SourceVersion version;
             if (path.equals(root)) {
                 path = outputDirectory;
                 version = SourceVersion.RELEASE_0;
             } else {
                 try {
                     version = SourceVersion.valueOf("RELEASE_" + path.getFileName());
                 } catch (IllegalArgumentException e) {
                     throw new CompilationFailureException("Invalid version number for " + path, e);
                 }
             }
             if (paths.put(version, path) != null) {
                 throw new CompilationFailureException("Duplicated version number for " + path);
             }
         });
         return paths;
     }

     /**
      * Adds the compilation outputs of previous Java releases to the class-path of module-path.
      * This method should be invoked only when compiling a multi-release <abbr>JAR</abbr> in the
      * old deprecated way.
      *
      * <p>The {@code executor} argument may be {@code null} if the caller is only interested in the
      * module name, with no executor to modify. The module name found by this method is specific to
      * the way that projects are organized when {@link #multiReleaseOutput} is {@code true}.</p>
      *
      * @param  executor  the executor where to add implicit dependencies, or {@code null} if none
      * @return the module name, or {@code null} if none
      * @throws IOException if this method needs to walk through directories and that operation failed
      *
      * @deprecated For compatibility with the previous way to build multi-release JAR file.
      *             May be removed after we drop support of the old way to do multi-release.
      */
     @Deprecated(since = "4.0.0")
     private String addImplicitDependencies(final ToolExecutor executor) throws IOException {
         final TreeMap<SourceVersion, Path> paths = getOutputDirectoryPerVersion();
         /*
          * Search for the module name. If many module-info classes are found,
          * the most basic one (with lowest Java release number) is selected.
          */
         String moduleName = null;
         for (Path path : paths.values()) {
             path = path.resolve(MODULE_INFO + CLASS_FILE_SUFFIX);
             if (Files.exists(path)) {
                 try (InputStream in = Files.newInputStream(path)) {
                     moduleName = ModuleDescriptor.read(in).name();
                 }
                 break;
             }
         }
         /*
          * If no module name was found in the classes compiled for previous Java releases,
          * search in the source files for the Java release of the current compilation unit.
          */
         if (moduleName == null) {
             final Stream<Path> sourceDirectories;
             if (executor != null) {
                 sourceDirectories = executor.sourceDirectories.stream().map(dir -> dir.root);
             } else if (isAbsent(compileSourceRoots)) {
                 sourceDirectories = getSourceRoots(compileScope.projectScope()).map(SourceRoot::directory);
             } else {
                 sourceDirectories = compileSourceRoots.stream().map(Path::of);
             }
             for (Path root : sourceDirectories.toList()) {
                 moduleName = parseModuleInfoName(root.resolve(MODULE_INFO + JAVA_FILE_SUFFIX));
                 if (moduleName != null) {
                     break;
                 }
             }
         }
         if (executor != null) {
             /*
              * Add previous versions as dependencies on the class-path or module-path, depending on whether
              * the project is modular. Each path should be on either the class-path or module-path, but not
              * both. If a path for a modular project seems needed on the class-path, it may be a sign that
              * other options are not used correctly (e.g., `--source-path` versus `--module-source-path`).
              */
             PathType type = JavaPathType.CLASSES;
             if (moduleName != null) {
                 type = JavaPathType.patchModule(moduleName);
                 directoryLevelToRemove = ModuleDirectoryRemover.create(executor.outputDirectory, moduleName);
             }
             if (!paths.isEmpty()) {
                 executor.dependencies(type).addAll(paths.descendingMap().values());
             }
         }
         return moduleName;
     }

     /**
      * {@return the module name in a previous execution of the compiler plugin, or {@code null} if none}
      *
      * @deprecated For compatibility with the previous way to build multi-release JAR file.
      *             May be removed after we drop support of the old way to do multi-release.
      */
     @Override
     @Deprecated(since = "4.0.0")
     final String moduleOfPreviousExecution() throws IOException {
         if (SUPPORT_LEGACY && multiReleaseOutput) {
             return addImplicitDependencies(null);
         }
         return super.moduleOfPreviousExecution();
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.maven.plugin.compiler;

	import javax.lang.model.SourceVersion;
	import javax.tools.DiagnosticListener;
	import javax.tools.JavaFileObject;
	import javax.tools.OptionChecker;

	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.module.ModuleDescriptor;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.util.List;
	import java.util.Set;
	import java.util.TreeMap;
	import java.util.stream.Stream;

	import org.apache.maven.api.JavaPathType;
	import org.apache.maven.api.PathScope;
	import org.apache.maven.api.PathType;
	import org.apache.maven.api.ProducedArtifact;
	import org.apache.maven.api.SourceRoot;
	import org.apache.maven.api.Type;
	import org.apache.maven.api.annotations.Nonnull;
	import org.apache.maven.api.annotations.Nullable;
	import org.apache.maven.api.plugin.MojoException;
	import org.apache.maven.api.plugin.annotations.Mojo;
	import org.apache.maven.api.plugin.annotations.Parameter;

	import static org.apache.maven.plugin.compiler.SourceDirectory.CLASS_FILE_SUFFIX;
	import static org.apache.maven.plugin.compiler.SourceDirectory.JAVA_FILE_SUFFIX;
	import static org.apache.maven.plugin.compiler.SourceDirectory.MODULE_INFO;

	/**
	* Compiles application sources.
	* Each instance shall be used only once, then discarded.
	*
	* @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
	* @author Martin Desruisseaux
	* @see <a href="https://docs.oracle.com/en/java/javase/17/docs/specs/man/javac.html">javac Command</a>
	* @since 2.0
	*/
	@Mojo(name = "compile", defaultPhase = "compile")
	public class CompilerMojo extends AbstractCompilerMojo {
	/**
	* Set this to {@code true} to bypass compilation of main sources.
	* Its use is not recommended, but quite convenient on occasion.
	*/
	@Parameter(property = "maven.main.skip")
	protected boolean skipMain;

	/**
	* Specify where to place generated source files created by annotation processing.
	*
	* @since 2.2
	*/
	@Parameter(defaultValue = "${project.build.directory}/generated-sources/annotations")
	protected Path generatedSourcesDirectory;

	/**
	* A set of inclusion filters for the compiler.
	*/
	@Parameter
	protected Set<String> includes;

	/**
	* A set of exclusion filters for the compiler.
	*/
	@Parameter
	protected Set<String> excludes;

	/**
	* A set of exclusion filters for the incremental calculation.
	* Updated source files, if excluded by this filter, will not cause the project to be rebuilt.
	*
	* <h4>Limitation</h4>
	* In the current implementation, those exclusion filters are applied for added or removed files,
	* but not yet for removed files.
	*
	* @since 3.11
	*/
	@Parameter
	protected Set<String> incrementalExcludes;

	/**
	* The directory for compiled classes.
	*
	* @see #getOutputDirectory()
	*/
	@Parameter(defaultValue = "${project.build.outputDirectory}", required = true, readonly = true)
	protected Path outputDirectory;

	/**
	* Projects main artifact.
	*/
	@Parameter(defaultValue = "${project.mainArtifact}", readonly = true, required = true)
	protected ProducedArtifact projectArtifact;

	/**
	* When set to {@code true}, the classes will be placed in {@code META-INF/versions/${release}}.
	* <p>
	* <strong>Note:</strong> A jar is only a multi-release jar if {@code META-INF/MANIFEST.MF} contains
	* {@code Multi-Release: true}. You need to set this by configuring the <a href=
	* "https://maven.apache.org/plugins/maven-jar-plugin/examples/manifest-customization.html">maven-jar-plugin</a>.
	* This implies that you cannot test a multi-release jar using the {@link #outputDirectory}.
	* </p>
	*
	* @since 3.7.1
	*
	* @deprecated Replaced by specifying the {@code <targetVersion>} value inside a {@code <source>} element.
	*/
	@Parameter
	@Deprecated(since = "4.0.0")
	protected boolean multiReleaseOutput;

	/**
	* The file where to dump the command-line when debug is activated or when the compilation failed.
	* For example, if the value is {@code "javac"}, then the Java compiler can be launched from the
	* command-line by typing {@code javac @target/javac.args}.
	* The debug file will contain the compiler options together with the list of source files to compile.
	*
	* <p>By default, this debug file is written only if the compilation of main code failed.
	* The writing of the debug files can be forced by setting the {@link #verbose} flag to {@code true}
	* or by specifying the {@code --verbose} option to Maven on the command-line.</p>
	*
	* @since 3.10.0
	*/
	@Parameter(defaultValue = "javac.args")
	protected String debugFileName;

	/**
	* Target directory that have been temporarily created as symbolic link before compilation.
	* This is used as a workaround for the fact that, when compiling a modular project with
	* all the module-related compiler options, the classes are written in a directory with
	* the module name. It does not fit in the {@code META-INF/versions/<release>} pattern.
	* Temporary symbolic link is a workaround for this problem.
	*
	* <h4>Example</h4>
	* When compiling the {@code my.app} module for Java 17, the desired output directory is:
	*
	* <blockquote>{@code target/classes/META-INF/versions/17}</blockquote>
	*
	* But {@code javac}, when used with the {@code --module-source-path} option,
	* will write the classes in the following directory:
	*
	* <blockquote>{@code target/classes/META-INF/versions/17/my.app}</blockquote>
	*
	* We workaround this problem with a symbolic link which redirects {@code 17/my.app} to {@code 17}.
	* We need to do this only when compiling multi-release project in the old deprecated way.
	* When using the recommended {@code <sources>} approach, the plugins are designed to work
	* with the directory layout produced by {@code javac} instead of fighting against it.
	*
	* @deprecated For compatibility with the previous way to build multi-release JAR file.
	* May be removed after we drop support of the old way to do multi-release.
	*/
	@Deprecated(since = "4.0.0")
	private ModuleDirectoryRemover directoryLevelToRemove;

	/**
	* 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.
	*/
	@Override
	public void execute() throws MojoException {
	if (skipMain) {
	logger.info("Not compiling main sources");
	return;
	}
	try {
	super.execute();
	} finally {
	try (ModuleDirectoryRemover r = directoryLevelToRemove) {
	// Implicit call to directoryLevelToRemove.close().
	} catch (IOException e) {
	throw new CompilationFailureException("I/O error while organizing multi-release classes.", e);
	}
	}
	@SuppressWarnings("LocalVariableHidesMemberVariable")
	Path outputDirectory = getOutputDirectory();
	if (Files.isDirectory(outputDirectory) && projectArtifact != null) {
	artifactManager.setPath(projectArtifact, outputDirectory);
	}
	}

	/**
	* 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")
	public Options parseParameters(final OptionChecker compiler) {
	Options configuration = super.parseParameters(compiler);
	configuration.addUnchecked(compilerArgs);
	configuration.addUnchecked(compilerArgument);
	return configuration;
	}

	/**
	* {@return the path where to place generated source files created by annotation processing on the main classes}
	*/
	@Nullable
	@Override
	protected Path getGeneratedSourcesDirectory() {
	return generatedSourcesDirectory;
	}

	/**
	* {@return the inclusion filters for the compiler, or an empty set for all Java source files}
	*/
	@Override
	protected Set<String> getIncludes() {
	return (includes != null) ? includes : Set.of();
	}

	/**
	* {@return the exclusion filters for the compiler, or an empty set if none}
	*/
	@Override
	protected Set<String> getExcludes() {
	return (excludes != null) ? excludes : Set.of();
	}

	/**
	* {@return the exclusion filters for the incremental calculation, or an empty set if none}
	*/
	@Override
	protected Set<String> getIncrementalExcludes() {
	return (incrementalExcludes != null) ? incrementalExcludes : Set.of();
	}

	/**
	* {@return the destination directory for main class files}
	* If {@link #multiReleaseOutput} is true <em>(deprecated)</em>,
	* the output will be in a {@code META-INF/versions} subdirectory.
	*/
	@Nonnull
	@Override
	protected Path getOutputDirectory() {
	if (SUPPORT_LEGACY && multiReleaseOutput && release != null) {
	return DirectoryHierarchy.PACKAGE
	.outputDirectoryForReleases(outputDirectory)
	.resolve(release);
	}
	return outputDirectory;
	}

	/**
	* {@return the file where to dump the command-line when debug is activated or when the compilation failed}
	*
	* @see #debugFileName
	*/
	@Nullable
	@Override
	protected String getDebugFileName() {
	return debugFileName;
	}

	/**
	* Creates a new task for compiling the main classes.
	*
	* @param listener where to send compilation warnings, or {@code null} for the Maven logger
	* @throws MojoException if this method identifies an invalid parameter in this <abbr>MOJO</abbr>
	* @return the task to execute for compiling the main code using the configuration in this <abbr>MOJO</abbr>
	* @throws IOException if an error occurred while creating the output directory or scanning the source directories
	*/
	@Override
	public ToolExecutor createExecutor(DiagnosticListener<? super JavaFileObject> listener) throws IOException {
	ToolExecutor executor = super.createExecutor(listener);
	if (SUPPORT_LEGACY && multiReleaseOutput) {
	addImplicitDependencies(executor);
	}
	return executor;
	}

	/**
	* {@return whether the project has at least one module-info file}
	* If no such file is found in the code to be compiled by this <abbr>MOJO</abbr> execution,
	* then this method searches in the multi-release codes compiled by previous executions.
	*
	* @param roots root directories of the sources to compile
	* @throws IOException if this method needed to read a module descriptor and failed
	*
	* @deprecated For compatibility with the previous way to build multi-release JAR file.
	* May be removed after we drop support of the old way to do multi-release.
	*/
	@Override
	@Deprecated(since = "4.0.0")
	final boolean hasModuleDeclaration(final List<SourceDirectory> roots) throws IOException {
	boolean hasModuleDeclaration = super.hasModuleDeclaration(roots);
	if (SUPPORT_LEGACY && !hasModuleDeclaration && multiReleaseOutput) {
	String type = project.getPackaging().type().id();
	if (!Type.CLASSPATH_JAR.equals(type)) {
	for (Path p : getOutputDirectoryPerVersion().values()) {
	p = p.resolve(SourceDirectory.MODULE_INFO + SourceDirectory.CLASS_FILE_SUFFIX);
	if (Files.exists(p)) {
	return true;
	}
	}
	}
	}
	return hasModuleDeclaration;
	}

	/**
	* {@return the output directory of each target Java version}
	* By convention, {@link SourceVersion#RELEASE_0} stands for the base version.
	*
	* @throws IOException if this method needs to walk through directories and that operation failed
	*
	* @deprecated For compatibility with the previous way to build multi-release JAR file.
	* May be removed after we drop support of the old way to do multi-release.
	*/
	@Deprecated(since = "4.0.0")
	private TreeMap<SourceVersion, Path> getOutputDirectoryPerVersion() throws IOException {
	final Path root = DirectoryHierarchy.PACKAGE.outputDirectoryForReleases(outputDirectory);
	if (Files.notExists(root)) {
	return null;
	}
	final var paths = new TreeMap<SourceVersion, Path>();
	Files.walk(root, 1).forEach((path) -> {
	SourceVersion version;
	if (path.equals(root)) {
	path = outputDirectory;
	version = SourceVersion.RELEASE_0;
	} else {
	try {
	version = SourceVersion.valueOf("RELEASE_" + path.getFileName());
	} catch (IllegalArgumentException e) {
	throw new CompilationFailureException("Invalid version number for " + path, e);
	}
	}
	if (paths.put(version, path) != null) {
	throw new CompilationFailureException("Duplicated version number for " + path);
	}
	});
	return paths;
	}

	/**
	* Adds the compilation outputs of previous Java releases to the class-path of module-path.
	* This method should be invoked only when compiling a multi-release <abbr>JAR</abbr> in the
	* old deprecated way.
	*
	* <p>The {@code executor} argument may be {@code null} if the caller is only interested in the
	* module name, with no executor to modify. The module name found by this method is specific to
	* the way that projects are organized when {@link #multiReleaseOutput} is {@code true}.</p>
	*
	* @param executor the executor where to add implicit dependencies, or {@code null} if none
	* @return the module name, or {@code null} if none
	* @throws IOException if this method needs to walk through directories and that operation failed
	*
	* @deprecated For compatibility with the previous way to build multi-release JAR file.
	* May be removed after we drop support of the old way to do multi-release.
	*/
	@Deprecated(since = "4.0.0")
	private String addImplicitDependencies(final ToolExecutor executor) throws IOException {
	final TreeMap<SourceVersion, Path> paths = getOutputDirectoryPerVersion();
	/*
	* Search for the module name. If many module-info classes are found,
	* the most basic one (with lowest Java release number) is selected.
	*/
	String moduleName = null;
	for (Path path : paths.values()) {
	path = path.resolve(MODULE_INFO + CLASS_FILE_SUFFIX);
	if (Files.exists(path)) {
	try (InputStream in = Files.newInputStream(path)) {
	moduleName = ModuleDescriptor.read(in).name();
	}
	break;
	}
	}
	/*
	* If no module name was found in the classes compiled for previous Java releases,
	* search in the source files for the Java release of the current compilation unit.
	*/
	if (moduleName == null) {
	final Stream<Path> sourceDirectories;
	if (executor != null) {
	sourceDirectories = executor.sourceDirectories.stream().map(dir -> dir.root);
	} else if (isAbsent(compileSourceRoots)) {
	sourceDirectories = getSourceRoots(compileScope.projectScope()).map(SourceRoot::directory);
	} else {
	sourceDirectories = compileSourceRoots.stream().map(Path::of);
	}
	for (Path root : sourceDirectories.toList()) {
	moduleName = parseModuleInfoName(root.resolve(MODULE_INFO + JAVA_FILE_SUFFIX));
	if (moduleName != null) {
	break;
	}
	}
	}
	if (executor != null) {
	/*
	* Add previous versions as dependencies on the class-path or module-path, depending on whether
	* the project is modular. Each path should be on either the class-path or module-path, but not
	* both. If a path for a modular project seems needed on the class-path, it may be a sign that
	* other options are not used correctly (e.g., `--source-path` versus `--module-source-path`).
	*/
	PathType type = JavaPathType.CLASSES;
	if (moduleName != null) {
	type = JavaPathType.patchModule(moduleName);
	directoryLevelToRemove = ModuleDirectoryRemover.create(executor.outputDirectory, moduleName);
	}
	if (!paths.isEmpty()) {
	executor.dependencies(type).addAll(paths.descendingMap().values());
	}
	}
	return moduleName;
	}

	/**
	* {@return the module name in a previous execution of the compiler plugin, or {@code null} if none}
	*
	* @deprecated For compatibility with the previous way to build multi-release JAR file.
	* May be removed after we drop support of the old way to do multi-release.
	*/
	@Override
	@Deprecated(since = "4.0.0")
	final String moduleOfPreviousExecution() throws IOException {
	if (SUPPORT_LEGACY && multiReleaseOutput) {
	return addImplicitDependencies(null);
	}
	return super.moduleOfPreviousExecution();
	}
	}