More conservative default value of the <incrementalCompilation> parameter if an annotation processor is present.

Author: desruisseaux

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

@@ -289,7 +289,7 @@ final Charset charset() {
      * </ul>
      *
      * Prior Java 21, {@code full} was the default.
-     * Starting with JDK 21, this option must be set explicitly.
+     * Starting with Java 21, the default is {@code none} unless another processor option is used.
      *
      * @see #annotationProcessors
      * @see <a href="https://docs.oracle.com/en/java/javase/17/docs/specs/man/javac.html#option-proc">javac -proc</a>
@@ -363,7 +363,12 @@ final Charset charset() {
      * </p>
      *
      * @since 3.12.0
+     *
+     * @deprecated This flag is ignored.
+     * Replaced by ordinary dependencies with {@code <type>} element set to
+     * {@code processor}, {@code classpath-processor} or {@code modular-processor}.
      */
+    @Deprecated(since = "4.0.0")
     @Parameter(defaultValue = "false")
     protected boolean annotationProcessorPathsUseDepMgmt;
 
@@ -458,7 +463,7 @@ final Charset charset() {
 
     /**
      * Whether to provide more details about why a module is rebuilt.
-     * This is used only if {@link #incrementalCompilation} is {@code "inputTreeChanges"}.
+     * This is used only if {@link #incrementalCompilation} is set to something else than {@code "none"}.
      *
      * @see #incrementalCompilation
      */
@@ -586,13 +591,23 @@ final Charset charset() {
      * In all cases, the current compiler-plugin does not detect structural changes other than file addition or removal.
      * For example, the plugin does not detect whether a method has been removed in a class.
      *
+     * <h4>Default value</h4>
+     * The default value depends on the context.
+     * If there is no annotation processor, then the default is {@code "options,dependencies,sources"}.
+     * It means that a full rebuild will be done if the compiler options or the dependencies changed,
+     * or if a source file has been deleted. Otherwise, only the modified source files will be recompiled.
+     *
+     * <p>If an annotation processor is present (e.g., {@link #proc} set to a value other than {@code "none"}),
+     * then the default value is same as above with the addition of {@code "rebuild-on-add,rebuild-on-change"}.
+     * It means that a full rebuild will be done if any kind of change is detected.</p>
+     *
      * @see #staleMillis
      * @see #fileExtensions
      * @see #showCompilationChanges
      * @see #createMissingPackageInfoClass
      * @since 4.0.0
      */
-    @Parameter(defaultValue = "options,dependencies,sources")
+    @Parameter // The default values are implemented in `incrementalCompilationConfiguration()`.
     protected String incrementalCompilation;
 
     /**
@@ -610,18 +625,30 @@ final Charset charset() {
 
     /**
      * Returns the configuration of the incremental compilation.
-     * This method may be removed in a future version if the deprecated parameter is removed.
+     * If the argument is null or blank, then this method applies
+     * the default values documented in {@link #incrementalCompilation} javadoc.
      *
      * @throws MojoException if a value is not recognized, or if mutually exclusive values are specified
      */
     final EnumSet<IncrementalBuild.Aspect> incrementalCompilationConfiguration() {
-        if (useIncrementalCompilation != null) {
-            return useIncrementalCompilation
-                    ? EnumSet.of(
-                            IncrementalBuild.Aspect.DEPENDENCIES,
-                            IncrementalBuild.Aspect.SOURCES,
-                            IncrementalBuild.Aspect.REBUILD_ON_ADD)
-                    : EnumSet.of(IncrementalBuild.Aspect.CLASSES);
+        if (incrementalCompilation == null || incrementalCompilation.isBlank()) {
+            if (useIncrementalCompilation != null) {
+                return useIncrementalCompilation
+                        ? EnumSet.of(
+                                IncrementalBuild.Aspect.DEPENDENCIES,
+                                IncrementalBuild.Aspect.SOURCES,
+                                IncrementalBuild.Aspect.REBUILD_ON_ADD)
+                        : EnumSet.of(IncrementalBuild.Aspect.CLASSES);
+            }
+            var aspects = EnumSet.of(
+                    IncrementalBuild.Aspect.OPTIONS,
+                    IncrementalBuild.Aspect.DEPENDENCIES,
+                    IncrementalBuild.Aspect.SOURCES);
+            if (hasAnnotationProcessor()) {
+                aspects.add(IncrementalBuild.Aspect.REBUILD_ON_ADD);
+                aspects.add(IncrementalBuild.Aspect.REBUILD_ON_CHANGE);
+            }
+            return aspects;
         } else {
             return IncrementalBuild.Aspect.parse(incrementalCompilation);
         }
@@ -1502,6 +1529,44 @@ final void resolveProcessorPathEntries(Map<PathType, List<Path>> addTo) throws M
         }
     }
 
+    /**
+     * {@return whether an annotation processor seems to be present}.
+     * This method is invoked if the user did not specified explicit incremental compilation options.
+     *
+     * @see #incrementalCompilation
+     */
+    private boolean hasAnnotationProcessor() {
+        if ("none".equalsIgnoreCase(proc)) {
+            return false;
+        }
+        if (proc == null || proc.isBlank()) {
+            /*
+             * 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.
+             */
+            if (annotationProcessors == null || annotationProcessors.length == 0) {
+                if (annotationProcessorPaths == null || annotationProcessorPaths.isEmpty()) {
+                    DependencyResolver resolver = session.getService(DependencyResolver.class);
+                    if (resolver == null) { // Null value happen during tests, depending on the mock used.
+                        return false;
+                    }
+                    var allowedTypes = EnumSet.of(JavaPathType.PROCESSOR_CLASSES, JavaPathType.PROCESSOR_MODULES);
+                    DependencyResolverResult dependencies = resolver.resolve(DependencyResolverRequest.builder()
+                            .session(session)
+                            .project(project)
+                            .requestType(DependencyResolverRequest.RequestType.COLLECT)
+                            .pathScope(compileScope)
+                            .pathTypeFilter(allowedTypes)
+                            .build());
+
+                    return !dependencies.getDependencies().isEmpty();
+                }
+            }
+        }
+        return true;
+    }
+
     /**
      * Ensures that the directory for generated sources exists, and adds it to the list of source directories
      * known to the project manager. This is used for adding the output of annotation processor.

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

@@ -163,7 +163,7 @@ public String toString() {
          * Parses a comma-separated list of aspects.
          *
          * @param values the plugin parameter to parse as a comma-separated list
-         * @return the aspect
+         * @return the aspects which, when modified, should cause a partial or full rebuild
          * @throws MojoException if a value is not recognized, or if mutually exclusive values are specified
          */
         static EnumSet<Aspect> parse(final String values) {