[Gradle] Promote KotlinMultiplatformPluginLifecycle to KotlinPluginLifecycle

KT-34662
2023-03-09 13:02:10 +01:00
parent 098cfae957
commit 656ce4aead
13 changed files with 75 additions and 74 deletions
@@ -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) {
-    kotlinMultiplatformPluginLifecycle.launch(block)
+internal fun Project.launch(block: suspend KotlinPluginLifecycle.() -> Unit) {
+    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
-    get() = extraProperties.getOrPut(KotlinMultiplatformPluginLifecycle::class.java.name) {
-        KotlinMultiplatformPluginLifecycleImpl(project)
+internal val Project.kotlinPluginLifecycle: KotlinPluginLifecycle
+    get() = extraProperties.getOrPut(KotlinPluginLifecycle::class.java.name) {
+        KotlinPluginLifecycleImpl(project)
    }

-internal fun Project.startKotlinMultiplatformPluginLifecycle() {
-    (kotlinMultiplatformPluginLifecycle as KotlinMultiplatformPluginLifecycleImpl).start()
+internal fun Project.startKotlinPluginLifecycle() {
+    (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>? {
-    return (currentMultiplatformPluginLifecycle() as KotlinMultiplatformPluginLifecycleImpl).findLifecycleAwareProperty(this)
+internal suspend fun <T : Any> Property<T>.findKotlinPluginLifecycleAwareProperty(): LifecycleAwareProperty<T>? {
+    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 {
-    return findLifecycleAwareProperty() != null
+internal suspend fun Property<*>.isKotlinPluginLifecycleAware(): Boolean {
+    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(!isFinished.get()) { "Cannot launch when ${KotlinMultiplatformPluginLifecycle::class.simpleName} is already finished" }
+        check(isStarted.get()) { "Cannot launch when ${KotlinPluginLifecycle::class.simpleName} is not started" }
+        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)
@@ -77,7 +77,7 @@ abstract class DefaultKotlinBasePlugin : KotlinBasePlugin {

        checkGradleCompatibility()

-        project.startKotlinMultiplatformPluginLifecycle()
+        project.startKotlinPluginLifecycle()

        project.gradle.projectsEvaluated {
            whenBuildEvaluated(project)
@@ -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

@@ -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.KotlinMultiplatformPluginLifecycle.Stage.Companion.upTo
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage
+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)
@@ -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) {
-            "Illegal 'dependsOn' call in stage '${project.kotlinMultiplatformPluginLifecycle.stage}'"
+        assert(project.kotlinPluginLifecycle.stage <= KotlinPluginLifecycle.Stage.FinaliseRefinesEdges) {
+            "Illegal 'dependsOn' call in stage '${project.kotlinPluginLifecycle.stage}'"
        }

        /*
@@ -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
@@ -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()
@@ -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)
@@ -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.kotlinMultiplatformPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.currentKotlinPluginLifecycle
+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")) }
        }
    }
@@ -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.KotlinMultiplatformPluginLifecycle.Stage
-import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginLifecycle.Stage.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.IllegalLifecycleException
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.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`() {
@@ -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)
-        assertTrue(property.isLifecycleAware())
+        val property by project.newKotlinPluginLifecycleAwareProperty<Int>(AfterFinaliseRefinesEdges)
+        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) {
@@ -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,
@@ -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()
 }