[Gradle] Remove direct Provider.forUseAtConfigurationTime calls

#KT-53823 Fixed

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/compilerRunner/CompilerSystemPropertiesService.kt

@@ -11,6 +11,8 @@ import org.gradle.api.provider.Provider
 import org.gradle.api.services.BuildService
 import org.gradle.api.services.BuildServiceParameters
 import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
+import org.jetbrains.kotlin.gradle.plugin.internal.configurationTimePropertiesAccessor
+import org.jetbrains.kotlin.gradle.plugin.internal.usedAtConfigurationTime
 import org.jetbrains.kotlin.gradle.utils.isConfigurationCacheAvailable
 
 internal abstract class CompilerSystemPropertiesService : BuildService<CompilerSystemPropertiesService.Parameters>, AutoCloseable {
@@ -60,7 +62,8 @@ internal abstract class CompilerSystemPropertiesService : BuildService<CompilerS
                     CompilerSystemProperties.values()
                         .filterNot { it.alwaysDirectAccess }
                         .associate {
-                            it.property to gradle.rootProject.providers.systemProperty(it.property).forUseAtConfigurationTime()
+                            it.property to gradle.rootProject.providers.systemProperty(it.property)
+                                .usedAtConfigurationTime(gradle.configurationTimePropertiesAccessor)
                         }.toMap()
                 )
             }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptTask.kt

@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.gradle.internal.kapt.incremental.KaptIncrementalChan
 import org.jetbrains.kotlin.gradle.internal.kapt.incremental.UnknownSnapshot
 import org.jetbrains.kotlin.gradle.internal.tasks.TaskWithLocalState
 import org.jetbrains.kotlin.gradle.plugin.CompilerPluginConfig
+import org.jetbrains.kotlin.gradle.plugin.internal.configurationTimePropertiesAccessor
+import org.jetbrains.kotlin.gradle.plugin.internal.usedAtConfigurationTime
 import org.jetbrains.kotlin.gradle.tasks.*
 import org.jetbrains.kotlin.gradle.utils.*
 import org.jetbrains.kotlin.utils.addToStdlib.cast
@@ -258,24 +260,17 @@ abstract class KaptTask @Inject constructor(
     }
 
     companion object {
-        const val KAPT_VERBOSE_OPTION_NAME = "kapt.verbose"
+        private const val KAPT_VERBOSE_OPTION_NAME = "kapt.verbose"
 
         internal fun queryKaptVerboseProperty(
             project: Project
         ): Provider<Boolean> {
-            return if (isConfigurationCacheAvailable(project.gradle)) {
-                project
-                    .providers
-                    .gradleProperty(KAPT_VERBOSE_OPTION_NAME)
-                    .forUseAtConfigurationTime()
-                    .map { it.toString().toBoolean() }
-                    .orElse(false)
-            } else {
-                project.objects.property(
-                    project.hasProperty(KAPT_VERBOSE_OPTION_NAME) &&
-                            project.property(KAPT_VERBOSE_OPTION_NAME).toString().toBoolean()
-                )
-            }
+            return project
+                .providers
+                .gradleProperty(KAPT_VERBOSE_OPTION_NAME)
+                .usedAtConfigurationTime(project.gradle.configurationTimePropertiesAccessor)
+                .map { it.toString().toBoolean() }
+                .orElse(false)
         }
     }
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptWithoutKotlincTask.kt

@@ -213,12 +213,7 @@ abstract class KaptWithoutKotlincTask @Inject constructor(
         }
     }
 
-    internal fun getValue(propertyName: String): String? =
-        if (isGradleVersionAtLeast(6, 5)) {
-            providerFactory.gradleProperty(propertyName).forUseAtConfigurationTime().orNull
-        } else {
-            project.findProperty(propertyName) as String?
-        }
+    private fun getValue(propertyName: String): String? = providerFactory.gradleProperty(propertyName).orNull
 
     internal interface KaptWorkParameters : WorkParameters {
         val workerOptions: Property<KaptOptionsForWorker>

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/testing/KotlinWasmD8.kt

@@ -9,12 +9,12 @@ import org.gradle.api.Project
 import org.gradle.process.ProcessForkOptions
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesClientSettings
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutionSpec
+import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutor
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
 import org.jetbrains.kotlin.gradle.targets.js.RequiredKotlinJsDependency
 import org.jetbrains.kotlin.gradle.targets.js.addWasmExperimentalArguments
 import org.jetbrains.kotlin.gradle.targets.js.d8.D8RootPlugin
 import org.jetbrains.kotlin.gradle.targets.js.internal.parseNodeJsStackTraceAsJvm
-import org.jetbrains.kotlin.gradle.targets.js.isTeamCity
 import org.jetbrains.kotlin.gradle.targets.js.writeWasmUnitTestRunner
 import org.jetbrains.kotlin.gradle.utils.getValue
 
@@ -27,7 +27,7 @@ internal class KotlinWasmD8(private val kotlinJsTest: KotlinJsTest) : KotlinJsTe
 
     private val d8 = D8RootPlugin.apply(project.rootProject)
     private val d8Executable by project.provider { d8.requireConfigured().executablePath }
-    private val isTeamCity by lazy { project.isTeamCity }
+    private val isTeamCity = project.providers.gradleProperty(TCServiceMessagesTestExecutor.TC_PROJECT_PROPERTY)
 
     init {
         kotlinJsTest.outputs.upToDateWhen { false }
@@ -50,7 +50,7 @@ internal class KotlinWasmD8(private val kotlinJsTest: KotlinJsTest) : KotlinJsTe
             prependSuiteName = true,
             stackTraceParser = ::parseNodeJsStackTraceAsJvm,
             ignoreOutOfRootNodes = true,
-            escapeTCMessagesInLog = isTeamCity
+            escapeTCMessagesInLog = isTeamCity.isPresent
         )
 
         val cliArgs = KotlinTestRunnerCliArgs(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/testing/KotlinWasmNode.kt

@@ -8,18 +8,18 @@ package org.jetbrains.kotlin.gradle.targets.js.testing
 import org.gradle.process.ProcessForkOptions
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesClientSettings
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutionSpec
+import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutor
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
 import org.jetbrains.kotlin.gradle.targets.js.RequiredKotlinJsDependency
 import org.jetbrains.kotlin.gradle.targets.js.addWasmExperimentalArguments
 import org.jetbrains.kotlin.gradle.targets.js.internal.parseNodeJsStackTraceAsJvm
-import org.jetbrains.kotlin.gradle.targets.js.isTeamCity
 import org.jetbrains.kotlin.gradle.targets.js.writeWasmUnitTestRunner
 
 internal class KotlinWasmNode(private val kotlinJsTest: KotlinJsTest) : KotlinJsTestFramework {
     override val settingsState: String = "KotlinWasmNode"
     @Transient
     override val compilation: KotlinJsCompilation = kotlinJsTest.compilation
-    private val isTeamCity by lazy { compilation.target.project.isTeamCity }
+    private val isTeamCity = compilation.target.project.providers.gradleProperty(TCServiceMessagesTestExecutor.TC_PROJECT_PROPERTY)
 
     init {
         kotlinJsTest.outputs.upToDateWhen { false }
@@ -39,7 +39,7 @@ internal class KotlinWasmNode(private val kotlinJsTest: KotlinJsTest) : KotlinJs
             prependSuiteName = true,
             stackTraceParser = ::parseNodeJsStackTraceAsJvm,
             ignoreOutOfRootNodes = true,
-            escapeTCMessagesInLog = isTeamCity
+            escapeTCMessagesInLog = isTeamCity.isPresent
         )
 
         val cliArgs = KotlinTestRunnerCliArgs(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/testing/karma/KotlinKarma.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.gradle.internal.operation
 import org.jetbrains.kotlin.gradle.internal.processLogMessage
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesClientSettings
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutionSpec
+import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutor
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
@@ -63,7 +64,7 @@ class KotlinKarma(
     private var configDirectory: File by property {
         defaultConfigDirectory
     }
-    private val isTeamCity by lazy { project.isTeamCity }
+    private val isTeamCity = project.providers.gradleProperty(TCServiceMessagesTestExecutor.TC_PROJECT_PROPERTY)
 
     override val requiredNpmDependencies: Set<RequiredKotlinJsDependency>
         get() = requiredDependencies + webpackConfig.getRequiredDependencies(versions)
@@ -414,7 +415,7 @@ class KotlinKarma(
             prependSuiteName = true,
             stackTraceParser = ::parseNodeJsStackTraceAsJvm,
             ignoreOutOfRootNodes = true,
-            escapeTCMessagesInLog = isTeamCity
+            escapeTCMessagesInLog = isTeamCity.isPresent
         )
 
         config.basePath = npmProject.nodeModulesDir.absolutePath

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/testing/mocha/KotlinMocha.kt

@@ -9,6 +9,7 @@ import org.gradle.api.Project
 import org.gradle.process.ProcessForkOptions
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesClientSettings
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutionSpec
+import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutor
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsCompilation
 import org.jetbrains.kotlin.gradle.targets.js.RequiredKotlinJsDependency
@@ -20,7 +21,6 @@ import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
 import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTestFramework
 import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinTestRunnerCliArgs
 import java.io.File
-import org.jetbrains.kotlin.gradle.targets.js.isTeamCity
 
 class KotlinMocha(@Transient override val compilation: KotlinJsCompilation, private val basePath: String) :
     KotlinJsTestFramework {
@@ -28,7 +28,7 @@ class KotlinMocha(@Transient override val compilation: KotlinJsCompilation, priv
     private val project: Project = compilation.target.project
     private val npmProject = compilation.npmProject
     private val versions = NodeJsRootPlugin.apply(project.rootProject).versions
-    private val isTeamCity by lazy { project.isTeamCity }
+    private val isTeamCity = project.providers.gradleProperty(TCServiceMessagesTestExecutor.TC_PROJECT_PROPERTY)
 
     override val settingsState: String
         get() = "mocha"
@@ -60,7 +60,7 @@ class KotlinMocha(@Transient override val compilation: KotlinJsCompilation, priv
             prependSuiteName = true,
             stackTraceParser = ::parseNodeJsStackTraceAsJvm,
             ignoreOutOfRootNodes = true,
-            escapeTCMessagesInLog = isTeamCity
+            escapeTCMessagesInLog = isTeamCity.isPresent
         )
 
         val cliArgs = KotlinTestRunnerCliArgs(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/utils.kt

@@ -62,13 +62,6 @@ const val JS = "js"
 const val JS_MAP = "js.map"
 const val META_JS = "meta.js"
 
-val Project.isTeamCity: Boolean
-    get() = if (isConfigurationCacheAvailable(project.gradle)) {
-        project.providers.gradleProperty(TCServiceMessagesTestExecutor.TC_PROJECT_PROPERTY).forUseAtConfigurationTime().isPresent
-    } else {
-        project.hasProperty(TCServiceMessagesTestExecutor.TC_PROJECT_PROPERTY)
-    }
-
 internal fun writeWasmUnitTestRunner(compiledFile: File): File {
     val testRunnerFile = compiledFile.parentFile.resolve("runUnitTests.mjs")
     testRunnerFile.writeText(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/CacheableTasks.kt

@@ -17,12 +17,13 @@
 package org.jetbrains.kotlin.gradle.tasks
 
 import org.gradle.api.Task
-import org.jetbrains.kotlin.gradle.utils.getSystemProperty
-
-private fun Task.isBuildCacheEnabledForKotlin(): Boolean = project.getSystemProperty(KOTLIN_CACHING_ENABLED_PROPERTY)?.toBoolean() ?: true
+import org.jetbrains.kotlin.gradle.utils.readSystemPropertyAtConfigurationTime
 
 internal fun <T : Task> T.cacheOnlyIfEnabledForKotlin() {
-    outputs.cacheIf { isBuildCacheEnabledForKotlin() }
+    // It's actually read at execution time, but the read should be declared for Gradle < 7.4 when KGP is used in buildSrc / includedBuild
+    // because it's interpreted as configuration time for the main project
+    val kotlinCachingEnabled = project.readSystemPropertyAtConfigurationTime(KOTLIN_CACHING_ENABLED_PROPERTY)
+    outputs.cacheIf { kotlinCachingEnabled.map { it.toBoolean() }.orNull ?: true }
 }
 
 private const val KOTLIN_CACHING_ENABLED_PROPERTY = "kotlin.caching.enabled"

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/configuration/KaptConfig.kt

@@ -128,14 +128,7 @@ internal open class KaptConfig<TASK : KaptTask>(
                 if ("-source" in result || "--source" in result || "--release" in result) return@also
 
                 if (defaultJavaSourceCompatibility.isPresent) {
-                    val atLeast12Java =
-                        if (isConfigurationCacheAvailable(project.gradle)) {
-                            val currentJavaVersion =
-                                JavaVersion.parse(project.providers.systemProperty("java.version").forUseAtConfigurationTime().get())
-                            currentJavaVersion.feature >= 12
-                        } else {
-                            SystemInfo.isJavaVersionAtLeast(12, 0, 0)
-                        }
+                    val atLeast12Java = SystemInfo.isJavaVersionAtLeast(12, 0, 0)
                     val sourceOptionKey = if (atLeast12Java) {
                         "--source"
                     } else {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/testing/internal/KotlinTestsRegistry.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.gradle.tasks.dependsOn
 import org.jetbrains.kotlin.gradle.tasks.locateOrRegisterTask
 import org.jetbrains.kotlin.gradle.tasks.registerTask
 import org.jetbrains.kotlin.gradle.tasks.locateTask
-import org.jetbrains.kotlin.gradle.utils.getSystemProperty
+import org.jetbrains.kotlin.gradle.utils.readSystemPropertyAtConfigurationTime
 
 /**
  * Internal service for creating aggregated test tasks and registering all test tasks.
@@ -74,7 +74,7 @@ class KotlinTestsRegistry(val project: Project, val allTestsTaskName: String = "
 
             aggregate.destinationDir = project.testReportsDir.resolve(reportName)
 
-            val isIdeaActive = project.getSystemProperty("idea.active") != null
+            val isIdeaActive = project.readSystemPropertyAtConfigurationTime("idea.active").isPresent
 
             if (isIdeaActive) {
                 aggregate.extensions.extraProperties.set("idea.internal.test", true)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/configurationCache.kt

@@ -9,6 +9,9 @@ import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.internal.StartParameterInternal
 import org.gradle.api.invocation.Gradle
+import org.gradle.api.provider.Provider
+import org.jetbrains.kotlin.gradle.plugin.internal.configurationTimePropertiesAccessor
+import org.jetbrains.kotlin.gradle.plugin.internal.usedAtConfigurationTime
 
 internal fun isConfigurationCacheAvailable(gradle: Gradle) =
     try {
@@ -18,12 +21,8 @@ internal fun isConfigurationCacheAvailable(gradle: Gradle) =
         null
     } ?: false
 
-internal fun Project.getSystemProperty(key: String): String? {
-    return if (isConfigurationCacheAvailable(gradle)) {
-        providers.systemProperty(key).forUseAtConfigurationTime().orNull
-    } else {
-        System.getProperty(key)
-    }
+internal fun Project.readSystemPropertyAtConfigurationTime(key: String): Provider<String> {
+    return providers.systemProperty(key).usedAtConfigurationTime(gradle.configurationTimePropertiesAccessor)
 }
 
 internal fun unavailableValueError(propertyName: String): Nothing =

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/runProjectConfigurationHealthCheck.kt

@@ -9,6 +9,8 @@ import org.gradle.api.Project
 import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.api.provider.Provider
 import org.gradle.tooling.model.kotlin.dsl.KotlinDslModelsParameters
+import org.jetbrains.kotlin.gradle.plugin.internal.configurationTimePropertiesAccessor
+import org.jetbrains.kotlin.gradle.plugin.internal.usedAtConfigurationTime
 import org.jetbrains.kotlin.gradle.plugin.whenEvaluated
 
 /**
@@ -80,7 +82,7 @@ private fun Project.syncExceptionsAreNotEmpty(): Boolean {
 private val Project.providerModeSystemPropertyValue: Provider<String>
     get() = providers
         .systemProperty(KotlinDslModelsParameters.PROVIDER_MODE_SYSTEM_PROPERTY_NAME)
-        .forUseAtConfigurationTime()
+        .usedAtConfigurationTime(gradle.configurationTimePropertiesAccessor)
 
 private fun Project.inLenientMode() =
     providerModeSystemPropertyValue.orNull == KotlinDslModelsParameters.CLASSPATH_MODE_SYSTEM_PROPERTY_VALUE

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest.kt

@@ -195,6 +195,7 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
     @Test
     fun `test WhenAndroidIsApplied - android is applied after the health check call`() {
         val project = ProjectBuilder.builder().build()
+        project.gradle.registerConfigurationTimePropertiesAccessorForTests()
 
         project.runMultiplatformAndroidGradlePluginCompatibilityHealthCheckWhenAndroidIsApplied(
             testLogger, FixedAndroidGradlePluginVersionProvider(null)
@@ -211,6 +212,7 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
     @Test
     fun `test - WhenAndroidIsApplied - android is applied before the health check call`() {
         val project = ProjectBuilder.builder().build()
+        project.gradle.registerConfigurationTimePropertiesAccessorForTests()
         addBuildEventsListenerRegistryMock(project)
         project.plugins.apply(LibraryPlugin::class.java)
 
@@ -224,6 +226,7 @@ class KotlinMultiplatformAndroidGradlePluginCompatibilityHealthCheckTest {
     @Test
     fun `test - WhenAndroidIsApplied - called multiple times - still emits only a single message`() {
         val project = ProjectBuilder.builder().build()
+        project.gradle.registerConfigurationTimePropertiesAccessorForTests()
         addBuildEventsListenerRegistryMock(project)
         project.plugins.apply(LibraryPlugin::class.java)
 

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/variants.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle
+
+import org.gradle.api.invocation.Gradle
+import org.jetbrains.kotlin.gradle.plugin.VariantImplementationFactories
+import org.jetbrains.kotlin.gradle.plugin.internal.ConfigurationTimePropertiesAccessor
+import org.jetbrains.kotlin.gradle.plugin.internal.DefaultConfigurationTimePropertiesAccessorVariantFactory
+
+/**
+ * [ConfigurationTimePropertiesAccessor] default factory is automatically registered in [org.jetbrains.kotlin.gradle.plugin.DefaultKotlinBasePlugin.apply]
+ * This helper function is for simple tests that are testing granular logic without applying Kotlin plugin
+ */
+fun Gradle.registerConfigurationTimePropertiesAccessorForTests() {
+    VariantImplementationFactories.get(gradle).putIfAbsent(
+        ConfigurationTimePropertiesAccessor.ConfigurationTimePropertiesAccessorVariantFactory::class,
+        DefaultConfigurationTimePropertiesAccessorVariantFactory()
+    )
+}