Split compiler options implementation and helper methods

Such split allows to reuse default implementation for different use-cases. Helpers, in this case, allows to do manipulations with options where required. ^KT-57159 In Progress
2023-03-09 21:42:38 +01:00
parent 2086c5348b
commit 4d4e5f4701
20 changed files with 394 additions and 173 deletions
@@ -36,17 +36,23 @@ private data class GeneratedOptions(
    val properties: List<KProperty1<*, *>>
 )

+private data class GeneratedImplOptions(
+    val baseImplName: FqName,
+    val helperName: FqName
+)
+
 private const val GRADLE_API_SRC_DIR = "libraries/tools/kotlin-gradle-plugin-api/src/common/kotlin"
 private const val GRADLE_PLUGIN_SRC_DIR = "libraries/tools/kotlin-gradle-plugin/src/common/kotlin"
 private const val OPTIONS_PACKAGE_PREFIX = "org.jetbrains.kotlin.gradle.dsl"
 private const val IMPLEMENTATION_SUFFIX = "Default"
+private const val IMPLEMENTATION_HELPERS_SUFFIX = "Helper"

 fun generateKotlinGradleOptions(withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit) {
    val apiSrcDir = File(GRADLE_API_SRC_DIR)
    val srcDir = File(GRADLE_PLUGIN_SRC_DIR)

    val commonToolOptions = generateKotlinCommonToolOptions(apiSrcDir, withPrinterToFile)
-    val commonToolImplFqName = generateKotlinCommonToolOptionsImpl(
+    val commonToolImplOptions = generateKotlinCommonToolOptionsImpl(
        srcDir,
        commonToolOptions.optionsName,
        commonToolOptions.properties,
@@ -58,10 +64,11 @@ fun generateKotlinGradleOptions(withPrinterToFile: (targetFile: File, Printer.()
        commonToolOptions,
        withPrinterToFile
    )
-    val commonCompilerOptionsImplFqName = generateKotlinCommonOptionsImpl(
+    val commonCompilerOptionsImpl = generateKotlinCommonOptionsImpl(
        srcDir,
        commonCompilerOptions.optionsName,
-        commonToolImplFqName,
+        commonToolImplOptions.baseImplName,
+        commonToolImplOptions.helperName,
        commonCompilerOptions.properties,
        withPrinterToFile
    )
@@ -74,7 +81,8 @@ fun generateKotlinGradleOptions(withPrinterToFile: (targetFile: File, Printer.()
    generateKotlinJvmOptionsImpl(
        srcDir,
        jvmOptions.optionsName,
-        commonCompilerOptionsImplFqName,
+        commonCompilerOptionsImpl.baseImplName,
+        commonCompilerOptionsImpl.helperName,
        jvmOptions.properties,
        withPrinterToFile
    )
@@ -87,7 +95,8 @@ fun generateKotlinGradleOptions(withPrinterToFile: (targetFile: File, Printer.()
    generateKotlinJsOptionsImpl(
        srcDir,
        jsOptions.optionsName,
-        commonCompilerOptionsImplFqName,
+        commonCompilerOptionsImpl.baseImplName,
+        commonCompilerOptionsImpl.helperName,
        jsOptions.properties,
        withPrinterToFile
    )
@@ -100,7 +109,8 @@ fun generateKotlinGradleOptions(withPrinterToFile: (targetFile: File, Printer.()
    generateKotlinNativeOptionsImpl(
        srcDir,
        nativeOptions.optionsName,
-        commonCompilerOptionsImplFqName,
+        commonCompilerOptionsImpl.baseImplName,
+        commonCompilerOptionsImpl.helperName,
        nativeOptions.properties,
        withPrinterToFile
    )
@@ -113,7 +123,8 @@ fun generateKotlinGradleOptions(withPrinterToFile: (targetFile: File, Printer.()
    generateJsDceOptionsImpl(
        srcDir,
        jsDceOptions.optionsName,
-        commonCompilerOptionsImplFqName,
+        commonToolImplOptions.baseImplName,
+        commonToolImplOptions.helperName,
        jsDceOptions.properties,
        withPrinterToFile
    )
@@ -126,7 +137,8 @@ fun generateKotlinGradleOptions(withPrinterToFile: (targetFile: File, Printer.()
    generateMultiplatformCommonOptionsImpl(
        srcDir,
        multiplatformCommonOptions.optionsName,
-        commonCompilerOptionsImplFqName,
+        commonCompilerOptionsImpl.baseImplName,
+        commonCompilerOptionsImpl.helperName,
        multiplatformCommonOptions.properties,
        withPrinterToFile
    )
@@ -182,20 +194,32 @@ private fun generateKotlinCommonToolOptionsImpl(
    commonToolOptionsInterfaceFqName: FqName,
    options: List<KProperty1<*, *>>,
    withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit
-): FqName {
-    val k2CommonToolCompilerArgumentsFqName = FqName(CommonToolArguments::class.qualifiedName!!)
-    val commonToolImplFqName = FqName("${commonToolOptionsInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
-    withPrinterToFile(fileFromFqName(srcDir, commonToolImplFqName)) {
+): GeneratedImplOptions {
+    val commonToolBaseImplFqName = FqName("${commonToolOptionsInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
+    withPrinterToFile(fileFromFqName(srcDir, commonToolBaseImplFqName)) {
        generateImpl(
-            commonToolImplFqName,
+            commonToolBaseImplFqName,
            null,
            commonToolOptionsInterfaceFqName,
-            k2CommonToolCompilerArgumentsFqName,
            options,
        )
    }

-    return commonToolImplFqName
+    val k2CommonToolCompilerArgumentsFqName = FqName(CommonToolArguments::class.qualifiedName!!)
+    val commonToolCompilerArgsImplFqName = FqName(
+        "${commonToolOptionsInterfaceFqName.asString()}$IMPLEMENTATION_HELPERS_SUFFIX"
+    )
+    withPrinterToFile(fileFromFqName(srcDir, commonToolCompilerArgsImplFqName)) {
+        generateCompilerOptionsHelper(
+            commonToolOptionsInterfaceFqName,
+            commonToolCompilerArgsImplFqName,
+            null,
+            k2CommonToolCompilerArgumentsFqName,
+            options
+        )
+    }
+
+    return GeneratedImplOptions(commonToolBaseImplFqName, commonToolCompilerArgsImplFqName)
 }

 private fun generateKotlinCommonOptions(
@@ -233,22 +257,35 @@ private fun generateKotlinCommonOptionsImpl(
    srcDir: File,
    commonOptionsInterfaceFqName: FqName,
    commonToolImpl: FqName,
+    commonToolCompilerHelperName: FqName,
    options: List<KProperty1<*, *>>,
    withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit
-): FqName {
-    val k2CommonCompilerArgumentsFqName = FqName(CommonCompilerArguments::class.qualifiedName!!)
+): GeneratedImplOptions {
    val commonCompilerImplFqName = FqName("${commonOptionsInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
    withPrinterToFile(fileFromFqName(srcDir, commonCompilerImplFqName)) {
        generateImpl(
            commonCompilerImplFqName,
            commonToolImpl,
            commonOptionsInterfaceFqName,
-            k2CommonCompilerArgumentsFqName,
            options,
        )
    }

-    return commonCompilerImplFqName
+    val k2CommonCompilerArgumentsFqName = FqName(CommonCompilerArguments::class.qualifiedName!!)
+    val commonCompilerHelperFqName = FqName(
+        "${commonOptionsInterfaceFqName.asString()}$IMPLEMENTATION_HELPERS_SUFFIX"
+    )
+    withPrinterToFile(fileFromFqName(srcDir, commonCompilerHelperFqName)) {
+        generateCompilerOptionsHelper(
+            commonOptionsInterfaceFqName,
+            commonCompilerHelperFqName,
+            commonToolCompilerHelperName,
+            k2CommonCompilerArgumentsFqName,
+            options
+        )
+    }
+
+    return GeneratedImplOptions(commonCompilerImplFqName, commonCompilerHelperFqName)
 }

 private fun generateKotlinJvmOptions(
@@ -286,16 +323,29 @@ private fun generateKotlinJvmOptionsImpl(
    srcDir: File,
    jvmInterfaceFqName: FqName,
    commonCompilerImpl: FqName,
+    commonCompilerHelperName: FqName,
    jvmOptions: List<KProperty1<*, *>>,
    withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit
 ) {
-    val k2JvmCompilerArgumentsFqName = FqName(K2JVMCompilerArguments::class.qualifiedName!!)
    val jvmImplFqName = FqName("${jvmInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
    withPrinterToFile(fileFromFqName(srcDir, jvmImplFqName)) {
        generateImpl(
            jvmImplFqName,
            commonCompilerImpl,
            jvmInterfaceFqName,
+            jvmOptions
+        )
+    }
+
+    val k2JvmCompilerArgumentsFqName = FqName(K2JVMCompilerArguments::class.qualifiedName!!)
+    val jvmCompilerOptionsHelperFqName = FqName(
+        "${jvmInterfaceFqName.asString()}$IMPLEMENTATION_HELPERS_SUFFIX"
+    )
+    withPrinterToFile(fileFromFqName(srcDir, jvmCompilerOptionsHelperFqName)) {
+        generateCompilerOptionsHelper(
+            jvmInterfaceFqName,
+            jvmCompilerOptionsHelperFqName,
+            commonCompilerHelperName,
            k2JvmCompilerArgumentsFqName,
            jvmOptions
        )
@@ -337,16 +387,29 @@ private fun generateKotlinJsOptionsImpl(
    srcDir: File,
    jsInterfaceFqName: FqName,
    commonCompilerImpl: FqName,
+    commonCompilerHelperName: FqName,
    jsOptions: List<KProperty1<*, *>>,
    withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit
 ) {
-    val k2JsCompilerArgumentsFqName = FqName(K2JSCompilerArguments::class.qualifiedName!!)
    val jsImplFqName = FqName("${jsInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
    withPrinterToFile(fileFromFqName(srcDir, jsImplFqName)) {
        generateImpl(
            jsImplFqName,
            commonCompilerImpl,
            jsInterfaceFqName,
+            jsOptions
+        )
+    }
+
+    val k2JsCompilerArgumentsFqName = FqName(K2JSCompilerArguments::class.qualifiedName!!)
+    val jsCompilerOptionsHelperFqName = FqName(
+        "${jsInterfaceFqName.asString()}$IMPLEMENTATION_HELPERS_SUFFIX"
+    )
+    withPrinterToFile(fileFromFqName(srcDir, jsCompilerOptionsHelperFqName)) {
+        generateCompilerOptionsHelper(
+            jsInterfaceFqName,
+            jsCompilerOptionsHelperFqName,
+            commonCompilerHelperName,
            k2JsCompilerArgumentsFqName,
            jsOptions
        )
@@ -378,16 +441,29 @@ private fun generateKotlinNativeOptionsImpl(
    srcDir: File,
    nativeInterfaceFqName: FqName,
    commonCompilerImpl: FqName,
+    commonCompilerHelper: FqName,
    nativeOptions: List<KProperty1<*, *>>,
    withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit
 ) {
-    val k2NativeCompilerArgumentsFqName = FqName(K2NativeCompilerArguments::class.qualifiedName!!)
    val nativeImplFqName = FqName("${nativeInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
    withPrinterToFile(fileFromFqName(srcDir, nativeImplFqName)) {
        generateImpl(
            nativeImplFqName,
            commonCompilerImpl,
            nativeInterfaceFqName,
+            nativeOptions
+        )
+    }
+
+    val k2NativeCompilerArgumentsFqName = FqName(K2NativeCompilerArguments::class.qualifiedName!!)
+    val nativeCompilerOptionsHelperFqName = FqName(
+        "${nativeInterfaceFqName.asString()}$IMPLEMENTATION_HELPERS_SUFFIX"
+    )
+    withPrinterToFile(fileFromFqName(srcDir, nativeCompilerOptionsHelperFqName)) {
+        generateCompilerOptionsHelper(
+            nativeInterfaceFqName,
+            nativeCompilerOptionsHelperFqName,
+            commonCompilerHelper,
            k2NativeCompilerArgumentsFqName,
            nativeOptions
        )
@@ -429,17 +505,30 @@ private fun generateJsDceOptions(
 private fun generateJsDceOptionsImpl(
    srcDir: File,
    jsDceInterfaceFqName: FqName,
-    commonCompilerImpl: FqName,
+    commonToolImpl: FqName,
+    commonToolHelper: FqName,
    jsDceOptions: List<KProperty1<*, *>>,
    withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit
 ) {
-    val k2JsDceArgumentsFqName = FqName(K2JSDceArguments::class.qualifiedName!!)
    val jsDceImplFqName = FqName("${jsDceInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
    withPrinterToFile(fileFromFqName(srcDir, jsDceImplFqName)) {
        generateImpl(
            jsDceImplFqName,
-            commonCompilerImpl,
+            commonToolImpl,
            jsDceInterfaceFqName,
+            jsDceOptions
+        )
+    }
+
+    val k2JsDceArgumentsFqName = FqName(K2JSDceArguments::class.qualifiedName!!)
+    val jsDceCompilerHelperFqName = FqName(
+        "${jsDceInterfaceFqName.asString()}$IMPLEMENTATION_HELPERS_SUFFIX"
+    )
+    withPrinterToFile(fileFromFqName(srcDir, jsDceCompilerHelperFqName)) {
+        generateCompilerOptionsHelper(
+            jsDceInterfaceFqName,
+            jsDceCompilerHelperFqName,
+            commonToolHelper,
            k2JsDceArgumentsFqName,
            jsDceOptions
        )
@@ -481,16 +570,29 @@ private fun generateMultiplatformCommonOptionsImpl(
    srcDir: File,
    multiplatformCommonInterfaceFqName: FqName,
    commonCompilerImpl: FqName,
+    commonCompilerHelper: FqName,
    multiplatformCommonOptions: List<KProperty1<*, *>>,
    withPrinterToFile: (targetFile: File, Printer.() -> Unit) -> Unit
 ) {
-    val k2metadataCompilerArgumentsFqName = FqName(K2MetadataCompilerArguments::class.qualifiedName!!)
    val multiplatformCommonImplFqName = FqName("${multiplatformCommonInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
    withPrinterToFile(fileFromFqName(srcDir, multiplatformCommonImplFqName)) {
        generateImpl(
            multiplatformCommonImplFqName,
            commonCompilerImpl,
            multiplatformCommonInterfaceFqName,
+            multiplatformCommonOptions
+        )
+    }
+
+    val k2metadataCompilerArgumentsFqName = FqName(K2MetadataCompilerArguments::class.qualifiedName!!)
+    val metadataCompilerHelperFqName = FqName(
+        "${multiplatformCommonInterfaceFqName.asString()}$IMPLEMENTATION_HELPERS_SUFFIX"
+    )
+    withPrinterToFile(fileFromFqName(srcDir, metadataCompilerHelperFqName)) {
+        generateCompilerOptionsHelper(
+            multiplatformCommonInterfaceFqName,
+            metadataCompilerHelperFqName,
+            commonCompilerHelper,
            k2metadataCompilerArgumentsFqName,
            multiplatformCommonOptions
        )
@@ -564,7 +666,6 @@ private fun Printer.generateImpl(
    type: FqName,
    parentImplFqName: FqName?,
    parentType: FqName,
-    argsType: FqName,
    properties: List<KProperty1<*, *>>
 ) {
    val modifiers = "internal abstract class"
@@ -583,30 +684,54 @@ private fun Printer.generateImpl(
            println()
            generatePropertyProviderImpl(property)
        }
+    }
+}

+private fun Printer.generateCompilerOptionsHelper(
+    type: FqName,
+    helperName: FqName,
+    parentHelperName: FqName?,
+    argsType: FqName,
+    properties: List<KProperty1<*, *>>
+) {
+    val modifiers = "internal object"
+
+    generateDeclaration(
+        modifiers,
+        helperName,
+    ) {
        println()
-        println("internal fun fillCompilerArguments(args: $argsType) {")
+        println("internal fun fillCompilerArguments(")
        withIndent {
-            if (parentImplFqName != null) println("super.fillCompilerArguments(args)")
+            println("from: $type,")
+            println("args: $argsType,")
+        }
+        println(") {")
+        withIndent {
+            if (parentHelperName != null) println("$parentHelperName.fillCompilerArguments(from, args)")
            for (property in properties) {
                val defaultValue = property.gradleValues
                if (property.name != "freeCompilerArgs") {
                    val getter = if (property.gradleReturnType.endsWith("?")) ".orNull" else ".get()"
                    val toArg = defaultValue.toArgumentConverter?.substringAfter("this") ?: ""
-                    println("args.${property.name} = ${property.name}$getter$toArg")
+                    println("args.${property.name} = from.${property.name}$getter$toArg")
                } else {
-                    println("args.freeArgs += ${property.name}.get()")
+                    println("args.freeArgs += from.${property.name}.get()")
                }
            }

-            addAdditionalJvmArgs(type)
+            addAdditionalJvmArgs(helperName)
        }
        println("}")

        println()
-        println("internal fun fillDefaultValues(args: $argsType) {")
+        println("internal fun fillDefaultValues(")
        withIndent {
-            if (parentImplFqName != null) println("super.fillDefaultValues(args)")
+            println("args: $argsType,")
+        }
+        println(") {")
+        withIndent {
+            if (parentHelperName != null) println("$parentHelperName.fillDefaultValues(args)")
            properties
                .filter { it.name != "freeCompilerArgs" }
                .forEach {
@@ -618,7 +743,7 @@ private fun Printer.generateImpl(
                    println("args.${it.name} = $value")
                }

-            addAdditionalJvmArgs(type)
+            addAdditionalJvmArgs(helperName)
        }
        println("}")
    }
@@ -627,7 +752,7 @@ private fun Printer.generateImpl(
 private fun Printer.addAdditionalJvmArgs(implType: FqName) {
    // Adding required 'noStdlib' and 'noReflect' compiler arguments for JVM compilation
    // Otherwise compilation via build tools will fail
-    if (implType.shortName().toString() == "KotlinJvmCompilerOptions$IMPLEMENTATION_SUFFIX") {
+    if (implType.shortName().toString() == "KotlinJvmCompilerOptions$IMPLEMENTATION_HELPERS_SUFFIX") {
        println()
        println("// Arguments with always default values when used from build tools")
        println("args.noStdlib = true")
@@ -24,22 +24,4 @@ internal abstract class KotlinCommonCompilerOptionsDefault @javax.inject.Inject
    @Deprecated(message = "Compiler flag -Xuse-k2 is deprecated; please use language version 2.0 instead", level = DeprecationLevel.WARNING)
    override val useK2: org.gradle.api.provider.Property<kotlin.Boolean> =
        objectFactory.property(kotlin.Boolean::class.java).convention(false)
-
-    internal fun fillCompilerArguments(args: org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments) {
-        super.fillCompilerArguments(args)
-        args.apiVersion = apiVersion.orNull?.version
-        args.languageVersion = languageVersion.orNull?.version
-        args.optIn = optIn.get().toTypedArray()
-        args.progressiveMode = progressiveMode.get()
-        args.useK2 = useK2.get()
-    }
-
-    internal fun fillDefaultValues(args: org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments) {
-        super.fillDefaultValues(args)
-        args.apiVersion = null
-        args.languageVersion = null
-        args.optIn = emptyList<String>().toTypedArray()
-        args.progressiveMode = false
-        args.useK2 = false
-    }
 }
@@ -0,0 +1,32 @@
+// DO NOT EDIT MANUALLY!
+// Generated by org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt
+// To regenerate run 'generateGradleOptions' task
+@file:Suppress("RemoveRedundantQualifierName", "Deprecation", "DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.dsl
+
+internal object KotlinCommonCompilerOptionsHelper {
+
+    internal fun fillCompilerArguments(
+        from: org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptions,
+        args: org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerToolOptionsHelper.fillCompilerArguments(from, args)
+        args.apiVersion = from.apiVersion.orNull?.version
+        args.languageVersion = from.languageVersion.orNull?.version
+        args.optIn = from.optIn.get().toTypedArray()
+        args.progressiveMode = from.progressiveMode.get()
+        args.useK2 = from.useK2.get()
+    }
+
+    internal fun fillDefaultValues(
+        args: org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerToolOptionsHelper.fillDefaultValues(args)
+        args.apiVersion = null
+        args.languageVersion = null
+        args.optIn = emptyList<String>().toTypedArray()
+        args.progressiveMode = false
+        args.useK2 = false
+    }
+}
@@ -20,17 +20,4 @@ internal abstract class KotlinCommonCompilerToolOptionsDefault @javax.inject.Inj

    override val freeCompilerArgs: org.gradle.api.provider.ListProperty<kotlin.String> =
        objectFactory.listProperty(kotlin.String::class.java).convention(emptyList<String>())
-
-    internal fun fillCompilerArguments(args: org.jetbrains.kotlin.cli.common.arguments.CommonToolArguments) {
-        args.allWarningsAsErrors = allWarningsAsErrors.get()
-        args.suppressWarnings = suppressWarnings.get()
-        args.verbose = verbose.get()
-        args.freeArgs += freeCompilerArgs.get()
-    }
-
-    internal fun fillDefaultValues(args: org.jetbrains.kotlin.cli.common.arguments.CommonToolArguments) {
-        args.allWarningsAsErrors = false
-        args.suppressWarnings = false
-        args.verbose = false
-    }
 }
@@ -0,0 +1,27 @@
+// DO NOT EDIT MANUALLY!
+// Generated by org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt
+// To regenerate run 'generateGradleOptions' task
+@file:Suppress("RemoveRedundantQualifierName", "Deprecation", "DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.dsl
+
+internal object KotlinCommonCompilerToolOptionsHelper {
+
+    internal fun fillCompilerArguments(
+        from: org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerToolOptions,
+        args: org.jetbrains.kotlin.cli.common.arguments.CommonToolArguments,
+    ) {
+        args.allWarningsAsErrors = from.allWarningsAsErrors.get()
+        args.suppressWarnings = from.suppressWarnings.get()
+        args.verbose = from.verbose.get()
+        args.freeArgs += from.freeCompilerArgs.get()
+    }
+
+    internal fun fillDefaultValues(
+        args: org.jetbrains.kotlin.cli.common.arguments.CommonToolArguments,
+    ) {
+        args.allWarningsAsErrors = false
+        args.suppressWarnings = false
+        args.verbose = false
+    }
+}
@@ -51,40 +51,4 @@ internal abstract class KotlinJsCompilerOptionsDefault @javax.inject.Inject cons

    override val useEsClasses: org.gradle.api.provider.Property<kotlin.Boolean> =
        objectFactory.property(kotlin.Boolean::class.java).convention(false)
-
-    internal fun fillCompilerArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments) {
-        super.fillCompilerArguments(args)
-        args.friendModulesDisabled = friendModulesDisabled.get()
-        args.main = main.get().mode
-        args.metaInfo = metaInfo.get()
-        args.moduleKind = moduleKind.get().kind
-        args.moduleName = moduleName.orNull
-        args.noStdlib = noStdlib.get()
-        args.outputFile = outputFile.orNull
-        args.sourceMap = sourceMap.get()
-        args.sourceMapEmbedSources = sourceMapEmbedSources.orNull?.mode
-        args.sourceMapNamesPolicy = sourceMapNamesPolicy.orNull?.policy
-        args.sourceMapPrefix = sourceMapPrefix.orNull
-        args.target = target.get()
-        args.typedArrays = typedArrays.get()
-        args.useEsClasses = useEsClasses.get()
-    }
-
-    internal fun fillDefaultValues(args: org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments) {
-        super.fillDefaultValues(args)
-        args.friendModulesDisabled = false
-        args.main = org.jetbrains.kotlin.gradle.dsl.JsMainFunctionExecutionMode.CALL.mode
-        args.metaInfo = true
-        args.moduleKind = org.jetbrains.kotlin.gradle.dsl.JsModuleKind.MODULE_PLAIN.kind
-        args.moduleName = null
-        args.noStdlib = true
-        args.outputFile = null
-        args.sourceMap = false
-        args.sourceMapEmbedSources = null
-        args.sourceMapNamesPolicy = null
-        args.sourceMapPrefix = null
-        args.target = "v5"
-        args.typedArrays = true
-        args.useEsClasses = false
-    }
 }
@@ -0,0 +1,50 @@
+// DO NOT EDIT MANUALLY!
+// Generated by org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt
+// To regenerate run 'generateGradleOptions' task
+@file:Suppress("RemoveRedundantQualifierName", "Deprecation", "DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.dsl
+
+internal object KotlinJsCompilerOptionsHelper {
+
+    internal fun fillCompilerArguments(
+        from: org.jetbrains.kotlin.gradle.dsl.KotlinJsCompilerOptions,
+        args: org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillCompilerArguments(from, args)
+        args.friendModulesDisabled = from.friendModulesDisabled.get()
+        args.main = from.main.get().mode
+        args.metaInfo = from.metaInfo.get()
+        args.moduleKind = from.moduleKind.get().kind
+        args.moduleName = from.moduleName.orNull
+        args.noStdlib = from.noStdlib.get()
+        args.outputFile = from.outputFile.orNull
+        args.sourceMap = from.sourceMap.get()
+        args.sourceMapEmbedSources = from.sourceMapEmbedSources.orNull?.mode
+        args.sourceMapNamesPolicy = from.sourceMapNamesPolicy.orNull?.policy
+        args.sourceMapPrefix = from.sourceMapPrefix.orNull
+        args.target = from.target.get()
+        args.typedArrays = from.typedArrays.get()
+        args.useEsClasses = from.useEsClasses.get()
+    }
+
+    internal fun fillDefaultValues(
+        args: org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillDefaultValues(args)
+        args.friendModulesDisabled = false
+        args.main = org.jetbrains.kotlin.gradle.dsl.JsMainFunctionExecutionMode.CALL.mode
+        args.metaInfo = true
+        args.moduleKind = org.jetbrains.kotlin.gradle.dsl.JsModuleKind.MODULE_PLAIN.kind
+        args.moduleName = null
+        args.noStdlib = true
+        args.outputFile = null
+        args.sourceMap = false
+        args.sourceMapEmbedSources = null
+        args.sourceMapNamesPolicy = null
+        args.sourceMapPrefix = null
+        args.target = "v5"
+        args.typedArrays = true
+        args.useEsClasses = false
+    }
+}
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.gradle.dsl

 internal abstract class KotlinJsDceCompilerToolOptionsDefault @javax.inject.Inject constructor(
    objectFactory: org.gradle.api.model.ObjectFactory
-) : org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsDefault(objectFactory), org.jetbrains.kotlin.gradle.dsl.KotlinJsDceCompilerToolOptions {
+) : org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerToolOptionsDefault(objectFactory), org.jetbrains.kotlin.gradle.dsl.KotlinJsDceCompilerToolOptions {

    override val devMode: org.gradle.api.provider.Property<kotlin.Boolean> =
        objectFactory.property(kotlin.Boolean::class.java).convention(false)
@@ -15,16 +15,4 @@ internal abstract class KotlinJsDceCompilerToolOptionsDefault @javax.inject.Inje
    @Deprecated(message = "Use task 'destinationDirectory' to configure output directory", level = DeprecationLevel.WARNING)
    override val outputDirectory: org.gradle.api.provider.Property<kotlin.String> =
        objectFactory.property(kotlin.String::class.java)
-
-    internal fun fillCompilerArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments) {
-        super.fillCompilerArguments(args)
-        args.devMode = devMode.get()
-        args.outputDirectory = outputDirectory.orNull
-    }
-
-    internal fun fillDefaultValues(args: org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments) {
-        super.fillDefaultValues(args)
-        args.devMode = false
-        args.outputDirectory = null
-    }
 }
@@ -0,0 +1,26 @@
+// DO NOT EDIT MANUALLY!
+// Generated by org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt
+// To regenerate run 'generateGradleOptions' task
+@file:Suppress("RemoveRedundantQualifierName", "Deprecation", "DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.dsl
+
+internal object KotlinJsDceCompilerToolOptionsHelper {
+
+    internal fun fillCompilerArguments(
+        from: org.jetbrains.kotlin.gradle.dsl.KotlinJsDceCompilerToolOptions,
+        args: org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerToolOptionsHelper.fillCompilerArguments(from, args)
+        args.devMode = from.devMode.get()
+        args.outputDirectory = from.outputDirectory.orNull
+    }
+
+    internal fun fillDefaultValues(
+        args: org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerToolOptionsHelper.fillDefaultValues(args)
+        args.devMode = false
+        args.outputDirectory = null
+    }
+}
@@ -20,28 +20,4 @@ internal abstract class KotlinJvmCompilerOptionsDefault @javax.inject.Inject con

    override val noJdk: org.gradle.api.provider.Property<kotlin.Boolean> =
        objectFactory.property(kotlin.Boolean::class.java).convention(false)
-
-    internal fun fillCompilerArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments) {
-        super.fillCompilerArguments(args)
-        args.javaParameters = javaParameters.get()
-        args.jvmTarget = jvmTarget.orNull?.target
-        args.moduleName = moduleName.orNull
-        args.noJdk = noJdk.get()
-
-        // Arguments with always default values when used from build tools
-        args.noStdlib = true
-        args.noReflect = true
-    }
-
-    internal fun fillDefaultValues(args: org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments) {
-        super.fillDefaultValues(args)
-        args.javaParameters = false
-        args.jvmTarget = null
-        args.moduleName = null
-        args.noJdk = false
-
-        // Arguments with always default values when used from build tools
-        args.noStdlib = true
-        args.noReflect = true
-    }
 }
@@ -0,0 +1,38 @@
+// DO NOT EDIT MANUALLY!
+// Generated by org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt
+// To regenerate run 'generateGradleOptions' task
+@file:Suppress("RemoveRedundantQualifierName", "Deprecation", "DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.dsl
+
+internal object KotlinJvmCompilerOptionsHelper {
+
+    internal fun fillCompilerArguments(
+        from: org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptions,
+        args: org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillCompilerArguments(from, args)
+        args.javaParameters = from.javaParameters.get()
+        args.jvmTarget = from.jvmTarget.orNull?.target
+        args.moduleName = from.moduleName.orNull
+        args.noJdk = from.noJdk.get()
+
+        // Arguments with always default values when used from build tools
+        args.noStdlib = true
+        args.noReflect = true
+    }
+
+    internal fun fillDefaultValues(
+        args: org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillDefaultValues(args)
+        args.javaParameters = false
+        args.jvmTarget = null
+        args.moduleName = null
+        args.noJdk = false
+
+        // Arguments with always default values when used from build tools
+        args.noStdlib = true
+        args.noReflect = true
+    }
+}
@@ -8,12 +8,4 @@ package org.jetbrains.kotlin.gradle.dsl
 internal abstract class KotlinMultiplatformCommonCompilerOptionsDefault @javax.inject.Inject constructor(
    objectFactory: org.gradle.api.model.ObjectFactory
 ) : org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsDefault(objectFactory), org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformCommonCompilerOptions {
-
-    internal fun fillCompilerArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments) {
-        super.fillCompilerArguments(args)
-    }
-
-    internal fun fillDefaultValues(args: org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments) {
-        super.fillDefaultValues(args)
-    }
 }
@@ -0,0 +1,22 @@
+// DO NOT EDIT MANUALLY!
+// Generated by org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt
+// To regenerate run 'generateGradleOptions' task
+@file:Suppress("RemoveRedundantQualifierName", "Deprecation", "DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.dsl
+
+internal object KotlinMultiplatformCommonCompilerOptionsHelper {
+
+    internal fun fillCompilerArguments(
+        from: org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformCommonCompilerOptions,
+        args: org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillCompilerArguments(from, args)
+    }
+
+    internal fun fillDefaultValues(
+        args: org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillDefaultValues(args)
+    }
+}
@@ -11,14 +11,4 @@ internal abstract class KotlinNativeCompilerOptionsDefault @javax.inject.Inject

    override val moduleName: org.gradle.api.provider.Property<kotlin.String> =
        objectFactory.property(kotlin.String::class.java)
-
-    internal fun fillCompilerArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2NativeCompilerArguments) {
-        super.fillCompilerArguments(args)
-        args.moduleName = moduleName.orNull
-    }
-
-    internal fun fillDefaultValues(args: org.jetbrains.kotlin.cli.common.arguments.K2NativeCompilerArguments) {
-        super.fillDefaultValues(args)
-        args.moduleName = null
-    }
 }
@@ -0,0 +1,24 @@
+// DO NOT EDIT MANUALLY!
+// Generated by org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt
+// To regenerate run 'generateGradleOptions' task
+@file:Suppress("RemoveRedundantQualifierName", "Deprecation", "DuplicatedCode")
+
+package org.jetbrains.kotlin.gradle.dsl
+
+internal object KotlinNativeCompilerOptionsHelper {
+
+    internal fun fillCompilerArguments(
+        from: org.jetbrains.kotlin.gradle.dsl.KotlinNativeCompilerOptions,
+        args: org.jetbrains.kotlin.cli.common.arguments.K2NativeCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillCompilerArguments(from, args)
+        args.moduleName = from.moduleName.orNull
+    }
+
+    internal fun fillDefaultValues(
+        args: org.jetbrains.kotlin.cli.common.arguments.K2NativeCompilerArguments,
+    ) {
+        org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsHelper.fillDefaultValues(args)
+        args.moduleName = null
+    }
+}
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.gradle.internal
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.CommonToolArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptionsDefault
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptionsHelper
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompileArgumentsProvider
@@ -78,7 +78,7 @@ internal open class KotlinJvmCompilerArgumentsContributor(
        args: K2JVMCompilerArguments,
        flags: Collection<CompilerArgumentsConfigurationFlag>
    ) {
-        (compilerOptions as KotlinJvmCompilerOptionsDefault).fillDefaultValues(args)
+        KotlinJvmCompilerOptionsHelper.fillDefaultValues(args)

        super.contributeArguments(args, flags)

@@ -98,7 +98,7 @@ internal open class KotlinJvmCompilerArgumentsContributor(
        }
        args.destinationAsFile = destinationDir

-        compilerOptions.fillCompilerArguments(args)
+        KotlinJvmCompilerOptionsHelper.fillCompilerArguments(compilerOptions, args)
        logger.kotlinDebug { "$taskName | args.moduleName = ${args.moduleName} (w/ compilerOptions applied)" }
    }
 }
@@ -26,6 +26,7 @@ import org.gradle.work.NormalizeLineEndings
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptionsDefault
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptionsHelper
 import org.jetbrains.kotlin.gradle.report.BuildReportMode
 import org.jetbrains.kotlin.gradle.tasks.KaptGenerateStubs
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
@@ -114,7 +115,7 @@ abstract class KaptGenerateStubsTask @Inject constructor(
        args.freeArgs = emptyList()
        // Also use KotlinOptions configuration that was directly set to this task
        // as 'compileKotlinArgumentsContributor' has KotlinOptions from linked KotlinCompile task
-        (compilerOptions as KotlinJvmCompilerOptionsDefault).fillCompilerArguments(args)
+        KotlinJvmCompilerOptionsHelper.fillCompilerArguments(compilerOptions, args)

        // Copied from KotlinCompile
        if (reportingSettings().buildReportMode == BuildReportMode.VERBOSE) {
@@ -23,10 +23,8 @@ import org.jetbrains.kotlin.compilerRunner.ArgumentUtils
 import org.jetbrains.kotlin.compilerRunner.GradleCompilerEnvironment
 import org.jetbrains.kotlin.compilerRunner.IncrementalCompilationEnvironment
 import org.jetbrains.kotlin.compilerRunner.OutputItemsCollectorImpl
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompile
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompilerOptions
+import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompilerOptionsDefault
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsOptions
 import org.jetbrains.kotlin.gradle.internal.tasks.allOutputFiles
 import org.jetbrains.kotlin.gradle.logging.GradleErrorMessageCollector
 import org.jetbrains.kotlin.gradle.logging.GradlePrintingMessageCollector
@@ -131,12 +129,12 @@ abstract class Kotlin2JsCompile @Inject constructor(
        K2JSCompilerArguments()

    override fun setupCompilerArgs(args: K2JSCompilerArguments, defaultsOnly: Boolean, ignoreClasspathResolutionErrors: Boolean) {
-        (compilerOptions as KotlinJsCompilerOptionsDefault).fillDefaultValues(args)
+        KotlinJsCompilerOptionsHelper.fillDefaultValues(args)
        super.setupCompilerArgs(args, defaultsOnly = defaultsOnly, ignoreClasspathResolutionErrors = ignoreClasspathResolutionErrors)

        if (defaultsOnly) return

-        (compilerOptions as KotlinJsCompilerOptionsDefault).fillCompilerArguments(args)
+        KotlinJsCompilerOptionsHelper.fillCompilerArguments(compilerOptions, args)
        if (!args.sourceMapPrefix.isNullOrEmpty()) {
            args.sourceMapBaseDirs = sourceMapBaseDir.get().asFile.absolutePath
        }
@@ -65,7 +65,7 @@ abstract class KotlinCompileCommon @Inject constructor(
        K2MetadataCompilerArguments()

    override fun setupCompilerArgs(args: K2MetadataCompilerArguments, defaultsOnly: Boolean, ignoreClasspathResolutionErrors: Boolean) {
-        (compilerOptions as KotlinMultiplatformCommonCompilerOptionsDefault).fillDefaultValues(args)
+        KotlinMultiplatformCommonCompilerOptionsHelper.fillDefaultValues(args)
        super.setupCompilerArgs(args, defaultsOnly = defaultsOnly, ignoreClasspathResolutionErrors = ignoreClasspathResolutionErrors)

        args.moduleName = this@KotlinCompileCommon.moduleName.get()
@@ -86,7 +86,7 @@ abstract class KotlinCompileCommon @Inject constructor(
            refinesPaths = refinesMetadataPaths.map { it.absolutePath }.toTypedArray()
        }

-        (compilerOptions as KotlinMultiplatformCommonCompilerOptionsDefault).fillCompilerArguments(args)
+        KotlinMultiplatformCommonCompilerOptionsHelper.fillCompilerArguments(compilerOptions, args)

        val localExecutionTimeFreeCompilerArgs = executionTimeFreeCompilerArgs
        if (localExecutionTimeFreeCompilerArgs != null) {
@@ -28,10 +28,9 @@ import org.jetbrains.kotlin.cli.common.arguments.DevModeOverwritingStrategies
 import org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments
 import org.jetbrains.kotlin.cli.js.dce.K2JSDce
 import org.jetbrains.kotlin.compilerRunner.runToolInSeparateProcess
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsDceCompilerToolOptions
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsDceCompilerToolOptionsDefault
+import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsDce
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsDceOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsDceCompilerToolOptionsDefault
 import org.jetbrains.kotlin.gradle.logging.GradleKotlinLogger
 import org.jetbrains.kotlin.gradle.utils.absolutePathWithoutExtension
 import org.jetbrains.kotlin.gradle.utils.fileExtensionCasePermutations
@@ -58,7 +57,7 @@ abstract class KotlinJsDce @Inject constructor(
    override fun createCompilerArgs(): K2JSDceArguments = K2JSDceArguments()

    override fun setupCompilerArgs(args: K2JSDceArguments, defaultsOnly: Boolean, ignoreClasspathResolutionErrors: Boolean) {
-        (toolOptions as KotlinJsDceCompilerToolOptionsDefault).fillCompilerArguments(args)
+        KotlinJsDceCompilerToolOptionsHelper.fillCompilerArguments(toolOptions, args)
        args.declarationsToKeep = keep.toTypedArray()
    }