[Gradle] Promote KotlinMultiplatformPluginLifecycle to KotlinPluginLifecycle

KT-34662

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

@@ -9,7 +9,7 @@ import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.withContext
 import org.gradle.api.Project
 import org.gradle.api.provider.Property
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.*
 import org.jetbrains.kotlin.gradle.utils.getOrPut
 import java.lang.ref.WeakReference
 import java.util.*
@@ -23,18 +23,18 @@ import kotlin.reflect.KProperty
 Util functions
  */
 
-internal fun Project.launch(block: suspend KotlinMultiplatformPluginLifecycle.() -> Unit) {
+internal fun Project.launch(block: suspend KotlinPluginLifecycle.() -> Unit) {
-    kotlinMultiplatformPluginLifecycle.launch(block)
+    kotlinPluginLifecycle.launch(block)
 }
 
-internal fun Project.launchInStage(stage: Stage, block: suspend KotlinMultiplatformPluginLifecycle.() -> Unit) {
+internal fun Project.launchInStage(stage: Stage, block: suspend KotlinPluginLifecycle.() -> Unit) {
     launch {
         await(stage)
         block()
     }
 }
 
-internal fun Project.launchInRequiredStage(stage: Stage, block: suspend KotlinMultiplatformPluginLifecycle.() -> Unit) {
+internal fun Project.launchInRequiredStage(stage: Stage, block: suspend KotlinPluginLifecycle.() -> Unit) {
     launchInStage(stage) {
         requiredStage(stage) {
             block()
@@ -42,41 +42,42 @@ internal fun Project.launchInRequiredStage(stage: Stage, block: suspend KotlinMu
     }
 }
 
-internal val Project.kotlinMultiplatformPluginLifecycle: KotlinMultiplatformPluginLifecycle
+internal val Project.kotlinPluginLifecycle: KotlinPluginLifecycle
-    get() = extraProperties.getOrPut(KotlinMultiplatformPluginLifecycle::class.java.name) {
+    get() = extraProperties.getOrPut(KotlinPluginLifecycle::class.java.name) {
-        KotlinMultiplatformPluginLifecycleImpl(project)
+        KotlinPluginLifecycleImpl(project)
     }
 
-internal fun Project.startKotlinMultiplatformPluginLifecycle() {
+internal fun Project.startKotlinPluginLifecycle() {
-    (kotlinMultiplatformPluginLifecycle as KotlinMultiplatformPluginLifecycleImpl).start()
+    (kotlinPluginLifecycle as KotlinPluginLifecycleImpl).start()
 }
 
-internal suspend fun currentMultiplatformPluginLifecycle(): KotlinMultiplatformPluginLifecycle {
+internal suspend fun currentKotlinPluginLifecycle(): KotlinPluginLifecycle {
     return currentCoroutineContext()[KotlinMultiplatformPluginLifecycleCoroutineContextElement]?.lifecycle
         ?: error("Missing $KotlinMultiplatformPluginLifecycleCoroutineContextElement in currentCoroutineContext")
 }
 
 internal suspend fun await(stage: Stage) {
-    currentMultiplatformPluginLifecycle().await(stage)
+    currentKotlinPluginLifecycle().await(stage)
 }
 
-internal inline fun <reified T : Any> Project.newLifecycleAwareProperty(
+internal inline fun <reified T : Any> Project.newKotlinPluginLifecycleAwareProperty(
     finaliseIn: Stage = Stage.FinaliseDsl, initialValue: T? = null
 ): LifecycleAwareProperty<T> {
-    return kotlinMultiplatformPluginLifecycle.newLifecycleAwareProperty(T::class.java, finaliseIn, initialValue)
+    return kotlinPluginLifecycle.newLifecycleAwareProperty(T::class.java, finaliseIn, initialValue)
 }
 
-internal suspend fun <T : Any> Property<T>.findLifecycleAwareProperty(): LifecycleAwareProperty<T>? {
+internal suspend fun <T : Any> Property<T>.findKotlinPluginLifecycleAwareProperty(): LifecycleAwareProperty<T>? {
-    return (currentMultiplatformPluginLifecycle() as KotlinMultiplatformPluginLifecycleImpl).findLifecycleAwareProperty(this)
+    return (currentKotlinPluginLifecycle() as KotlinPluginLifecycleImpl).findLifecycleAwareProperty(this)
 }
 
 internal suspend fun <T : Any> Property<T>.awaitFinalValue(): T? {
-    val lifecycleAwareProperty = findLifecycleAwareProperty() ?: throw IllegalArgumentException("Property is not lifecycle aware")
+    val lifecycleAwareProperty = findKotlinPluginLifecycleAwareProperty()
+        ?: throw IllegalArgumentException("Property is not lifecycle aware")
     return lifecycleAwareProperty.awaitFinalValue()
 }
 
-internal suspend fun Property<*>.isLifecycleAware(): Boolean {
+internal suspend fun Property<*>.isKotlinPluginLifecycleAware(): Boolean {
-    return findLifecycleAwareProperty() != null
+    return findKotlinPluginLifecycleAwareProperty() != null
 }
 
 internal suspend fun <T> requiredStage(stage: Stage, block: suspend () -> T): T {
@@ -84,11 +85,11 @@ internal suspend fun <T> requiredStage(stage: Stage, block: suspend () -> T): T
 }
 
 internal suspend fun <T> requireCurrentStage(block: suspend () -> T): T {
-    return requiredStage(currentMultiplatformPluginLifecycle().stage, block)
+    return requiredStage(currentKotlinPluginLifecycle().stage, block)
 }
 
 internal suspend fun <T> withRestrictedStages(allowed: Set<Stage>, block: suspend () -> T): T {
-    return withContext(RestrictedLifecycleStages(currentMultiplatformPluginLifecycle(), allowed)) {
+    return withContext(RestrictedLifecycleStages(currentKotlinPluginLifecycle(), allowed)) {
         block()
     }
 }
@@ -97,7 +98,7 @@ internal suspend fun <T> withRestrictedStages(allowed: Set<Stage>, block: suspen
 Definition of the Lifecycle and its stages
  */
 
-internal interface KotlinMultiplatformPluginLifecycle {
+internal interface KotlinPluginLifecycle {
     enum class Stage {
         Configure,
         AfterEvaluate,
@@ -130,9 +131,9 @@ internal interface KotlinMultiplatformPluginLifecycle {
 
     val stage: Stage
 
-    fun enqueue(stage: Stage, action: KotlinMultiplatformPluginLifecycle.() -> Unit)
+    fun enqueue(stage: Stage, action: KotlinPluginLifecycle.() -> Unit)
 
-    fun launch(block: suspend KotlinMultiplatformPluginLifecycle.() -> Unit)
+    fun launch(block: suspend KotlinPluginLifecycle.() -> Unit)
 
     suspend fun await(stage: Stage)
 
@@ -155,9 +156,9 @@ internal interface KotlinMultiplatformPluginLifecycle {
 Implementation
  */
 
-private class KotlinMultiplatformPluginLifecycleImpl(override val project: Project) : KotlinMultiplatformPluginLifecycle {
+private class KotlinPluginLifecycleImpl(override val project: Project) : KotlinPluginLifecycle {
     private val enqueuedStages: ArrayDeque<Stage> = ArrayDeque(Stage.values)
-    private val enqueuedActions: Map<Stage, ArrayDeque<KotlinMultiplatformPluginLifecycle.() -> Unit>> =
+    private val enqueuedActions: Map<Stage, ArrayDeque<KotlinPluginLifecycle.() -> Unit>> =
         Stage.values().associateWith { ArrayDeque() }
 
     private var configureLoopRunning = AtomicBoolean(false)
@@ -168,11 +169,11 @@ private class KotlinMultiplatformPluginLifecycleImpl(override val project: Proje
 
     fun start() {
         check(!isStarted.getAndSet(true)) {
-            "${KotlinMultiplatformPluginLifecycle::class.java.name} already started"
+            "${KotlinPluginLifecycle::class.java.name} already started"
         }
 
         check(!project.state.executed) {
-            "${KotlinMultiplatformPluginLifecycle::class.java.name} cannot be started in ProjectState '${project.state}'"
+            "${KotlinPluginLifecycle::class.java.name} cannot be started in ProjectState '${project.state}'"
         }
 
         project.whenEvaluated {
@@ -213,7 +214,7 @@ private class KotlinMultiplatformPluginLifecycleImpl(override val project: Proje
 
     override var stage: Stage = enqueuedStages.removeFirst()
 
-    override fun enqueue(stage: Stage, action: KotlinMultiplatformPluginLifecycle.() -> Unit) {
+    override fun enqueue(stage: Stage, action: KotlinPluginLifecycle.() -> Unit) {
         if (stage < this.stage) {
             throw IllegalLifecycleException("Cannot enqueue Action for stage '${this.stage}' in current stage '${this.stage}'")
         }
@@ -225,10 +226,10 @@ private class KotlinMultiplatformPluginLifecycleImpl(override val project: Proje
         }
     }
 
-    override fun launch(block: suspend KotlinMultiplatformPluginLifecycle.() -> Unit) {
+    override fun launch(block: suspend KotlinPluginLifecycle.() -> Unit) {
         val lifecycle = this
-        check(isStarted.get()) { "Cannot launch when ${KotlinMultiplatformPluginLifecycle::class.simpleName} is not started" }
+        check(isStarted.get()) { "Cannot launch when ${KotlinPluginLifecycle::class.simpleName} is not started" }
-        check(!isFinished.get()) { "Cannot launch when ${KotlinMultiplatformPluginLifecycle::class.simpleName} is already finished" }
+        check(!isFinished.get()) { "Cannot launch when ${KotlinPluginLifecycle::class.simpleName} is already finished" }
 
         val coroutine = block.createCoroutine(this, object : Continuation<Unit> {
             override val context: CoroutineContext = EmptyCoroutineContext +
@@ -277,7 +278,7 @@ private class KotlinMultiplatformPluginLifecycleImpl(override val project: Proje
 }
 
 private class KotlinMultiplatformPluginLifecycleCoroutineContextElement(
-    val lifecycle: KotlinMultiplatformPluginLifecycle
+    val lifecycle: KotlinPluginLifecycle
 ) : CoroutineContext.Element {
     companion object Key : CoroutineContext.Key<KotlinMultiplatformPluginLifecycleCoroutineContextElement>
 
@@ -285,7 +286,7 @@ private class KotlinMultiplatformPluginLifecycleCoroutineContextElement(
 }
 
 private class RestrictedLifecycleStages(
-    private val lifecycle: KotlinMultiplatformPluginLifecycle,
+    private val lifecycle: KotlinPluginLifecycle,
     private val allowedStages: Set<Stage>,
 ) : CoroutineContext.Element, ContinuationInterceptor {
     @OptIn(ExperimentalStdlibApi::class)

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

@@ -77,7 +77,7 @@ abstract class DefaultKotlinBasePlugin : KotlinBasePlugin {
 
         checkGradleCompatibility()
 
-        project.startKotlinMultiplatformPluginLifecycle()
+        project.startKotlinPluginLifecycle()
 
         project.gradle.projectsEvaluated {
             whenBuildEvaluated(project)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinMultiplatformPlugin.kt

@@ -172,7 +172,7 @@ class KotlinMultiplatformPlugin : Plugin<Project> {
         val production = sourceSets.create(KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME)
         val test = sourceSets.create(KotlinSourceSet.COMMON_TEST_SOURCE_SET_NAME)
         targets.all { target ->
-            project.launchInStage(KotlinMultiplatformPluginLifecycle.Stage.FinaliseRefinesEdges) {
+            project.launchInStage(KotlinPluginLifecycle.Stage.FinaliseRefinesEdges) {
                 /* Only setup default refines edges when no KotlinTargetHierarchy was applied */
                 if (project.multiplatformExtension.internalKotlinTargetHierarchy.appliedDescriptors.isNotEmpty()) return@launchInStage
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/targetHierarchy/applyKotlinTargetHierarchy.kt

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.gradle.plugin.mpp.targetHierarchy
 import org.gradle.api.DomainObjectCollection
 import org.gradle.api.NamedDomainObjectContainer
 import org.jetbrains.kotlin.gradle.plugin.*
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.Stage
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.Stage.Companion.upTo
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage.Companion.upTo
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal
 
 internal fun applyKotlinTargetHierarchy(
@@ -21,7 +21,7 @@ internal fun applyKotlinTargetHierarchy(
         .matching { target -> target.platformType != KotlinPlatformType.common }
         .all { target ->
             target.compilations.all forCompilation@{ compilation ->
-                target.project.kotlinMultiplatformPluginLifecycle.launch {
+                target.project.kotlinPluginLifecycle.launch {
                     withRestrictedStages(upTo(Stage.FinaliseRefinesEdges)) {
                         val hierarchy = hierarchyDescriptor.buildKotlinTargetHierarchy(compilation) ?: return@withRestrictedStages
                         applyKotlinTargetHierarchy(hierarchy, compilation, sourceSets)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/AbstractKotlinSourceSet.kt

@@ -8,9 +8,9 @@
 package org.jetbrains.kotlin.gradle.plugin.sources
 
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
-import org.jetbrains.kotlin.gradle.plugin.kotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.kotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.utils.MutableObservableSet
 import org.jetbrains.kotlin.gradle.utils.MutableObservableSetImpl
 import org.jetbrains.kotlin.gradle.utils.ObservableSet
@@ -34,8 +34,8 @@ abstract class AbstractKotlinSourceSet : InternalKotlinSourceSet {
     final override fun dependsOn(other: KotlinSourceSet) {
         if (other == this) return
 
-        assert(project.kotlinMultiplatformPluginLifecycle.stage <= KotlinMultiplatformPluginLifecycle.Stage.FinaliseRefinesEdges) {
+        assert(project.kotlinPluginLifecycle.stage <= KotlinPluginLifecycle.Stage.FinaliseRefinesEdges) {
-            "Illegal 'dependsOn' call in stage '${project.kotlinMultiplatformPluginLifecycle.stage}'"
+            "Illegal 'dependsOn' call in stage '${project.kotlinPluginLifecycle.stage}'"
         }
 
         /*

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/android/configurator/MultiplatformLayoutV2DependsOnConfigurator.kt

@@ -9,7 +9,7 @@ import com.android.build.gradle.api.AndroidSourceSet
 import com.android.build.gradle.api.BaseVariant
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.KotlinTargetHierarchy
 import org.jetbrains.kotlin.gradle.plugin.launchInStage
@@ -32,7 +32,7 @@ internal object MultiplatformLayoutV2DependsOnConfigurator : KotlinAndroidSource
     }
 
     private fun setDefaultDependsOn(target: KotlinAndroidTarget, kotlinSourceSet: KotlinSourceSet, variantType: AndroidVariantType) {
-        target.project.launchInStage(KotlinMultiplatformPluginLifecycle.Stage.FinaliseRefinesEdges) {
+        target.project.launchInStage(KotlinPluginLifecycle.Stage.FinaliseRefinesEdges) {
             /* Only setup default if not KotlinTargetHierarchy was applied */
             if (target.project.multiplatformExtensionOrNull?.internalKotlinTargetHierarchy?.appliedDescriptors.orEmpty().isNotEmpty()) {
                 return@launchInStage

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/android/KotlinAndroidTargetVariantTypeDsl.kt

@@ -9,9 +9,9 @@ import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.provider.Property
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.Stage.FinaliseDsl
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage.FinaliseDsl
 import org.jetbrains.kotlin.gradle.plugin.KotlinTargetHierarchy
-import org.jetbrains.kotlin.gradle.plugin.newLifecycleAwareProperty
+import org.jetbrains.kotlin.gradle.plugin.newKotlinPluginLifecycleAwareProperty
 
 @ExperimentalKotlinGradlePluginApi
 interface KotlinAndroidTargetVariantTypeDsl {
@@ -27,7 +27,7 @@ interface KotlinAndroidTargetVariantTypeDsl {
 
 internal class KotlinAndroidTargetVariantTypeDslImpl(private val project: Project) : KotlinAndroidTargetVariantTypeDsl {
     internal inner class TargetHierarchyDslImpl : KotlinAndroidTargetVariantTypeDsl.TargetHierarchyDsl {
-        override val module: Property<KotlinTargetHierarchy.ModuleName> by project.newLifecycleAwareProperty(FinaliseDsl)
+        override val module: Property<KotlinTargetHierarchy.ModuleName> by project.newKotlinPluginLifecycleAwareProperty(FinaliseDsl)
     }
 
     override val targetHierarchy: KotlinAndroidTargetVariantTypeDsl.TargetHierarchyDsl = TargetHierarchyDslImpl()

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/metadata/KotlinMetadataTargetConfigurator.kt

@@ -175,7 +175,7 @@ class KotlinMetadataTargetConfigurator :
     private fun createMetadataCompilationsForCommonSourceSets(
         target: KotlinMetadataTarget,
         allMetadataJar: TaskProvider<out Jar>
-    ) = target.project.launchInStage(KotlinMultiplatformPluginLifecycle.Stage.FinaliseCompilations) {
+    ) = target.project.launchInStage(KotlinPluginLifecycle.Stage.FinaliseCompilations) {
         // Do this after all targets are configured by the user build script
 
         val publishedCommonSourceSets: Set<KotlinSourceSet> = getCommonSourceSetsForMetadataCompilation(project)

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

@@ -9,10 +9,10 @@ package org.jetbrains.kotlin.gradle.unitTests
 
 import junit.framework.TestCase.assertNull
 import org.jetbrains.kotlin.gradle.plugin.*
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.plugin.awaitFinalValue
-import org.jetbrains.kotlin.gradle.plugin.currentMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.currentKotlinPluginLifecycle
-import org.jetbrains.kotlin.gradle.plugin.kotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.kotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.targets.android.KotlinAndroidTargetVariantTypeDslImpl
 import org.jetbrains.kotlin.gradle.util.buildProjectWithMPP
 import org.jetbrains.kotlin.gradle.util.runLifecycleAwareTest
@@ -27,7 +27,7 @@ class KotlinAndroidTargetVariantTypeDslImplTest {
 
     @Test
     fun `test -  module - not set`() = project.runLifecycleAwareTest {
-        project.kotlinMultiplatformPluginLifecycle.launch {
+        project.kotlinPluginLifecycle.launch {
             assertNull(dsl.targetHierarchy.module.orNull)
             assertNull(dsl.targetHierarchy.module.awaitFinalValue())
         }
@@ -38,16 +38,16 @@ class KotlinAndroidTargetVariantTypeDslImplTest {
         afterEvaluate { dsl.targetHierarchy.module.set(KotlinTargetHierarchy.ModuleName("x")) }
         dsl.targetHierarchy.module.set(KotlinTargetHierarchy.ModuleName("-set-before-after-evaluate-"))
         assertEquals("x", dsl.targetHierarchy.module.awaitFinalValue()?.name)
-        assertEquals(KotlinMultiplatformPluginLifecycle.Stage.FinaliseDsl, currentMultiplatformPluginLifecycle().stage)
+        assertEquals(KotlinPluginLifecycle.Stage.FinaliseDsl, currentKotlinPluginLifecycle().stage)
     }
 
     @Test
     fun `test - module - cannot be set after FinaliseDsl`() = project.runLifecycleAwareTest {
-        launchInStage(KotlinMultiplatformPluginLifecycle.Stage.BeforeFinaliseDsl) {
+        launchInStage(KotlinPluginLifecycle.Stage.BeforeFinaliseDsl) {
             dsl.targetHierarchy.module.set(KotlinTargetHierarchy.ModuleName("x"))
         }
 
-        launchInStage(KotlinMultiplatformPluginLifecycle.Stage.FinaliseDsl) {
+        launchInStage(KotlinPluginLifecycle.Stage.FinaliseDsl) {
             assertFails { dsl.targetHierarchy.module.set(KotlinTargetHierarchy.ModuleName("y")) }
         }
     }

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

@@ -9,9 +9,9 @@ package org.jetbrains.kotlin.gradle.unitTests
 
 import org.gradle.api.ProjectConfigurationException
 import org.jetbrains.kotlin.gradle.plugin.*
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.IllegalLifecycleException
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.IllegalLifecycleException
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.Stage
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.Stage.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage.*
 import org.jetbrains.kotlin.gradle.util.buildProjectWithMPP
 import org.jetbrains.kotlin.gradle.util.runLifecycleAwareTest
 import org.jetbrains.kotlin.tooling.core.withLinearClosure
@@ -20,10 +20,10 @@ import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.*
 
-class KotlinMultiplatformPluginLifecycleTest {
+class KotlinPluginLifecycleTest {
 
     private val project = buildProjectWithMPP()
-    private val lifecycle = project.kotlinMultiplatformPluginLifecycle
+    private val lifecycle = project.kotlinPluginLifecycle
 
     @Test
     fun `test - configure phase is executed right away`() {

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

@@ -8,11 +8,11 @@
 package org.jetbrains.kotlin.gradle.unitTests
 
 import org.jetbrains.kotlin.gradle.plugin.*
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.Stage.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage.*
 import org.jetbrains.kotlin.gradle.plugin.awaitFinalValue
-import org.jetbrains.kotlin.gradle.plugin.currentMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.currentKotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.plugin.launchInStage
-import org.jetbrains.kotlin.gradle.plugin.newLifecycleAwareProperty
+import org.jetbrains.kotlin.gradle.plugin.newKotlinPluginLifecycleAwareProperty
 import org.jetbrains.kotlin.gradle.util.buildProjectWithMPP
 import org.jetbrains.kotlin.gradle.util.runLifecycleAwareTest
 import org.jetbrains.kotlin.gradle.utils.newProperty
@@ -27,8 +27,8 @@ class LifecycleAwarePropertyTest {
 
     @Test
     fun `test - awaitFinalValue`() = project.runLifecycleAwareTest {
-        val property by project.newLifecycleAwareProperty<Int>(AfterFinaliseRefinesEdges)
+        val property by project.newKotlinPluginLifecycleAwareProperty<Int>(AfterFinaliseRefinesEdges)
-        assertTrue(property.isLifecycleAware())
+        assertTrue(property.isKotlinPluginLifecycleAware())
 
         launchInStage(BeforeFinaliseRefinesEdges) {
             property.set(1)
@@ -39,21 +39,21 @@ class LifecycleAwarePropertyTest {
             property.set(2)
         }
 
-        assertEquals(Configure, currentMultiplatformPluginLifecycle().stage)
+        assertEquals(Configure, currentKotlinPluginLifecycle().stage)
         assertEquals(2, property.awaitFinalValue())
-        assertEquals(AfterFinaliseRefinesEdges, currentMultiplatformPluginLifecycle().stage)
+        assertEquals(AfterFinaliseRefinesEdges, currentKotlinPluginLifecycle().stage)
     }
 
     @Test
     fun `test - awaitFinalValue - on non lifecycle aware property`() = project.runLifecycleAwareTest {
         val property = project.newProperty<String>()
-        assertFalse(property.isLifecycleAware())
+        assertFalse(property.isKotlinPluginLifecycleAware())
         assertFailsWith<IllegalArgumentException> { property.awaitFinalValue() }
     }
 
     @Test
     fun `test - changing value after finalized`() = project.runLifecycleAwareTest {
-        val property by project.newLifecycleAwareProperty<Int>(AfterEvaluate)
+        val property by project.newKotlinPluginLifecycleAwareProperty<Int>(AfterEvaluate)
         property.set(1)
 
         launchInStage(AfterEvaluate) {

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/sources/InternalKotlinSourceSetTest.kt

@@ -9,7 +9,7 @@ package org.jetbrains.kotlin.gradle.unitTests.sources
 
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.launchInStage
 import org.jetbrains.kotlin.gradle.plugin.mpp.getHostSpecificMainSharedSourceSets
@@ -70,7 +70,7 @@ class InternalKotlinSourceSetTest {
             nativeMain.internal.compilations
         )
 
-        project.launchInStage(KotlinMultiplatformPluginLifecycle.Stage.Finalised) {
+        project.launchInStage(KotlinPluginLifecycle.Stage.Finalised) {
             assertEquals<Set<KotlinCompilation<*>>>(
                 setOf(
                     metadataCompilation,

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

@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.gradle.util
 
 import org.gradle.api.Project
 import org.gradle.api.internal.project.ProjectInternal
-import org.jetbrains.kotlin.gradle.plugin.kotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.kotlinPluginLifecycle
 
 fun Project.runLifecycleAwareTest(block: suspend Project.() -> Unit) {
-    kotlinMultiplatformPluginLifecycle.launch { block() }
+    kotlinPluginLifecycle.launch { block() }
     (this as ProjectInternal).evaluate()
 }