You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by de...@apache.org on 2025/10/14 18:08:46 UTC
(maven-compiler-plugin) 04/04: Do not create empty "generated-sources" when there is no annotation processor to run. This commit takes in account the fact that `-proc:full` was the default before Java 23.
This is an automated email from the ASF dual-hosted git repository.
desruisseaux pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-compiler-plugin.git
commit d958a62fc0ae2190b5fbcce3d479032eea5638b9
Author: Martin Desruisseaux <ma...@geomatys.com>
AuthorDate: Sun Sep 21 16:37:18 2025 +0200
Do not create empty "generated-sources" when there is no annotation processor to run.
This commit takes in account the fact that `-proc:full` was the default before Java 23.
---
.../plugin/compiler/AbstractCompilerMojo.java | 58 +++++++++++++++-------
1 file changed, 39 insertions(+), 19 deletions(-)
diff --git a/src/main/java/org/apache/maven/plugin/compiler/AbstractCompilerMojo.java b/src/main/java/org/apache/maven/plugin/compiler/AbstractCompilerMojo.java
index 3fad7fe..c65674c 100644
--- a/src/main/java/org/apache/maven/plugin/compiler/AbstractCompilerMojo.java
+++ b/src/main/java/org/apache/maven/plugin/compiler/AbstractCompilerMojo.java
@@ -24,7 +24,6 @@ import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.OptionChecker;
-import javax.tools.Tool;
import javax.tools.ToolProvider;
import java.io.BufferedReader;
@@ -213,6 +212,13 @@ public abstract class AbstractCompilerMojo implements Mojo {
*/
private boolean targetOrReleaseSet;
+ /**
+ * The highest version supported by the compiler, or {@code null} if not yet determined.
+ *
+ * @see #isVersionEqualOrNewer(String)
+ */
+ private SourceVersion supportedVersion;
+
/**
* Whether to enable preview language features of the java compiler.
* If {@code true}, then the {@code --enable-preview} option will be added to compiler arguments.
@@ -290,12 +296,16 @@ public abstract class AbstractCompilerMojo implements Mojo {
* </ul>
*
* The default value depends on the JDK used for the build.
- * Prior to Java 22, the default was {@code full}, so annotation processing and compilation were executed without explicit configuration.
+ * Prior to Java 23, the default was {@code full},
+ * so annotation processing and compilation were executed without explicit configuration.
*
* For security reasons, starting with Java 23 no annotation processing is done if neither
- * any {@code -processor}, {@code -processor path} or {@code -processor module} are set, or either {@code only} or {@code full} is set.
+ * any {@code -processor}, {@code -processor path} or {@code -processor module} are set,
+ * or either {@code only} or {@code full} is set.
* So literally the default is {@code none}.
- * It is recommended to always list the annotation processors you want to execute instead of using the {@code proc} configuration, to ensure that only desired processors are executed and not any "hidden" (and maybe malicious).
+ * It is recommended to always list the annotation processors you want to execute
+ * instead of using the {@code proc} configuration,
+ * to ensure that only desired processors are executed and not any "hidden" (and maybe malicious).
*
* @see #annotationProcessors
* @see <a href="https://inside.java/2024/06/18/quality-heads-up/">Inside Java 2024-06-18 Quality Heads up</a>
@@ -662,7 +672,7 @@ public abstract class AbstractCompilerMojo implements Mojo {
IncrementalBuild.Aspect.OPTIONS,
IncrementalBuild.Aspect.DEPENDENCIES,
IncrementalBuild.Aspect.SOURCES);
- if (hasAnnotationProcessor()) {
+ if (hasAnnotationProcessor(false)) {
aspects.add(IncrementalBuild.Aspect.REBUILD_ON_ADD);
aspects.add(IncrementalBuild.Aspect.REBUILD_ON_CHANGE);
}
@@ -1143,6 +1153,11 @@ public abstract class AbstractCompilerMojo implements Mojo {
@Override
public void execute() throws MojoException {
JavaCompiler compiler = compiler();
+ for (SourceVersion version : compiler.getSourceVersions()) {
+ if (supportedVersion == null || version.compareTo(supportedVersion) >= 0) {
+ supportedVersion = version;
+ }
+ }
Options configuration = parseParameters(compiler);
try {
compile(compiler, configuration);
@@ -1404,7 +1419,7 @@ public abstract class AbstractCompilerMojo implements Mojo {
* Note: a previous version used as an heuristic way to detect if Reproducible Build was enabled. This check
* has been removed because Reproducible Build are enabled by default in Maven now.
*/
- if (!isVersionEqualOrNewer(compiler, "RELEASE_22")) {
+ if (!isVersionEqualOrNewer("RELEASE_22")) {
Path moduleDescriptor = executor.outputDirectory.resolve(MODULE_INFO + CLASS_FILE_SUFFIX);
if (Files.isRegularFile(moduleDescriptor)) {
byte[] oridinal = Files.readAllBytes(moduleDescriptor);
@@ -1417,12 +1432,12 @@ public abstract class AbstractCompilerMojo implements Mojo {
}
/**
- * Returns whether the given tool (usually the compiler) supports the given source version or newer versions.
+ * Returns whether the compiler supports the given source version or newer versions.
* The specified source version shall be the name of one of the {@link SourceVersion} enumeration values.
- * Note that a return value of {@code true} does not mean that the tool support that version,
- * as it may be too old. This method is rather for checking whether a tool need to be patched.
+ * Note that a return value of {@code true} does not mean that the compiler supports that exact version,
+ * as it may supports only newer versions.
*/
- private static boolean isVersionEqualOrNewer(Tool tool, String sourceVersion) {
+ private boolean isVersionEqualOrNewer(String sourceVersion) {
final SourceVersion requested;
try {
requested = SourceVersion.valueOf(sourceVersion);
@@ -1430,7 +1445,10 @@ public abstract class AbstractCompilerMojo implements Mojo {
// The current tool is from a JDK older than the one for the requested source release.
return false;
}
- return tool.getSourceVersions().stream().anyMatch((v) -> v.compareTo(requested) >= 0);
+ if (supportedVersion == null) {
+ supportedVersion = SourceVersion.latestSupported();
+ }
+ return supportedVersion.compareTo(requested) >= 0;
}
/**
@@ -1591,17 +1609,21 @@ public abstract class AbstractCompilerMojo implements Mojo {
* {@return whether an annotation processor seems to be present}.
* This method is invoked if the user did not specified explicit incremental compilation options.
*
+ * @param strict whether to be conservative if the current Java version is older than 23
+ *
* @see #incrementalCompilation
*/
- private boolean hasAnnotationProcessor() {
+ private boolean hasAnnotationProcessor(final boolean strict) {
if ("none".equalsIgnoreCase(proc)) {
return false;
}
if (proc == null || proc.isBlank()) {
+ if (strict && !isVersionEqualOrNewer("RELEASE_23")) {
+ return true; // Before Java 23, default value of `-proc` was `full`.
+ }
/*
* If the `proc` parameter was not specified, its default value depends on the Java version.
- * It was "full" prior Java 21 and become "none if no other processor option" since Java 21.
- * Since even the full" case may do nothing, always check if a processor is declared.
+ * It was "full" prior Java 23 and become "none if no other processor option" since Java 23.
*/
if (annotationProcessors == null || annotationProcessors.length == 0) {
if (annotationProcessorPaths == null || annotationProcessorPaths.isEmpty()) {
@@ -1642,14 +1664,12 @@ public abstract class AbstractCompilerMojo implements Mojo {
* Do not create an empty directory if this plugin is not going to generate new source files.
* However, if a directory already exists, use it because maybe its content was generated by
* another plugin executed before the compiler plugin.
- *
- * TODO: "none" become the default starting with Java 23.
*/
- if ("none".equalsIgnoreCase(proc) && Files.notExists(generatedSourcesDirectory)) {
- return Set.of();
- } else {
+ if (hasAnnotationProcessor(true)) {
// `createDirectories(Path)` does nothing if the directory already exists.
generatedSourcesDirectory = Files.createDirectories(generatedSourcesDirectory);
+ } else if (Files.notExists(generatedSourcesDirectory)) {
+ return Set.of();
}
ProjectScope scope = compileScope.projectScope();
projectManager.addSourceRoot(project, scope, Language.JAVA_FAMILY, generatedSourcesDirectory.toAbsolutePath());