Add maven.build.cache.cacheCompile property to control compile-phase caching

Added new configuration property maven.build.cache.cacheCompile (default: true)
to address reviewer concerns about performance overhead during active development.

Changes:
- CacheConfig: Added isCacheCompile() method with javadoc
- CacheConfigImpl: Added CACHE_COMPILE constant and implementation (default true)
- CacheControllerImpl: Wrapped attachGeneratedSources() and attachOutputs()
  calls in isCacheCompile() check
- CacheCompileDisabledTest: Integration tests verifying behavior when disabled

Benefits:
- Maintains fix for issue #393 (default behavior unchanged)
- Allows developers to opt-out of compile caching with:
  -Dmaven.build.cache.cacheCompile=false
- Reduces IO overhead (no zipping/uploading) during active development
- Users working on large multi-module projects can keep it enabled

Usage:
  # Disable compile caching to reduce overhead during development:
  mvn clean compile -Dmaven.build.cache.cacheCompile=false

  # Enable for CI/multi-module scenarios (default):
  mvn clean compile

Author: cowwoc

src/main/java/org/apache/maven/buildcache/CacheControllerImpl.java

@@ -525,8 +525,13 @@ public void save(
             final org.apache.maven.artifact.Artifact projectArtifact = project.getArtifact();
             final boolean hasPackagePhase = project.hasLifecyclePhase("package");
 
-            attachGeneratedSources(project, state, buildStartTime);
-            attachOutputs(project, state, buildStartTime);
+            // Cache compile outputs (classes, test-classes, generated sources) if enabled
+            // This allows compile-only builds to create restorable cache entries
+            // Can be disabled with -Dmaven.build.cache.cacheCompile=false to reduce IO overhead
+            if (cacheConfig.isCacheCompile()) {
+                attachGeneratedSources(project, state, buildStartTime);
+                attachOutputs(project, state, buildStartTime);
+            }
 
             final List<org.apache.maven.artifact.Artifact> attachedArtifacts = project.getAttachedArtifacts() != null
                     ? project.getAttachedArtifacts()

src/main/java/org/apache/maven/buildcache/xml/CacheConfig.java

@@ -152,4 +152,15 @@ public interface CacheConfig {
      * Flag to save in cache only if a build went through the clean lifecycle
      */
     boolean isMandatoryClean();
+
+    /**
+     * Flag to cache compile phase outputs (classes, test-classes, generated sources).
+     * When enabled (default), compile-only builds create cache entries that can be restored
+     * by subsequent builds. When disabled, caching only occurs during package phase or later.
+     * <p>
+     * Use: -Dmaven.build.cache.cacheCompile=(true|false)
+     * <p>
+     * Default: true
+     */
+    boolean isCacheCompile();
 }

src/main/java/org/apache/maven/buildcache/xml/CacheConfigImpl.java

@@ -97,6 +97,7 @@ public class CacheConfigImpl implements org.apache.maven.buildcache.xml.CacheCon
     public static final String RESTORE_GENERATED_SOURCES_PROPERTY_NAME = "maven.build.cache.restoreGeneratedSources";
     public static final String ALWAYS_RUN_PLUGINS = "maven.build.cache.alwaysRunPlugins";
     public static final String MANDATORY_CLEAN = "maven.build.cache.mandatoryClean";
+    public static final String CACHE_COMPILE = "maven.build.cache.cacheCompile";
 
     /**
      * Flag to control if we should skip lookup for cached artifacts globally or for a particular project even if
@@ -541,6 +542,11 @@ public boolean isMandatoryClean() {
         return getProperty(MANDATORY_CLEAN, getConfiguration().isMandatoryClean());
     }
 
+    @Override
+    public boolean isCacheCompile() {
+        return getProperty(CACHE_COMPILE, true);
+    }
+
     @Override
     public String getId() {
         checkInitializedState();

src/test/java/org/apache/maven/buildcache/its/CacheCompileDisabledTest.java

@@ -0,0 +1,129 @@
+/*
+ * 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.buildcache.its;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+import org.apache.maven.buildcache.its.junit.IntegrationTest;
+import org.apache.maven.it.VerificationException;
+import org.apache.maven.it.Verifier;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests that the maven.build.cache.cacheCompile property correctly disables
+ * caching of compile-phase outputs.
+ */
+@IntegrationTest("src/test/projects/simple-project")
+class CacheCompileDisabledTest {
+
+    @Test
+    void compileDoesNotCacheWhenDisabled(Verifier verifier) throws VerificationException, IOException {
+        verifier.setAutoclean(false);
+
+        Path basedir = Paths.get(verifier.getBasedir());
+        Path localCache = basedir.resolveSibling("cache-local");
+
+        // Clean cache before test
+        if (Files.exists(localCache)) {
+            deleteDirectory(localCache);
+        }
+        Files.createDirectories(localCache);
+
+        // First compile with cacheCompile disabled
+        verifier.setLogFileName("../log-compile-disabled.txt");
+        verifier.addCliOption("-Dmaven.build.cache.cacheCompile=false");
+        verifier.executeGoals(Arrays.asList("clean", "compile"));
+        verifier.verifyErrorFreeLog();
+
+        // Verify NO cache entry was created (no buildinfo.xml in local cache)
+        boolean hasCacheEntry = Files.walk(localCache)
+                .anyMatch(p -> p.getFileName().toString().equals("buildinfo.xml"));
+        assertFalse(hasCacheEntry,
+                "Cache entry should NOT be created when maven.build.cache.cacheCompile=false");
+
+        // Clean project and run compile again
+        verifier.setLogFileName("../log-compile-disabled-2.txt");
+        verifier.addCliOption("-Dmaven.build.cache.cacheCompile=false");
+        verifier.executeGoals(Arrays.asList("clean", "compile"));
+        verifier.verifyErrorFreeLog();
+
+        // Verify cache miss (should NOT restore from cache)
+        Path logFile = basedir.getParent().resolve("log-compile-disabled-2.txt");
+        String logContent = new String(Files.readAllBytes(logFile));
+        assertFalse(logContent.contains("Found cached build, restoring"),
+                "Should NOT restore from cache when cacheCompile was disabled");
+    }
+
+    @Test
+    void compileCreatesCacheEntryWhenEnabled(Verifier verifier) throws VerificationException, IOException {
+        verifier.setAutoclean(false);
+
+        Path basedir = Paths.get(verifier.getBasedir());
+        Path localCache = basedir.resolveSibling("cache-local");
+
+        // Clean cache before test
+        if (Files.exists(localCache)) {
+            deleteDirectory(localCache);
+        }
+        Files.createDirectories(localCache);
+
+        // First compile with cacheCompile enabled (default)
+        verifier.setLogFileName("../log-compile-enabled.txt");
+        verifier.executeGoals(Arrays.asList("clean", "compile"));
+        verifier.verifyErrorFreeLog();
+
+        // Verify cache entry WAS created
+        boolean hasCacheEntry = Files.walk(localCache)
+                .anyMatch(p -> p.getFileName().toString().equals("buildinfo.xml"));
+        assertTrue(hasCacheEntry,
+                "Cache entry should be created when maven.build.cache.cacheCompile=true (default)");
+
+        // Clean project and run compile again
+        verifier.setLogFileName("../log-compile-enabled-2.txt");
+        verifier.executeGoals(Arrays.asList("clean", "compile"));
+        verifier.verifyErrorFreeLog();
+
+        // Verify cache hit (should restore from cache)
+        verifier.verifyTextInLog("Found cached build, restoring");
+        verifier.verifyTextInLog("Skipping plugin execution (cached): compiler:compile");
+    }
+
+    private void deleteDirectory(Path directory) throws IOException {
+        if (Files.exists(directory)) {
+            try (Stream<Path> walk = Files.walk(directory)) {
+                walk.sorted((a, b) -> b.compareTo(a))
+                        .forEach(path -> {
+                            try {
+                                Files.delete(path);
+                            } catch (IOException e) {
+                                // Ignore
+                            }
+                        });
+            }
+        }
+    }
+}