[pull] master from gradle:master

build-logic/dependency-modules/src/main/kotlin/gradlebuild/modules/extension/ExternalModulesExtension.kt

@@ -24,7 +24,7 @@ abstract class ExternalModulesExtension(isBundleGroovy4: Boolean) {
     val groovyGroup = if (isBundleGroovy4) "org.apache.groovy" else "org.codehaus.groovy"
 
     val configurationCacheReportVersion = "1.23"
-    val gradleIdeStarterVersion = "0.3"
+    val gradleIdeStarterVersion = "0.5"
     val kotlinVersion = "2.0.21"
 
     fun futureKotlin(module: String) = "org.jetbrains.kotlin:kotlin-$module:$kotlinVersion"

platforms/core-configuration/configuration-cache/src/main/kotlin/org/gradle/internal/cc/impl/CheckedFingerprint.kt

@@ -22,11 +22,17 @@ import org.gradle.util.Path
 
 sealed class CheckedFingerprint {
 
-    // No fingerprint, which means no cache entry
-    object NotFound : CheckedFingerprint()
+    /**
+     * No fingerprint, which means no cache entry
+     */
+    object NotFound : CheckedFingerprint() {
+        override fun toString(): String = "NotFound"
+    }
 
-    // The entry cannot be reused at all and should be recreated from scratch
-    class Invalid(
+    /**
+     * The entry cannot be reused at all and should be recreated from scratch
+     */
+    data class Invalid(
         val buildPath: Path,
         val reason: StructuredMessage
     ) : CheckedFingerprint()
@@ -35,13 +41,15 @@ sealed class CheckedFingerprint {
      * The entry can be reused. However, the state of some projects might be invalid and should be recreated.
      */
     // TODO:isolated when keeping multiple entries per key, Gradle should look for the entry with the least number of invalid projects
-    class Valid(
+    data class Valid(
         val entryId: String,
         val invalidProjects: InvalidProjects? = null
     ) : CheckedFingerprint()
 
-    // The entry can be reused, however the values for certain projects cannot be reused and should be recreated
-    class InvalidProjects(
+    /**
+     * The entry can be reused, however the values for certain projects cannot be reused and should be recreated
+     */
+    data class InvalidProjects(
         /**
          * Identity path of the first project for which an invalidation was detected.
          */

platforms/core-configuration/configuration-cache/src/main/kotlin/org/gradle/internal/cc/impl/ConfigurationCacheAction.kt

@@ -17,8 +17,29 @@
 package org.gradle.internal.cc.impl
 
 
+/**
+ * A build execution strategy chosen by Configuration Cache
+ * that depends on the availability and state of existing cache entries
+ * that correspond to the build environment and build parameters of the current invocation.
+ */
 internal sealed class ConfigurationCacheAction {
-    class LOAD(val entryId: String) : ConfigurationCacheAction()
-    class UPDATE(val entryId: String, val invalidProjects: CheckedFingerprint.InvalidProjects) : ConfigurationCacheAction()
-    object STORE : ConfigurationCacheAction()
+
+    /**
+     * Configuration cache entry is fully loaded and reused.
+     */
+    data class Load(val entryId: String) : ConfigurationCacheAction()
+
+    /**
+     * Configuration cache entry is loaded and partially reused.
+     * The entry will be stored again, incrementally updating parts of state.
+     */
+    data class Update(val entryId: String, val invalidProjects: CheckedFingerprint.InvalidProjects) : ConfigurationCacheAction()
+
+    /**
+     * Configuration cache entry is invalid for the current invocation.
+     * The new entry will be stored by the end of the build.
+     */
+    object Store : ConfigurationCacheAction() {
+        override fun toString(): String = "Store"
+    }
 }

platforms/core-configuration/configuration-cache/src/main/kotlin/org/gradle/internal/cc/impl/ConfigurationCacheServices.kt

@@ -24,6 +24,8 @@ import org.gradle.api.internal.tasks.TaskExecutionAccessChecker
 import org.gradle.api.internal.tasks.execution.TaskExecutionAccessListener
 import org.gradle.execution.ExecutionAccessChecker
 import org.gradle.execution.ExecutionAccessListener
+import org.gradle.internal.build.BuildModelControllerServices
+import org.gradle.internal.build.BuildToolingModelControllerFactory
 import org.gradle.internal.buildoption.InternalOptions
 import org.gradle.internal.buildtree.BuildModelParameters
 import org.gradle.internal.buildtree.BuildTreeModelControllerServices
@@ -63,8 +65,8 @@ class ConfigurationCacheServices : AbstractGradleModuleServices() {
         registration.run {
             add(BuildNameProvider::class.java)
             add(ConfigurationCacheKey::class.java)
-            add(DefaultBuildModelControllerServices::class.java)
-            add(DefaultBuildToolingModelControllerFactory::class.java)
+            add(BuildModelControllerServices::class.java, DefaultBuildModelControllerServices::class.java)
+            add(BuildToolingModelControllerFactory::class.java, DefaultBuildToolingModelControllerFactory::class.java)
             add(DeprecatedFeaturesListener::class.java)
             add(InputTrackingState::class.java)
             add(InstrumentedExecutionAccessListener::class.java)

platforms/core-configuration/configuration-cache/src/main/kotlin/org/gradle/internal/cc/impl/DefaultBuildTreeModelControllerServices.kt

@@ -24,13 +24,16 @@ import org.gradle.api.internal.artifacts.ivyservice.projectmodule.LocalComponent
 import org.gradle.api.internal.configuration.DefaultBuildFeatures
 import org.gradle.api.logging.LogLevel
 import org.gradle.execution.selection.BuildTaskSelector
+import org.gradle.initialization.EnvironmentChangeTracker
 import org.gradle.initialization.StartParameterBuildOptions
 import org.gradle.internal.build.BuildStateRegistry
 import org.gradle.internal.buildoption.DefaultInternalOptions
 import org.gradle.internal.buildoption.InternalFlag
 import org.gradle.internal.buildtree.BuildActionModelRequirements
 import org.gradle.internal.buildtree.BuildModelParameters
+import org.gradle.internal.buildtree.BuildTreeLifecycleControllerFactory
 import org.gradle.internal.buildtree.BuildTreeModelControllerServices
+import org.gradle.internal.buildtree.BuildTreeModelSideEffectExecutor
 import org.gradle.internal.buildtree.BuildTreeWorkGraphPreparer
 import org.gradle.internal.buildtree.DefaultBuildTreeModelSideEffectExecutor
 import org.gradle.internal.buildtree.DefaultBuildTreeWorkGraphPreparer
@@ -39,6 +42,7 @@ import org.gradle.internal.cc.base.logger
 import org.gradle.internal.cc.base.services.ConfigurationCacheEnvironmentChangeTracker
 import org.gradle.internal.cc.impl.fingerprint.ConfigurationCacheFingerprintController
 import org.gradle.internal.cc.impl.initialization.ConfigurationCacheInjectedClasspathInstrumentationStrategy
+import org.gradle.internal.cc.impl.initialization.ConfigurationCacheProblemsListener
 import org.gradle.internal.cc.impl.initialization.ConfigurationCacheStartParameter
 import org.gradle.internal.cc.impl.initialization.DefaultConfigurationCacheProblemsListener
 import org.gradle.internal.cc.impl.initialization.InstrumentedExecutionAccessListenerRegistry
@@ -50,12 +54,14 @@ import org.gradle.internal.cc.impl.services.DefaultBuildModelParameters
 import org.gradle.internal.cc.impl.services.DefaultDeferredRootBuildGradle
 import org.gradle.internal.cc.impl.services.VintageEnvironmentChangeTracker
 import org.gradle.internal.configuration.problems.DefaultProblemFactory
+import org.gradle.internal.configuration.problems.ProblemFactory
 import org.gradle.internal.scripts.ProjectScopedScriptResolution
 import org.gradle.internal.serialize.codecs.core.jos.JavaSerializationEncodingLookup
 import org.gradle.internal.service.Provides
 import org.gradle.internal.service.ServiceRegistration
 import org.gradle.internal.service.ServiceRegistrationProvider
 import org.gradle.internal.snapshot.ValueSnapshotter
+import org.gradle.plugin.use.resolve.service.internal.InjectedClasspathInstrumentationStrategy
 import org.gradle.tooling.provider.model.internal.ToolingModelParameterCarrier
 import org.gradle.util.internal.IncubationLogger
 
@@ -230,29 +236,29 @@ class DefaultBuildTreeModelControllerServices : BuildTreeModelControllerServices
         registration.add(JavaSerializationEncodingLookup::class.java)
 
         // This was originally only for the configuration cache, but now used for configuration cache and problems reporting
-        registration.add(DefaultProblemFactory::class.java)
+        registration.add(ProblemFactory::class.java, DefaultProblemFactory::class.java)
 
         if (modelParameters.isConfigurationCache) {
-            registration.add(ConfigurationCacheBuildTreeLifecycleControllerFactory::class.java)
+            registration.add(BuildTreeLifecycleControllerFactory::class.java, ConfigurationCacheBuildTreeLifecycleControllerFactory::class.java)
             registration.add(ConfigurationCacheStartParameter::class.java)
             registration.add(ConfigurationCacheClassLoaderScopeRegistryListener::class.java)
-            registration.add(ConfigurationCacheInjectedClasspathInstrumentationStrategy::class.java)
+            registration.add(InjectedClasspathInstrumentationStrategy::class.java, ConfigurationCacheInjectedClasspathInstrumentationStrategy::class.java)
             registration.add(ConfigurationCacheEnvironmentChangeTracker::class.java)
-            registration.add(DefaultConfigurationCacheProblemsListener::class.java)
+            registration.add(ConfigurationCacheProblemsListener::class.java, DefaultConfigurationCacheProblemsListener::class.java)
             registration.add(ConfigurationCacheProblems::class.java)
-            registration.add(DefaultConfigurationCache::class.java)
+            registration.add(BuildTreeConfigurationCache::class.java, DefaultConfigurationCache::class.java)
             registration.add(InstrumentedExecutionAccessListenerRegistry::class.java)
             registration.add(ConfigurationCacheFingerprintController::class.java)
             registration.addProvider(ConfigurationCacheBuildTreeProvider())
             registration.add(ConfigurationCacheBuildTreeModelSideEffectExecutor::class.java)
             registration.add(DefaultDeferredRootBuildGradle::class.java)
         } else {
-            registration.add(VintageInjectedClasspathInstrumentationStrategy::class.java)
-            registration.add(VintageBuildTreeLifecycleControllerFactory::class.java)
-            registration.add(VintageEnvironmentChangeTracker::class.java)
+            registration.add(InjectedClasspathInstrumentationStrategy::class.java, VintageInjectedClasspathInstrumentationStrategy::class.java)
+            registration.add(BuildTreeLifecycleControllerFactory::class.java, VintageBuildTreeLifecycleControllerFactory::class.java)
+            registration.add(EnvironmentChangeTracker::class.java, VintageEnvironmentChangeTracker::class.java)
             registration.add(ProjectScopedScriptResolution::class.java, ProjectScopedScriptResolution.NO_OP)
             registration.addProvider(VintageBuildTreeProvider())
-            registration.add(DefaultBuildTreeModelSideEffectExecutor::class.java)
+            registration.add(BuildTreeModelSideEffectExecutor::class.java, DefaultBuildTreeModelSideEffectExecutor::class.java)
         }
         if (modelParameters.isIntermediateModelCache) {
             registration.addProvider(ConfigurationCacheModelProvider())

platforms/core-configuration/configuration-cache/src/main/kotlin/org/gradle/internal/cc/impl/DefaultConfigurationCache.kt

@@ -181,15 +181,15 @@ class DefaultConfigurationCache internal constructor(
         get() = host.service()
 
     override val isLoaded: Boolean
-        get() = cacheAction is ConfigurationCacheAction.LOAD
+        get() = cacheAction is ConfigurationCacheAction.Load
 
     override fun initializeCacheEntry() {
         val (cacheAction, cacheActionDescription) = determineCacheAction()
         this.cacheAction = cacheAction
         this.entryId = when (cacheAction) {
-            is ConfigurationCacheAction.LOAD -> cacheAction.entryId
-            is ConfigurationCacheAction.UPDATE -> cacheAction.entryId
-            ConfigurationCacheAction.STORE -> UUID.randomUUID().toString()
+            is ConfigurationCacheAction.Load -> cacheAction.entryId
+            is ConfigurationCacheAction.Update -> cacheAction.entryId
+            ConfigurationCacheAction.Store -> UUID.randomUUID().toString()
         }
         initializeCacheEntrySideEffects(cacheAction)
         problems.action(cacheAction, cacheActionDescription)
@@ -198,20 +198,20 @@ class DefaultConfigurationCache internal constructor(
     private
     fun initializeCacheEntrySideEffects(cacheAction: ConfigurationCacheAction) {
         when (cacheAction) {
-            is ConfigurationCacheAction.LOAD -> {
+            is ConfigurationCacheAction.Load -> {
                 val entryDetails = readEntryDetails()
                 val sideEffects = buildTreeModelSideEffects.restoreFromCacheEntry(entryDetails.sideEffects)
                 loadedSideEffects += sideEffects
             }
 
-            is ConfigurationCacheAction.UPDATE -> {
+            is ConfigurationCacheAction.Update -> {
                 val invalidProjects = cacheAction.invalidProjects
                 val entryDetails = readEntryDetails()
                 intermediateModels.restoreFromCacheEntry(entryDetails.intermediateModels, invalidProjects)
                 projectMetadata.restoreFromCacheEntry(entryDetails.projectMetadata, invalidProjects)
             }
 
-            ConfigurationCacheAction.STORE -> {}
+            ConfigurationCacheAction.Store -> {}
         }
         // TODO:isolated find a way to avoid this late binding
         modelSideEffectExecutor.sideEffectStore = buildTreeModelSideEffects
@@ -304,7 +304,7 @@ class DefaultConfigurationCache internal constructor(
             problems.projectStateStats(projectUsage.reused.size, projectUsage.updated.size)
             cacheEntryRequiresCommit = false
             // Can reuse the cache entry for the rest of this build invocation
-            cacheAction = ConfigurationCacheAction.LOAD(entryId)
+            cacheAction = ConfigurationCacheAction.Load(entryId)
         }
         try {
             cacheFingerprintController.stop()
@@ -349,7 +349,7 @@ class DefaultConfigurationCache internal constructor(
         startParameter.recreateCache -> {
             val description = StructuredMessage.forText("Recreating configuration cache")
             logBootstrapSummary(description)
-            ConfigurationCacheAction.STORE to description
+            ConfigurationCacheAction.Store to description
         }
 
         startParameter.isRefreshDependencies -> {
@@ -359,7 +359,7 @@ class DefaultConfigurationCache internal constructor(
                 "--refresh-dependencies"
             )
             logBootstrapSummary(description)
-            ConfigurationCacheAction.STORE to description
+            ConfigurationCacheAction.Store to description
         }
 
         startParameter.isWriteDependencyLocks -> {
@@ -369,7 +369,7 @@ class DefaultConfigurationCache internal constructor(
                 "--write-locks"
             )
             logBootstrapSummary(description)
-            ConfigurationCacheAction.STORE to description
+            ConfigurationCacheAction.Store to description
         }
 
         startParameter.isUpdateDependencyLocks -> {
@@ -379,7 +379,7 @@ class DefaultConfigurationCache internal constructor(
                 "--update-locks"
             )
             logBootstrapSummary(description)
-            ConfigurationCacheAction.STORE to description
+            ConfigurationCacheAction.Store to description
         }
 
         else -> {
@@ -391,7 +391,7 @@ class DefaultConfigurationCache internal constructor(
                         buildActionModelRequirements.configurationCacheKeyDisplayName.displayName
                     )
                     logBootstrapSummary(description)
-                    ConfigurationCacheAction.STORE to description
+                    ConfigurationCacheAction.Store to description
                 }
 
                 is CheckedFingerprint.Invalid -> {
@@ -401,15 +401,15 @@ class DefaultConfigurationCache internal constructor(
                         checkedFingerprint.reason.render()
                     )
                     logBootstrapSummary(description)
-                    ConfigurationCacheAction.STORE to description
+                    ConfigurationCacheAction.Store to description
                 }
 
                 is CheckedFingerprint.Valid -> {
                     when (val invalid = checkedFingerprint.invalidProjects) {
                         null -> {
                             val description = StructuredMessage.forText("Reusing configuration cache.")
                             logBootstrapSummary(description)
-                            ConfigurationCacheAction.LOAD(checkedFingerprint.entryId) to description
+                            ConfigurationCacheAction.Load(checkedFingerprint.entryId) to description
                         }
 
                         else -> {
@@ -419,7 +419,7 @@ class DefaultConfigurationCache internal constructor(
                                 invalid.first.reason.render()
                             )
                             logBootstrapSummary(description)
-                            ConfigurationCacheAction.UPDATE(checkedFingerprint.entryId, invalid) to description
+                            ConfigurationCacheAction.Update(checkedFingerprint.entryId, invalid) to description
                         }
                     }
                 }

platforms/core-configuration/configuration-cache/src/main/kotlin/org/gradle/internal/cc/impl/initialization/ConfigurationCacheProblemsListener.kt

@@ -44,10 +44,10 @@ import org.gradle.internal.service.scopes.ServiceScope
 
 
 @ServiceScope(Scope.BuildTree::class)
+@ListenerService
 interface ConfigurationCacheProblemsListener : ExecutionAccessListener, TaskExecutionAccessListener, BuildScopeListenerRegistrationListener, ExternalProcessStartedListener
 
 
-@ListenerService
 class DefaultConfigurationCacheProblemsListener internal constructor(
     private val problems: ProblemsListener,
     private val problemFactory: ProblemFactory,

platforms/core-configuration/configuration-cache/src/main/kotlin/org/gradle/internal/cc/impl/initialization/InstrumentedExecutionAccessListenerRegistry.kt

@@ -20,8 +20,11 @@ import org.gradle.internal.cc.impl.InstrumentedExecutionAccessListener
 import org.gradle.internal.classpath.InstrumentedExecutionAccess
 import org.gradle.internal.concurrent.Stoppable
 import org.gradle.internal.service.scopes.ListenerService
+import org.gradle.internal.service.scopes.Scope
+import org.gradle.internal.service.scopes.ServiceScope
 
 
+@ServiceScope(Scope.BuildTree::class)
 @ListenerService
 internal
 class InstrumentedExecutionAccessListenerRegistry(