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

generators/tests/org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt

@@ -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 {
+): GeneratedImplOptions {
-    val k2CommonToolCompilerArgumentsFqName = FqName(CommonToolArguments::class.qualifiedName!!)
+    val commonToolBaseImplFqName = FqName("${commonToolOptionsInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
-    val commonToolImplFqName = FqName("${commonToolOptionsInterfaceFqName.asString()}$IMPLEMENTATION_SUFFIX")
+    withPrinterToFile(fileFromFqName(srcDir, commonToolBaseImplFqName)) {
-    withPrinterToFile(fileFromFqName(srcDir, commonToolImplFqName)) {
         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 {
+): GeneratedImplOptions {
-    val k2CommonCompilerArgumentsFqName = FqName(CommonCompilerArguments::class.qualifiedName!!)
     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")

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

@@ -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
-    }
 }

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

@@ -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
+    }
+}

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

@@ -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
-    }
 }

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

@@ -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
+    }
+}

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

@@ -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
-    }
 }

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

@@ -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
+    }
+}

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

@@ -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
-    }
 }

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

@@ -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
+    }
+}

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

@@ -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
-    }
 }

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

@@ -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
+    }
+}

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

@@ -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)
-    }
 }

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

@@ -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)
+    }
+}

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

@@ -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
-    }
 }

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

@@ -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
+    }
+}

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

@@ -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)" }
     }
 }

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

@@ -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) {

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

@@ -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.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompilerOptions
 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
         }

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

@@ -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) {

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

@@ -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.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsDceCompilerToolOptionsDefault
 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()
     }