Refactor kotlin multiplatform extension access

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinProjectExtension.kt

@@ -34,6 +34,12 @@ internal fun Project.createKotlinExtension(extensionClass: KClass<out KotlinProj
 internal val Project.kotlinExtension: KotlinProjectExtension
     get() = extensions.getByName(KOTLIN_PROJECT_EXTENSION_NAME) as KotlinProjectExtension
 
+internal val Project.multiplatformExtensionOrNull: KotlinMultiplatformExtension?
+    get() = extensions.findByName(KOTLIN_PROJECT_EXTENSION_NAME) as? KotlinMultiplatformExtension
+
+internal val Project.multiplatformExtension: KotlinMultiplatformExtension
+    get() = extensions.getByName(KOTLIN_PROJECT_EXTENSION_NAME) as KotlinMultiplatformExtension
+
 open class KotlinProjectExtension {
     val experimental: ExperimentalExtension
         get() = DslObject(this).extensions.getByType(ExperimentalExtension::class.java)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/AndroidSubplugin.kt

@@ -20,7 +20,6 @@ import com.android.build.gradle.BaseExtension
 import com.android.build.gradle.api.AndroidSourceSet
 import com.android.build.gradle.api.BaseVariant
 import com.android.build.gradle.api.TestVariant
-import com.android.build.gradle.internal.variant.BaseVariantData
 import com.android.build.gradle.internal.variant.TestVariantData
 import org.gradle.api.Plugin
 import org.gradle.api.Project
@@ -32,7 +31,7 @@ import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
 import org.jetbrains.kotlin.gradle.model.builder.KotlinAndroidExtensionModelBuilder
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.multiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.w3c.dom.Document
 import java.io.File
@@ -93,7 +92,7 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         if (project.plugins.findPlugin(AndroidExtensionsSubpluginIndicator::class.java) == null) {
             return false
         }
-        project.multiplatformExtension?.let { kotlin ->
+        project.multiplatformExtensionOrNull?.let { kotlin ->
             return kotlin.targets.any { target ->
                 target is KotlinAndroidTarget && target.compilations.any { it.compileKotlinTaskName == task.name }
             }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinJsDcePlugin.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinSingleJavaTargetExtension
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.multiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
 import org.jetbrains.kotlin.gradle.tasks.KotlinJsDce
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
@@ -30,7 +30,7 @@ import java.io.File
 
 class KotlinJsDcePlugin : Plugin<Project> {
     override fun apply(project: Project) {
-        val kotlinExtension = project.multiplatformExtension ?: run {
+        val kotlinExtension = project.multiplatformExtensionOrNull ?: run {
             project.pluginManager.apply(Kotlin2JsPluginWrapper::class.java)
             project.kotlinExtension as KotlinSingleJavaTargetExtension
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/cocoapods/KotlinCocoapodsPlugin.kt

@@ -9,7 +9,7 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.tasks.Sync
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.addExtension
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
@@ -143,12 +143,7 @@ open class KotlinCocoapodsPlugin: Plugin<Project> {
 
     override fun apply(project: Project): Unit = with(project) {
         pluginManager.withPlugin("kotlin-multiplatform") {
-            val kotlinExtension = project.kotlinExtension as? KotlinMultiplatformExtension
+            val kotlinExtension = project.multiplatformExtension
-            if (kotlinExtension == null) {
-                logger.info("Cannot apply cocoapods plugin: Cannot cast ${project.kotlinExtension} to KotlinMultiplatformExtension")
-                return@withPlugin
-            }
-
             val cocoapodsExtension = CocoapodsExtension(this)
 
             kotlinExtension.addExtension(EXTENSION_NAME, cocoapodsExtension)

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

@@ -23,9 +23,7 @@ import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.internal.reflect.Instantiator
 import org.gradle.jvm.tasks.Jar
 import org.gradle.util.ConfigureUtil
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.configureOrCreate
-import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.sources.DefaultLanguageSettingsBuilder
 import org.jetbrains.kotlin.gradle.utils.SingleWarningPerBuild
@@ -34,10 +32,6 @@ import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.konan.target.HostManager
 import org.jetbrains.kotlin.konan.target.presetName
 
-internal val Project.multiplatformExtension
-    get(): KotlinMultiplatformExtension? =
-        project.extensions.findByName("kotlin") as? KotlinMultiplatformExtension
-
 class KotlinMultiplatformPlugin(
     private val fileResolver: FileResolver,
     private val instantiator: Instantiator,
@@ -102,7 +96,7 @@ class KotlinMultiplatformPlugin(
     private fun setupCompilerPluginOptions(project: Project) {
         // common source sets use the compiler options from the metadata compilation:
         val metadataCompilation =
-            project.multiplatformExtension!!.targets
+            project.multiplatformExtension.targets
                 .getByName(METADATA_TARGET_NAME)
                 .compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
 
@@ -137,7 +131,7 @@ class KotlinMultiplatformPlugin(
     }
 
     fun setupDefaultPresets(project: Project) {
-        with((project.kotlinExtension as KotlinMultiplatformExtension).presets) {
+        with(project.multiplatformExtension.presets) {
             add(KotlinJvmTargetPreset(project, instantiator, fileResolver, kotlinPluginVersion))
             add(KotlinJsTargetPreset(project, instantiator, fileResolver, kotlinPluginVersion))
             add(KotlinAndroidTargetPreset(project, kotlinPluginVersion))
@@ -150,15 +144,15 @@ class KotlinMultiplatformPlugin(
 
     private fun configurePublishingWithMavenPublish(project: Project) = project.pluginManager.withPlugin("maven-publish") { _ ->
 
-        if (project.multiplatformExtension!!.run { isGradleMetadataAvailable && isGradleMetadataExperimental }) {
+        if (project.multiplatformExtension.run { isGradleMetadataAvailable && isGradleMetadataExperimental }) {
             SingleWarningPerBuild.show(
                 project,
                 GRADLE_METADATA_WARNING
             )
         }
 
-        val targets = project.multiplatformExtension!!.targets
+        val targets = project.multiplatformExtension.targets
-        val kotlinSoftwareComponent = project.multiplatformExtension!!.rootSoftwareComponent
+        val kotlinSoftwareComponent = project.multiplatformExtension.rootSoftwareComponent
 
         project.extensions.configure(PublishingExtension::class.java) { publishing ->
 
@@ -171,7 +165,7 @@ class KotlinMultiplatformPlugin(
 
             // Publish the root publication only if Gradle metadata publishing is enabled:
             project.tasks.withType(AbstractPublishToMaven::class.java).all { publishTask ->
-                publishTask.onlyIf { publishTask.publication != rootPublication || project.multiplatformExtension!!.isGradleMetadataAvailable }
+                publishTask.onlyIf { publishTask.publication != rootPublication || project.multiplatformExtension.isGradleMetadataAvailable }
             }
 
             // Enforce the order of creating the publications, since the metadata publication is used in the other publications:
@@ -216,7 +210,7 @@ class KotlinMultiplatformPlugin(
             }
     }
 
-    private fun configureSourceSets(project: Project) = with(project.kotlinExtension as KotlinMultiplatformExtension) {
+    private fun configureSourceSets(project: Project) = with(project.multiplatformExtension) {
         val production = sourceSets.create(KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME)
         val test = sourceSets.create(KotlinSourceSet.COMMON_TEST_SOURCE_SET_NAME)
 
@@ -232,7 +226,7 @@ class KotlinMultiplatformPlugin(
     }
 
     private fun setUpConfigurationAttributes(project: Project) {
-        val targets = (project.kotlinExtension as KotlinMultiplatformExtension).targets
+        val targets = project.multiplatformExtension.targets
 
         project.afterEvaluate {
             targets.all { target ->
@@ -306,7 +300,7 @@ internal fun sourcesJarTask(compilation: KotlinCompilation<*>, componentName: St
 
 internal fun compilationsBySourceSet(project: Project): Map<KotlinSourceSet, Set<KotlinCompilation<*>>> =
     HashMap<KotlinSourceSet, MutableSet<KotlinCompilation<*>>>().also { result ->
-        for (target in project.multiplatformExtension!!.targets) {
+        for (target in project.multiplatformExtension.targets) {
             for (compilation in target.compilations) {
                 for (sourceSet in compilation.allKotlinSourceSets) {
                     result.getOrPut(sourceSet) { mutableSetOf() }.add(compilation)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinCompilations.kt

@@ -207,7 +207,7 @@ private object CompilationSourceSetUtil {
         projectSourceSetsInMultipleCompilationsCache.computeIfAbsent(project) { _ ->
             check(project.state.executed) { "Should only be computed after the project is evaluated" }
 
-            val compilations = (project.kotlinExtension as? KotlinMultiplatformExtension)?.targets?.flatMap { it.compilations }
+            val compilations = project.multiplatformExtensionOrNull?.targets?.flatMap { it.compilations }
                 ?: return@computeIfAbsent null
 
             val sources = compilations

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/mppDependencyRewritingUtils.kt

@@ -14,6 +14,7 @@ import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.attributes.Usage
 import org.gradle.api.internal.component.SoftwareComponentInternal
 import org.gradle.api.internal.component.UsageContext
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationToRunnableFiles
 import org.jetbrains.kotlin.gradle.plugin.KotlinTargetComponent
 
@@ -115,7 +116,7 @@ private fun associateDependenciesWithActualModuleDependencies(
             when (dependency) {
                 is ProjectDependency -> {
                     val dependencyProject = dependency.dependencyProject
-                    val dependencyProjectKotlinExtension = dependencyProject.multiplatformExtension
+                    val dependencyProjectKotlinExtension = dependencyProject.multiplatformExtensionOrNull
                         ?: return@associate dependency to dependency
 
                     val resolved = resolvedDependencies[Triple(dependency.group, dependency.name, dependency.version)]