Update KotlinCompilation hierarchy to use compiler options

^KT-27301 In Progress

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

@@ -344,7 +344,7 @@ internal open class GradleCompilerRunner(
                         )
                         val jarTask = project.tasks.findByName(target.artifactsTaskName) as? AbstractArchiveTask ?: continue
                         jarToModule[jarTask.archivePathCompatible.canonicalFile] = module
-                        if (target is KotlinWithJavaTarget<*>) {
+                        if (target is KotlinWithJavaTarget<*, *>) {
                             val jar = project.tasks.getByName(target.artifactsTaskName) as Jar
                             jarToClassListFile[jar.archivePathCompatible.canonicalFile] = target.defaultArtifactClassesListFile.get()
                             //configure abiSnapshot mapping for jars

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

@@ -161,30 +161,30 @@ abstract class KotlinSingleTargetExtension<TARGET : KotlinTarget>(project: Proje
     fun target(body: Action<TARGET>) = body.execute(target)
 }
 
-abstract class KotlinSingleJavaTargetExtension(project: Project) : KotlinSingleTargetExtension<KotlinWithJavaTarget<*>>(project)
+abstract class KotlinSingleJavaTargetExtension(project: Project) : KotlinSingleTargetExtension<KotlinWithJavaTarget<*, *>>(project)
 
 abstract class KotlinJvmProjectExtension(project: Project) : KotlinSingleJavaTargetExtension(project) {
-    override lateinit var target: KotlinWithJavaTarget<KotlinJvmOptions>
+    override lateinit var target: KotlinWithJavaTarget<KotlinJvmOptions, CompilerJvmOptions>
         internal set
 
-    open fun target(body: KotlinWithJavaTarget<KotlinJvmOptions>.() -> Unit) = target.run(body)
+    open fun target(body: KotlinWithJavaTarget<KotlinJvmOptions, CompilerJvmOptions>.() -> Unit) = target.run(body)
 }
 
 abstract class Kotlin2JsProjectExtension(project: Project) : KotlinSingleJavaTargetExtension(project) {
-    private lateinit var _target: KotlinWithJavaTarget<KotlinJsOptions>
+    private lateinit var _target: KotlinWithJavaTarget<KotlinJsOptions, CompilerJsOptions>
 
-    override val target: KotlinWithJavaTarget<KotlinJsOptions>
+    override val target: KotlinWithJavaTarget<KotlinJsOptions, CompilerJsOptions>
         get() {
             if (!::_target.isInitialized) throw IllegalStateException("Extension target is not initialized!")
 
             return _target
         }
 
-    internal fun setTarget(target: KotlinWithJavaTarget<KotlinJsOptions>) {
+    internal fun setTarget(target: KotlinWithJavaTarget<KotlinJsOptions, CompilerJsOptions>) {
         _target = target
     }
 
-    open fun target(body: KotlinWithJavaTarget<KotlinJsOptions>.() -> Unit) = target.run(body)
+    open fun target(body: KotlinWithJavaTarget<KotlinJsOptions, CompilerJsOptions>.() -> Unit) = target.run(body)
 }
 
 abstract class KotlinJsProjectExtension(project: Project) :
@@ -367,10 +367,12 @@ abstract class KotlinJsProjectExtension(project: Project) :
 }
 
 abstract class KotlinCommonProjectExtension(project: Project) : KotlinSingleJavaTargetExtension(project) {
-    override lateinit var target: KotlinWithJavaTarget<KotlinMultiplatformCommonOptions>
+    override lateinit var target: KotlinWithJavaTarget<KotlinMultiplatformCommonOptions, CompilerMultiplatformCommonOptions>
         internal set
 
-    open fun target(body: KotlinWithJavaTarget<KotlinMultiplatformCommonOptions>.() -> Unit) = target.run(body)
+    open fun target(
+        body: KotlinWithJavaTarget<KotlinMultiplatformCommonOptions, CompilerMultiplatformCommonOptions>.() -> Unit
+    ) = target.run(body)
 }
 
 abstract class KotlinAndroidProjectExtension(project: Project) : KotlinSingleTargetExtension<KotlinAndroidTarget>(project) {

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

@@ -85,7 +85,7 @@ private fun KotlinTarget.excludeStdlibAndKotlinTestCommonFromPlatformCompilation
             (it as? KotlinCompilationToRunnableFiles<*>)?.runtimeDependencyConfigurationName,
 
             // Additional configurations for (old) jvmWithJava-preset. Remove it when we drop it completely
-            (it as? KotlinWithJavaCompilation<*>)?.apiConfigurationName
+            (it as? KotlinWithJavaCompilation<*, *>)?.apiConfigurationName
         ).forEach { configurationName ->
             project.configurations.getByName(configurationName).apply {
                 exclude(mapOf("group" to "org.jetbrains.kotlin", "module" to "kotlin-stdlib-common"))

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

@@ -159,7 +159,7 @@ private fun KotlinCompilation<*>.kotlinTestCapabilityForJvmSourceSet(
             .matching { it is KotlinTaskTestRun<*, *> }
             .mapNotNull { (it as KotlinTaskTestRun<*, *>).executionTask }
 
-        compilationTarget is KotlinWithJavaTarget<*> &&
+        compilationTarget is KotlinWithJavaTarget<*, *> &&
                 name == KotlinCompilation.TEST_COMPILATION_NAME ->
             listOfNotNull(tasks.locateTask(compilationTarget.testTaskName))
 

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

@@ -92,7 +92,7 @@ internal abstract class KotlinSourceSetProcessor<T : AbstractKotlinCompile<*>>(
     protected val javaSourceSet: SourceSet?
         get() {
             val compilation = kotlinCompilation
-            return (compilation as? KotlinWithJavaCompilation<*>)?.javaSourceSet
+            return (compilation as? KotlinWithJavaCompilation<*, *>)?.javaSourceSet
                 ?: kotlinCompilation.owner.let {
                     if (it is KotlinJvmTarget && it.withJavaEnabled && compilation is KotlinJvmCompilation)
                         project.gradle.variantImplementationFactory<JavaSourceSetsAccessor.JavaSourceSetsAccessorVariantFactory>()
@@ -112,7 +112,7 @@ internal abstract class KotlinSourceSetProcessor<T : AbstractKotlinCompile<*>>(
         addKotlinDirectoriesToJavaSourceSet()
         doTargetSpecificProcessing()
 
-        if (kotlinCompilation is KotlinWithJavaCompilation<*>) {
+        if (kotlinCompilation is KotlinWithJavaCompilation<*, *>) {
             createAdditionalClassesTaskForIdeRunner()
         }
     }
@@ -238,7 +238,7 @@ internal class Kotlin2JsSourceSetProcessor(
             it.dependsOn(kotlinTask)
         }
 
-        if (kotlinCompilation is KotlinWithJavaCompilation<*>) {
+        if (kotlinCompilation is KotlinWithJavaCompilation<*, *>) {
             kotlinCompilation.javaSourceSet.clearJavaSrcDirs()
         }
 
@@ -471,7 +471,7 @@ internal abstract class AbstractKotlinPlugin(
         }
 
         fun configureTarget(
-            target: KotlinWithJavaTarget<*>,
+            target: KotlinWithJavaTarget<*, *>,
             buildSourceSetProcessor: (AbstractKotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
         ) {
             setUpJavaSourceSets(target)
@@ -501,7 +501,7 @@ internal abstract class AbstractKotlinPlugin(
             javaSourceSets.all { javaSourceSet ->
                 val kotlinCompilation =
                     compilationsUnderConstruction[javaSourceSet.name] ?: kotlinTarget.compilations.maybeCreate(javaSourceSet.name)
-                (kotlinCompilation as? KotlinWithJavaCompilation<*>)?.javaSourceSet = javaSourceSet
+                (kotlinCompilation as? KotlinWithJavaCompilation<*, *>)?.javaSourceSet = javaSourceSet
 
                 if (duplicateJavaSourceSetsAsKotlinSourceSets) {
                     val kotlinSourceSet = project.kotlinExtension.sourceSets.maybeCreate(kotlinCompilation.name)
@@ -520,7 +520,7 @@ internal abstract class AbstractKotlinPlugin(
             kotlinTarget.compilations.all { kotlinCompilation ->
                 val sourceSetName = kotlinCompilation.name
                 compilationsUnderConstruction[sourceSetName] = kotlinCompilation
-                (kotlinCompilation as? KotlinWithJavaCompilation<*>)?.javaSourceSet = javaSourceSets.maybeCreate(sourceSetName)
+                (kotlinCompilation as? KotlinWithJavaCompilation<*, *>)?.javaSourceSet = javaSourceSets.maybeCreate(sourceSetName)
 
                 // Another Kotlin source set following the other convention, named according to the compilation, not the Java source set:
                 val kotlinSourceSet = project.kotlinExtension.sourceSets.maybeCreate(kotlinCompilation.defaultSourceSetName)
@@ -545,7 +545,7 @@ internal abstract class AbstractKotlinPlugin(
         }
 
         private fun configureAttributes(
-            kotlinTarget: KotlinWithJavaTarget<*>
+            kotlinTarget: KotlinWithJavaTarget<*, *>
         ) {
             val project = kotlinTarget.project
 
@@ -571,7 +571,7 @@ internal abstract class AbstractKotlinPlugin(
         }
 
         private fun configureSourceSetDefaults(
-            kotlinTarget: KotlinWithJavaTarget<*>,
+            kotlinTarget: KotlinWithJavaTarget<*, *>,
             buildSourceSetProcessor: (AbstractKotlinCompilation<*>) -> KotlinSourceSetProcessor<*>
         ) {
             kotlinTarget.compilations.all { compilation ->
@@ -600,8 +600,18 @@ internal open class KotlinPlugin(
             project,
             KotlinPlatformType.jvm,
             targetName,
-            { KotlinJvmOptionsImpl() }
-        ) as KotlinWithJavaTarget<KotlinJvmOptions>)
+            {
+                object : HasCompilerOptions<CompilerJvmOptions> {
+                    override val options: CompilerJvmOptions =
+                        project.objects.newInstance(CompilerJvmOptionsDefault::class.java)
+                }
+            },
+            { compilerOptions: CompilerJvmOptions ->
+                object : KotlinJvmOptions {
+                    override val options: CompilerJvmOptions get() = compilerOptions
+                }
+            }
+        ) as KotlinWithJavaTarget<KotlinJvmOptions, CompilerJvmOptions>)
             .apply {
                 disambiguationClassifier = null // don't add anything to the task names
             }
@@ -642,8 +652,19 @@ internal open class KotlinCommonPlugin(
             project,
             KotlinPlatformType.common,
             targetName,
-            { KotlinMultiplatformCommonOptionsImpl() }
-        ) as KotlinWithJavaTarget<KotlinMultiplatformCommonOptions>
+            {
+                object : HasCompilerOptions<CompilerMultiplatformCommonOptions> {
+                    override val options: CompilerMultiplatformCommonOptions =
+                        project.objects.newInstance(CompilerMultiplatformCommonOptionsDefault::class.java)
+                }
+            },
+            { compilerOptions: CompilerMultiplatformCommonOptions ->
+                object : KotlinMultiplatformCommonOptions {
+                    override val options: CompilerMultiplatformCommonOptions
+                        get() = compilerOptions
+                }
+            }
+        ) as KotlinWithJavaTarget<KotlinMultiplatformCommonOptions, CompilerMultiplatformCommonOptions>
         (project.kotlinExtension as KotlinCommonProjectExtension).target = target
 
         super.apply(project)
@@ -675,8 +696,19 @@ internal open class Kotlin2JsPlugin(
             project,
             KotlinPlatformType.js,
             targetName,
-            { KotlinJsOptionsImpl() }
-        ) as KotlinWithJavaTarget<KotlinJsOptions>
+            {
+                object : HasCompilerOptions<CompilerJsOptions> {
+                    override val options: CompilerJsOptions =
+                        project.objects.newInstance(CompilerJsOptionsDefault::class.java)
+                }
+            },
+            { compilerOptions: CompilerJsOptions ->
+                object : KotlinJsOptions {
+                    override val options: CompilerJsOptions
+                        get() = compilerOptions
+                }
+            }
+        ) as KotlinWithJavaTarget<KotlinJsOptions, CompilerJsOptions>
 
         (project.kotlinExtension as Kotlin2JsProjectExtension).setTarget(target)
         super.apply(project)

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

@@ -45,7 +45,7 @@ internal fun Configuration.setupAsLocalTargetSpecificConfigurationIfSupported(ta
     // don't setup in old MPP common modules, as their output configurations with KotlinPlatformType attribute would
     // fail to resolve as transitive dependencies of the platform modules, just as we don't mark their
     // `api/RuntimeElements` with the KotlinPlatformType
-    if ((target !is KotlinWithJavaTarget<*> || target.platformType != KotlinPlatformType.common)) {
+    if ((target !is KotlinWithJavaTarget<*, *> || target.platformType != KotlinPlatformType.common)) {
         usesPlatformOf(target)
     }
 }

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

@@ -111,7 +111,7 @@ internal fun addCompilationSourcesToExternalCompileTask(
 internal fun findJavaTaskForKotlinCompilation(compilation: KotlinCompilation<*>): TaskProvider<out JavaCompile>? =
     when (compilation) {
         is KotlinJvmAndroidCompilation -> compilation.compileJavaTaskProvider
-        is KotlinWithJavaCompilation -> compilation.compileJavaTaskProvider
+        is KotlinWithJavaCompilation<*, *> -> compilation.compileJavaTaskProvider
         is KotlinJvmCompilation -> compilation.compileJavaTaskProvider // may be null for Kotlin-only JVM target in MPP
         else -> null
     }

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinCompilationData
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
 import org.jetbrains.kotlin.gradle.tasks.locateTask
 import org.jetbrains.kotlin.gradle.utils.ObservableSet
 import org.jetbrains.kotlin.project.model.LanguageSettings
@@ -48,6 +49,12 @@ abstract class AbstractKotlinCompilation<T : KotlinCommonOptions>(
     final override val platformType: KotlinPlatformType get() = compilationData.platformType
     final override val output: KotlinCompilationOutput get() = compilationData.output
     final override val compileKotlinTaskName: String get() = compilationData.compileKotlinTaskName
+
+    override val compilerOptions: HasCompilerOptions<*>
+        get() = compilationData.compilerOptions
+
+    @Suppress("DEPRECATION")
+    @Deprecated("Replaced by compilerOptions", replaceWith = ReplaceWith("compilerOptions.options"))
     final override val kotlinOptions: T get() = compilationData.kotlinOptions
     final override val kotlinSourceDirectoriesByFragmentName get() = compilationData.kotlinSourceDirectoriesByFragmentName
     //endregion
@@ -73,17 +80,24 @@ abstract class AbstractKotlinCompilation<T : KotlinCommonOptions>(
 
     final override val compilationName: String get() = compilationDetails.compilationData.compilationPurpose
 
+    @Suppress("DEPRECATION")
+    @Deprecated("Replaced by compilerOptions.configure { }", replaceWith = ReplaceWith("compilerOptions.configure(configure)"))
     override fun kotlinOptions(configure: T.() -> Unit) =
         configure(kotlinOptions)
 
-    @Suppress("UNCHECKED_CAST")
+    @Suppress("DEPRECATION")
+    @Deprecated("Accessing task instance directly is deprecated", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTask: KotlinCompile<T>
         get() = compileKotlinTaskProvider.get()
 
-    @Suppress("UNCHECKED_CAST")
+    @Suppress("DEPRECATION")
+    @Deprecated("Replaced with compileTaskProvider", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTaskProvider: TaskProvider<out KotlinCompile<T>>
         get() = target.project.locateTask(compileKotlinTaskName) ?: throw GradleException("Couldn't locate  task $compileKotlinTaskName")
 
+    override val compileTaskProvider: TaskProvider<out KotlinCompilationTask<*>>
+        get() = target.project.locateTask(compileKotlinTaskName) ?: throw GradleException("Couldn't locate task $compileKotlinTaskName")
+
     private val attributeContainer by lazy { HierarchyAttributeContainer(target.attributes) }
 
     override fun getAttributes(): AttributeContainer = attributeContainer

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

@@ -485,8 +485,9 @@ internal class WithJavaCompilationDetails<T : KotlinCommonOptions, CO : Compiler
     createCompilerOptions: DefaultCompilationDetails<T, CO>.() -> HasCompilerOptions<CO>,
     createKotlinOptions: DefaultCompilationDetails<T, CO>.() -> T
 ) : DefaultCompilationDetailsWithRuntime<T, CO>(target, compilationPurpose, defaultSourceSet, createCompilerOptions, createKotlinOptions) {
-    override val compilation: KotlinWithJavaCompilation<T>
-        get() = super.compilation as KotlinWithJavaCompilation<T>
+    @Suppress("UNCHECKED_CAST")
+    override val compilation: KotlinWithJavaCompilation<T, CO>
+        get() = super.compilation as KotlinWithJavaCompilation<T, CO>
 
     val javaSourceSet: SourceSet
         get() = compilation.javaSourceSet

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

@@ -5,10 +5,13 @@
 
 package org.jetbrains.kotlin.gradle.plugin.mpp
 
+import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.dsl.CompilerMultiplatformCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon
 import javax.inject.Inject
 
@@ -22,9 +25,15 @@ abstract class KotlinCommonCompilation @Inject constructor(
     override fun getName() =
         if (compilationDetails is MetadataMappedCompilationDetails) defaultSourceSetName else super.compilationPurpose
 
+    @Suppress("DEPRECATION")
+    @Deprecated("Accessing task instance directly is deprecated", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTask: KotlinCompileCommon
         get() = super.compileKotlinTask as KotlinCompileCommon
 
+    @Suppress("UNCHECKED_CAST")
+    override val compileTaskProvider: TaskProvider<KotlinCompilationTask<CompilerMultiplatformCommonOptions>>
+        get() = super.compileTaskProvider as TaskProvider<KotlinCompilationTask<CompilerMultiplatformCommonOptions>>
+
     internal val isKlibCompilation: Boolean
         get() = target.project.isKotlinGranularMetadataEnabled && !forceCompilationToKotlinMetadata
 

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

@@ -7,11 +7,9 @@ package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
-import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptionsDefault
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
-import org.jetbrains.kotlin.gradle.plugin.runOnceAfterEvaluated
-import org.jetbrains.kotlin.gradle.plugin.sources.applyLanguageSettingsToCompilerOptions
+import org.jetbrains.kotlin.gradle.targets.native.NativeCompilerOptions
 import org.jetbrains.kotlin.konan.target.KonanTarget
 
 internal class GradleKpmNativeVariantCompilationData(
@@ -29,17 +27,10 @@ internal class GradleKpmNativeVariantCompilationData(
     override val owner: GradleKpmNativeVariant
         get() = variant
 
-    override val compilerOptions: HasCompilerOptions<CompilerCommonOptions> =
-        object : HasCompilerOptions<CompilerCommonOptions> {
-            override val options: CompilerCommonOptions =
-                project.objects.newInstance(CompilerCommonOptionsDefault::class.java)
-                    .apply {
-                        useK2.finalizeValue()
-                        project.runOnceAfterEvaluated("apply Kotlin native properties from language settings") {
-                            applyLanguageSettingsToCompilerOptions(variant.languageSettings, this)
-                        }
-                    }
-        }
+    override val compilerOptions: HasCompilerOptions<CompilerCommonOptions> = NativeCompilerOptions(
+        project,
+        variant.languageSettings
+    )
 
     @Suppress("DEPRECATION")
     @Deprecated("Replaced with compilerOptions.options", replaceWith = ReplaceWith("compilerOptions.options"))

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

@@ -15,9 +15,9 @@ import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.archivesName
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.disambiguateName
-import org.jetbrains.kotlin.gradle.plugin.sources.applyLanguageSettingsToCompilerOptions
 import org.jetbrains.kotlin.gradle.targets.metadata.ResolvedMetadataFilesProvider
 import org.jetbrains.kotlin.gradle.targets.metadata.createMetadataDependencyTransformationClasspath
+import org.jetbrains.kotlin.gradle.targets.native.NativeCompilerOptions
 import org.jetbrains.kotlin.gradle.utils.getValue
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.gradle.utils.newProperty
@@ -177,17 +177,10 @@ internal open class KotlinNativeFragmentMetadataCompilationDataImpl(
     override val isActive: Boolean
         get() = fragment.isNativeShared() && fragment.containingVariants.count() > 1
 
-    override val compilerOptions: HasCompilerOptions<CompilerCommonOptions> =
-        object : HasCompilerOptions<CompilerCommonOptions> {
-            override val options: CompilerCommonOptions =
-                project.objects.newInstance(CompilerCommonOptionsDefault::class.java)
-                    .apply {
-                        useK2.finalizeValue()
-                        project.runOnceAfterEvaluated("apply Kotlin native properties from language settings") {
-                            applyLanguageSettingsToCompilerOptions(languageSettings, this)
-                        }
-                    }
-        }
+    override val compilerOptions: HasCompilerOptions<CompilerCommonOptions> = NativeCompilerOptions(
+        project,
+        languageSettings
+    )
 
     @Suppress("DEPRECATION")
     @Deprecated("Replaced with compilerOptions.options", replaceWith = ReplaceWith("compilerOptions.options"))

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

@@ -10,7 +10,9 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 
 import groovy.lang.Closure
 import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.dsl.CompilerJsOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptions
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
 import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
@@ -20,6 +22,7 @@ import org.jetbrains.kotlin.gradle.targets.js.ir.JsBinary
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsBinaryContainer
 import org.jetbrains.kotlin.gradle.targets.js.npm.PackageJson
 import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
 import javax.inject.Inject
 
 abstract class KotlinJsCompilation @Inject internal constructor(
@@ -29,6 +32,10 @@ abstract class KotlinJsCompilation @Inject internal constructor(
 
     final override val target: KotlinTarget get() = super.target
 
+    @Suppress("UNCHECKED_CAST")
+    final override val compilerOptions: HasCompilerOptions<CompilerJsOptions>
+        get() = super.compilerOptions as HasCompilerOptions<CompilerJsOptions>
+
     private val kotlinProperties = PropertiesProvider(target.project)
 
     internal open val externalsOutputFormat: ExternalsOutputFormat
@@ -57,13 +64,20 @@ abstract class KotlinJsCompilation @Inject internal constructor(
     override val processResourcesTaskName: String
         get() = disambiguateName("processResources")
 
+    @Suppress("DEPRECATION")
+    @Deprecated("Accessing task instance directly is deprecated", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTask: Kotlin2JsCompile
         get() = super.compileKotlinTask as Kotlin2JsCompile
 
-    @Suppress("UNCHECKED_CAST")
+    @Suppress("UNCHECKED_CAST", "DEPRECATION")
+    @Deprecated("Replaced with compileTaskProvider", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTaskProvider: TaskProvider<out Kotlin2JsCompile>
         get() = super.compileKotlinTaskProvider as TaskProvider<out Kotlin2JsCompile>
 
+    @Suppress("UNCHECKED_CAST")
+    override val compileTaskProvider: TaskProvider<Kotlin2JsCompile>
+        get() = super.compileTaskProvider as TaskProvider<Kotlin2JsCompile>
+
     internal val packageJsonHandlers = mutableListOf<PackageJson.() -> Unit>()
 
     fun packageJson(handler: PackageJson.() -> Unit) {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinJvmAndroidCompilation.kt

@@ -11,8 +11,10 @@ import org.gradle.api.file.FileCollection
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.compile.JavaCompile
+import org.jetbrains.kotlin.gradle.dsl.CompilerJvmOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
 import org.jetbrains.kotlin.gradle.plugin.getJavaTaskProvider
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
 import javax.inject.Inject
 
 abstract class KotlinJvmAndroidCompilation @Inject constructor(
@@ -24,13 +26,20 @@ abstract class KotlinJvmAndroidCompilation @Inject constructor(
     internal val testedVariantArtifacts: Property<FileCollection> =
         compilationDetails.target.project.objects.property(FileCollection::class.java)
 
+    @Suppress("DEPRECATION")
+    @Deprecated("Accessing task instance directly is deprecated", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTask: org.jetbrains.kotlin.gradle.tasks.KotlinCompile
         get() = super.compileKotlinTask as org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
-    @Suppress("UNCHECKED_CAST")
+    @Suppress("UNCHECKED_CAST", "DEPRECATION")
+    @Deprecated("Replaced with compileTaskProvider", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTaskProvider: TaskProvider<out org.jetbrains.kotlin.gradle.tasks.KotlinCompile>
         get() = super.compileKotlinTaskProvider as TaskProvider<out org.jetbrains.kotlin.gradle.tasks.KotlinCompile>
 
+    @Suppress("UNCHECKED_CAST")
+    override val compileTaskProvider: TaskProvider<out KotlinCompilationTask<CompilerJvmOptions>>
+        get() = super.compileTaskProvider as TaskProvider<KotlinCompilationTask<CompilerJvmOptions>>
+
     val compileJavaTaskProvider: TaskProvider<out JavaCompile>
         get() = androidVariant.getJavaTaskProvider()
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinJvmCompilation.kt

@@ -8,28 +8,43 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.dsl.CompilerJvmOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
 import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.variantImplementationFactory
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
 import javax.inject.Inject
 
 abstract class KotlinJvmCompilation @Inject constructor(
     compilationDetails: CompilationDetailsWithRuntime<KotlinJvmOptions>,
-) : AbstractKotlinCompilationToRunnableFiles<KotlinJvmOptions>(compilationDetails), KotlinCompilationWithResources<KotlinJvmOptions> {
+) : AbstractKotlinCompilationToRunnableFiles<KotlinJvmOptions>(compilationDetails),
+    KotlinCompilationWithResources<KotlinJvmOptions> {
     override val target: KotlinJvmTarget get() = compilationDetails.target as KotlinJvmTarget
 
+    @Suppress("UNCHECKED_CAST")
+    override val compilerOptions: HasCompilerOptions<CompilerJvmOptions>
+        get() = super.compilerOptions as HasCompilerOptions<CompilerJvmOptions>
+
     override val processResourcesTaskName: String
         get() = disambiguateName("processResources")
 
-    @Suppress("UNCHECKED_CAST")
+    @Deprecated("Replaced with compileTaskProvider", replaceWith = ReplaceWith("compileTaskProvider"))
+    @Suppress("UNCHECKED_CAST", "DEPRECATION")
     override val compileKotlinTaskProvider: TaskProvider<out org.jetbrains.kotlin.gradle.tasks.KotlinCompile>
         get() = super.compileKotlinTaskProvider as TaskProvider<out org.jetbrains.kotlin.gradle.tasks.KotlinCompile>
 
+    @Suppress("DEPRECATION")
+    @Deprecated("Accessing task instance directly is deprecated", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTask: org.jetbrains.kotlin.gradle.tasks.KotlinCompile
         get() = super.compileKotlinTask as org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
+    @Suppress("UNCHECKED_CAST")
+    override val compileTaskProvider: TaskProvider<out KotlinCompilationTask<CompilerJvmOptions>>
+        get() = super.compileTaskProvider as TaskProvider<KotlinCompilationTask<CompilerJvmOptions>>
+
     val compileJavaTaskProvider: TaskProvider<out JavaCompile>?
         get() = if (target.withJavaEnabled) {
             val project = target.project

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinJvmCompilationFactory.kt

@@ -6,7 +6,10 @@
 @file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp
 
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptionsImpl
+import org.jetbrains.kotlin.gradle.dsl.CompilerJvmOptions
+import org.jetbrains.kotlin.gradle.dsl.CompilerJvmOptionsDefault
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
 
 open class KotlinJvmCompilationFactory(
@@ -15,11 +18,26 @@ open class KotlinJvmCompilationFactory(
     override val itemClass: Class<KotlinJvmCompilation>
         get() = KotlinJvmCompilation::class.java
 
+    @Suppress("DEPRECATION")
     override fun create(name: String): KotlinJvmCompilation =
         target.project.objects.newInstance(
             KotlinJvmCompilation::class.java,
-            DefaultCompilationDetailsWithRuntime(
-                target, name, getOrCreateDefaultSourceSet(name), KotlinJvmOptionsImpl()
+            DefaultCompilationDetailsWithRuntime<KotlinJvmOptions, CompilerJvmOptions>(
+                target,
+                name,
+                getOrCreateDefaultSourceSet(name),
+                {
+                    object : HasCompilerOptions<CompilerJvmOptions> {
+                        override val options: CompilerJvmOptions =
+                            target.project.objects.newInstance(CompilerJvmOptionsDefault::class.java)
+                    }
+                },
+                {
+                    object : KotlinJvmOptions {
+                        override val options: CompilerJvmOptions
+                            get() = compilerOptions.options
+                    }
+                }
             )
         )
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinJvmWithJavaTargetPreset.kt

@@ -8,8 +8,9 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPlugin
+import org.jetbrains.kotlin.gradle.dsl.CompilerJvmOptions
+import org.jetbrains.kotlin.gradle.dsl.CompilerJvmOptionsDefault
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptionsImpl
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinTasksProvider
@@ -17,11 +18,11 @@ import org.jetbrains.kotlin.gradle.utils.SingleWarningPerBuild
 
 class KotlinJvmWithJavaTargetPreset(
     private val project: Project
-) : KotlinTargetPreset<KotlinWithJavaTarget<KotlinJvmOptions>> {
+) : KotlinTargetPreset<KotlinWithJavaTarget<KotlinJvmOptions, CompilerJvmOptions>> {
 
     override fun getName(): String = PRESET_NAME
 
-    override fun createTarget(name: String): KotlinWithJavaTarget<KotlinJvmOptions> {
+    override fun createTarget(name: String): KotlinWithJavaTarget<KotlinJvmOptions, CompilerJvmOptions> {
         SingleWarningPerBuild.show(
             project,
             DEPRECATION_WARNING
@@ -29,14 +30,25 @@ class KotlinJvmWithJavaTargetPreset(
 
         project.plugins.apply(JavaPlugin::class.java)
 
-        @Suppress("UNCHECKED_CAST")
+        @Suppress("UNCHECKED_CAST", "DEPRECATION")
         val target = (project.objects.newInstance(
             KotlinWithJavaTarget::class.java,
             project,
             KotlinPlatformType.jvm,
             name,
-            { KotlinJvmOptionsImpl() }
-        ) as KotlinWithJavaTarget<KotlinJvmOptions>)
+            {
+                object : HasCompilerOptions<CompilerJvmOptions> {
+                    override val options: CompilerJvmOptions =
+                        project.objects.newInstance(CompilerJvmOptionsDefault::class.java)
+                }
+            },
+            { compilerOptions: CompilerJvmOptions ->
+                object : KotlinJvmOptions {
+                    override val options: CompilerJvmOptions
+                        get() = compilerOptions
+                }
+            }
+        ) as KotlinWithJavaTarget<KotlinJvmOptions, CompilerJvmOptions>)
             .apply {
                 disambiguationClassifier = name
                 preset = this@KotlinJvmWithJavaTargetPreset

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaCompilation.kt

@@ -9,20 +9,23 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.compile.JavaCompile
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.utils.named
 import javax.inject.Inject
 
-abstract class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions> @Inject constructor(
-    target: KotlinWithJavaTarget<KotlinOptionsType>,
+abstract class KotlinWithJavaCompilation<KotlinOptionsType : KotlinCommonOptions, CO : CompilerCommonOptions> @Inject constructor(
+    target: KotlinWithJavaTarget<KotlinOptionsType, CO>,
     name: String,
     override val defaultSourceSet: KotlinSourceSet,
+    compilerOptions: HasCompilerOptions<CO>,
     kotlinOptions: KotlinOptionsType
 ) : AbstractKotlinCompilationToRunnableFiles<KotlinOptionsType>(
-    WithJavaCompilationDetails(target, name, defaultSourceSet, kotlinOptions)
+    WithJavaCompilationDetails<KotlinOptionsType, CO>(target, name, defaultSourceSet, { compilerOptions }, { kotlinOptions })
 ), KotlinCompilationWithResources<KotlinOptionsType> {
     lateinit var javaSourceSet: SourceSet
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaCompilationFactory.kt

@@ -6,24 +6,31 @@
 @file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp
 
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
 
-class KotlinWithJavaCompilationFactory<KotlinOptionsType : KotlinCommonOptions>(
-    override val target: KotlinWithJavaTarget<KotlinOptionsType>,
-    val kotlinOptionsFactory: () -> KotlinOptionsType
-) : KotlinCompilationFactory<KotlinWithJavaCompilation<KotlinOptionsType>> {
+class KotlinWithJavaCompilationFactory<KotlinOptionsType : KotlinCommonOptions, CO : CompilerCommonOptions>(
+    override val target: KotlinWithJavaTarget<KotlinOptionsType, CO>,
+    val compilerOptionsFactory: () -> HasCompilerOptions<CO>,
+    val kotlinOptionsFactory: (CO) -> KotlinOptionsType
+) : KotlinCompilationFactory<KotlinWithJavaCompilation<KotlinOptionsType, CO>> {
 
-    override val itemClass: Class<KotlinWithJavaCompilation<KotlinOptionsType>>
+    override val itemClass: Class<KotlinWithJavaCompilation<KotlinOptionsType, CO>>
         @Suppress("UNCHECKED_CAST")
-        get() = KotlinWithJavaCompilation::class.java as Class<KotlinWithJavaCompilation<KotlinOptionsType>>
+        get() = KotlinWithJavaCompilation::class.java as Class<KotlinWithJavaCompilation<KotlinOptionsType, CO>>
 
     @Suppress("UNCHECKED_CAST")
-    override fun create(name: String): KotlinWithJavaCompilation<KotlinOptionsType> =
-        project.objects.newInstance(
+    override fun create(name: String): KotlinWithJavaCompilation<KotlinOptionsType, CO> {
+        val compilerOptions = compilerOptionsFactory()
+        val kotlinOptions = kotlinOptionsFactory(compilerOptions.options)
+        return project.objects.newInstance(
             KotlinWithJavaCompilation::class.java,
             target,
             name,
             getOrCreateDefaultSourceSet(name),
-            kotlinOptionsFactory()
-        ) as KotlinWithJavaCompilation<KotlinOptionsType>
+            compilerOptions,
+            kotlinOptions
+        ) as KotlinWithJavaCompilation<KotlinOptionsType, CO>
+    }
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaCompilationOutput.kt

@@ -13,7 +13,7 @@ import java.io.File
 import java.util.concurrent.Callable
 
 class KotlinWithJavaCompilationOutput(
-    internal val compilation: KotlinWithJavaCompilation<*>
+    internal val compilation: KotlinWithJavaCompilation<*, *>
 ) : KotlinCompilationOutput, Callable<FileCollection> {
 
     private val javaSourceSetOutput

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaTarget.kt

@@ -13,17 +13,20 @@ import org.gradle.api.file.Directory
 import org.gradle.api.plugins.JavaPlugin
 import org.gradle.api.provider.Provider
 import org.gradle.jvm.tasks.Jar
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.tasks.KOTLIN_BUILD_DIR_NAME
 import java.io.File
 import javax.inject.Inject
 
-abstract class KotlinWithJavaTarget<KotlinOptionsType : KotlinCommonOptions> @Inject constructor(
+abstract class KotlinWithJavaTarget<KotlinOptionsType : KotlinCommonOptions, CO : CompilerCommonOptions> @Inject constructor(
     project: Project,
     override val platformType: KotlinPlatformType,
     override val targetName: String,
-    kotlinOptionsFactory: () -> KotlinOptionsType
+    compilerOptionsFactory: () -> HasCompilerOptions<CO>,
+    kotlinOptionsFactory: (CO) -> KotlinOptionsType
 ) : AbstractKotlinTarget(project) {
     override var disambiguationClassifier: String? = null
         internal set
@@ -40,11 +43,11 @@ abstract class KotlinWithJavaTarget<KotlinOptionsType : KotlinCommonOptions> @In
     override val artifactsTaskName: String
         get() = JavaPlugin.JAR_TASK_NAME
 
-    override val compilations: NamedDomainObjectContainer<KotlinWithJavaCompilation<KotlinOptionsType>> =
+    override val compilations: NamedDomainObjectContainer<KotlinWithJavaCompilation<KotlinOptionsType, CO>> =
         @Suppress("UNCHECKED_CAST")
         project.container(
-            KotlinWithJavaCompilation::class.java as Class<KotlinWithJavaCompilation<KotlinOptionsType>>,
-            KotlinWithJavaCompilationFactory(this, kotlinOptionsFactory)
+            KotlinWithJavaCompilation::class.java as Class<KotlinWithJavaCompilation<KotlinOptionsType, CO>>,
+            KotlinWithJavaCompilationFactory(this, compilerOptionsFactory, kotlinOptionsFactory)
         )
 
     private val layout = project.layout

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

@@ -312,7 +312,7 @@ class KotlinMetadataTargetConfigurator :
         return compilationFactory.create(compilationName).apply {
             target.compilations.add(this@apply)
 
-            (compilationDetails as DefaultCompilationDetails<*>).addExactSourceSetEagerly(sourceSet)
+            (compilationDetails as DefaultCompilationDetails<*, *>).addExactSourceSetEagerly(sourceSet)
 
             configureMetadataDependenciesForCompilation(this@apply)
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinNativeCompilation.kt

@@ -10,9 +10,9 @@ import org.gradle.api.Action
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
 import org.gradle.api.tasks.TaskProvider
-import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
-import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationWithResources
+import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinNativeCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinNativeFragmentMetadataCompilationData
 import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
@@ -22,32 +22,6 @@ import java.io.File
 import java.util.concurrent.Callable
 import javax.inject.Inject
 
-internal class NativeCompileOptions(private val languageSettings: LanguageSettingsBuilder) : KotlinCommonOptions {
-    override val options: CompilerCommonOptions get() = TODO("TBA support")
-
-    override var apiVersion: String?
-        get() = languageSettings.apiVersion
-        set(value) {
-            languageSettings.apiVersion = value
-        }
-
-    override var languageVersion: String?
-        get() = languageSettings.languageVersion
-        set(value) {
-            languageSettings.languageVersion = value
-        }
-    
-    override var useK2: Boolean
-        get() = false
-        set(@Suppress("UNUSED_PARAMETER") value) {}
-
-    override var allWarningsAsErrors: Boolean = false
-    override var suppressWarnings: Boolean = false
-    override var verbose: Boolean = false
-
-    override var freeCompilerArgs: List<String> = listOf()
-}
-
 abstract class AbstractKotlinNativeCompilation(
     override val konanTarget: KonanTarget,
     compilationDetails: CompilationDetails<KotlinCommonOptions>
@@ -56,13 +30,20 @@ abstract class AbstractKotlinNativeCompilation(
 ),
     KotlinNativeCompilationData<KotlinCommonOptions> {
 
+    @Suppress("DEPRECATION")
+    @Deprecated("Accessing task instance directly is deprecated", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTask: KotlinNativeCompile
         get() = super.compileKotlinTask as KotlinNativeCompile
 
-    @Suppress("UNCHECKED_CAST")
+    @Suppress("UNCHECKED_CAST", "DEPRECATION")
+    @Deprecated("Replaced with compileTaskProvider", replaceWith = ReplaceWith("compileTaskProvider"))
     override val compileKotlinTaskProvider: TaskProvider<out KotlinNativeCompile>
         get() = super.compileKotlinTaskProvider as TaskProvider<out KotlinNativeCompile>
 
+    @Suppress("UNCHECKED_CAST")
+    override val compileTaskProvider: TaskProvider<KotlinNativeCompile>
+        get() = super.compileTaskProvider as TaskProvider<KotlinNativeCompile>
+
     internal val useGenericPluginArtifact: Boolean
         get() = project.nativeUseEmbeddableCompilerJar
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinNativeCompilationFactory.kt

@@ -6,6 +6,9 @@
 @file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.plugin.mpp
 
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
+import org.jetbrains.kotlin.gradle.targets.native.NativeCompilerOptions
 import org.jetbrains.kotlin.konan.target.KonanTarget
 
 open class KotlinNativeCompilationFactory(
@@ -15,6 +18,7 @@ open class KotlinNativeCompilationFactory(
     override val itemClass: Class<KotlinNativeCompilation>
         get() = KotlinNativeCompilation::class.java
 
+    @Suppress("DEPRECATION")
     override fun create(name: String): KotlinNativeCompilation {
         // TODO: Validate compilation free args using the [CompilationFreeArgsValidator]
         //       when the compilation and the link args are separated (see KT-33717).
@@ -26,7 +30,21 @@ open class KotlinNativeCompilationFactory(
             KotlinNativeCompilation::class.java,
             target.konanTarget,
             NativeCompilationDetails(
-                target, name, defaultSourceSet, NativeCompileOptions(defaultSourceSet.languageSettings)
+                target,
+                name,
+                defaultSourceSet,
+                {
+                    NativeCompilerOptions(
+                        target.project,
+                        defaultSourceSet.languageSettings
+                    )
+                },
+                {
+                    object : KotlinCommonOptions {
+                        override val options: CompilerCommonOptions
+                            get() = compilerOptions.options
+                    }
+                }
             )
         )
     }
@@ -44,7 +62,23 @@ class KotlinSharedNativeCompilationFactory(
         return target.project.objects.newInstance(
             KotlinSharedNativeCompilation::class.java,
             konanTargets,
-            SharedNativeCompilationDetails(target, name, defaultSourceSet, NativeCompileOptions(defaultSourceSet.languageSettings))
+            SharedNativeCompilationDetails(
+                target,
+                name,
+                defaultSourceSet,
+                {
+                    NativeCompilerOptions(
+                        target.project,
+                        defaultSourceSet.languageSettings
+                    )
+                },
+                {
+                    object : KotlinCommonOptions {
+                        override val options: CompilerCommonOptions
+                            get() = compilerOptions.options
+                    }
+                }
+            )
         )
     }
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/NativeCompilerOptions.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.targets.native
+
+import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptions
+import org.jetbrains.kotlin.gradle.dsl.CompilerCommonOptionsDefault
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
+import org.jetbrains.kotlin.gradle.plugin.runOnceAfterEvaluated
+import org.jetbrains.kotlin.gradle.plugin.sources.applyLanguageSettingsToCompilerOptions
+import org.jetbrains.kotlin.project.model.LanguageSettings
+
+internal class NativeCompilerOptions(
+    project: Project,
+    nativeLanguageSettings: LanguageSettings
+) : HasCompilerOptions<CompilerCommonOptions> {
+    override val options: CompilerCommonOptions = project.objects
+        .newInstance(CompilerCommonOptionsDefault::class.java)
+        .apply {
+            useK2.finalizeValue()
+            project.runOnceAfterEvaluated("apply Kotlin native properties from language settings") {
+                applyLanguageSettingsToCompilerOptions(nativeLanguageSettings, this)
+            }
+        }
+}