Add JVM project level compiler options DSL

These options are used as initial convention values for compilerOptions
in target compilations.

^KT-57159 In Progress

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt

@@ -472,7 +472,8 @@ open class IncrementalJvmCompilerRunner(
         isIncremental: Boolean
     ): Services.Builder =
         super.makeServices(args, lookupTracker, expectActualTracker, caches, dirtySources, isIncremental).apply {
-            val targetId = TargetId(args.moduleName!!, "java-production")
+            val moduleName = requireNotNull(args.moduleName) { "'moduleName' is null!" }
+            val targetId = TargetId(moduleName, "java-production")
             val targetToCache = mapOf(targetId to caches.platformCache)
             val incrementalComponents = IncrementalCompilationComponentsImpl(targetToCache)
             register(IncrementalCompilationComponents::class.java, incrementalComponents)

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/CompilerOptionsProjectIT.kt

@@ -0,0 +1,216 @@
+/*
+ * Copyright 2010-2023 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
+
+import org.gradle.api.logging.LogLevel
+import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.testbase.*
+import org.junit.jupiter.api.DisplayName
+import kotlin.io.path.appendText
+
+class CompilerOptionsProjectIT : KGPBaseTest() {
+
+    @DisplayName("Jvm project compiler options are passed to compilation")
+    @JvmGradlePluginTests
+    @GradleTest
+    fun jvmProjectLevelOptions(gradleVersion: GradleVersion) {
+        project(
+            projectName = "simpleProject",
+            gradleVersion = gradleVersion,
+            buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.DEBUG)
+        ) {
+            buildGradle.appendText(
+                //language=Groovy
+                """
+                |
+                |kotlin {
+                |    compilerOptions {
+                |         javaParameters = true
+                |         verbose = false
+                |    }
+                |}
+                """.trimMargin()
+            )
+
+            build("compileKotlin") {
+                assertTasksExecuted(":compileKotlin")
+
+                val compilationArgs = output.lineSequence().first { it.contains("Kotlin compiler args:") }
+
+                assert(compilationArgs.contains("-java-parameters")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-progressive': $compilationArgs"
+                }
+
+                // '-verbose' by default will be set to 'true' by debug log level
+                assert(!compilationArgs.contains("-verbose")) {
+                    printBuildOutput()
+                    "Compiler arguments contains '-verbose': $compilationArgs"
+                }
+            }
+        }
+    }
+
+    @DisplayName("languageSettings should not override project options when not configured")
+    @JvmGradlePluginTests
+    @GradleTest
+    fun nonConfiguredLanguageSettings(gradleVersion: GradleVersion) {
+        project(
+            projectName = "simpleProject",
+            gradleVersion = gradleVersion,
+            buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.DEBUG)
+        ) {
+            buildGradle.appendText(
+                //language=Groovy
+                """
+                |
+                |kotlin {
+                |    compilerOptions {
+                |         languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_0
+                |         apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_0
+                |         progressiveMode = true
+                |         optIn.add("my.custom.OptInAnnotation")
+                |         freeCompilerArgs.add("-Xuse-ir")
+                |    }
+                |}
+                """.trimMargin()
+            )
+
+            build("compileKotlin") {
+                assertTasksExecuted(":compileKotlin")
+
+                val compilationArgs = output.lineSequence().first { it.contains("Kotlin compiler args:") }
+
+                assert(compilationArgs.contains("-language-version 2.0")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-language-version 2.0': $compilationArgs"
+                }
+
+                assert(compilationArgs.contains("-api-version 2.0")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-api-version 2.0': $compilationArgs"
+                }
+
+                assert(compilationArgs.contains("-progressive")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-progressive': $compilationArgs"
+                }
+
+                assert(compilationArgs.contains("-opt-in my.custom.OptInAnnotation")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-opt-in my.custom.OptInAnnotation': $compilationArgs"
+                }
+
+                assert(compilationArgs.contains("-Xuse-ir")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-Xuse-ir': $compilationArgs"
+                }
+            }
+        }
+    }
+
+    @DisplayName("languageSettings override project options when configured")
+    @JvmGradlePluginTests
+    @GradleTest
+    fun configuredLanguageSettings(gradleVersion: GradleVersion) {
+        project(
+            projectName = "simpleProject",
+            gradleVersion = gradleVersion,
+            buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.DEBUG)
+        ) {
+            buildGradle.appendText(
+                //language=Groovy
+                """
+                |
+                |kotlin {
+                |    compilerOptions {
+                |         languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_0
+                |         apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_0
+                |         progressiveMode = true
+                |         optIn.add("my.custom.OptInAnnotation")
+                |         freeCompilerArgs.add("-Xuse-ir")
+                |    }
+                |    
+                |    sourceSets.all {
+                |        languageSettings {
+                |            languageVersion = '1.9'
+                |            apiVersion = '1.9'
+                |            progressiveMode = false
+                |            optInAnnotationsInUse.add("another.CustomOptInAnnotation")
+                |            enableLanguageFeature("UnitConversionsOnArbitraryExpressions")
+                |        }
+                |    }
+                |}
+                """.trimMargin()
+            )
+
+            build("compileKotlin") {
+                assertTasksExecuted(":compileKotlin")
+
+                val compilationArgs = output.lineSequence().first { it.contains("Kotlin compiler args:") }
+
+                assert(compilationArgs.contains("-language-version 1.9")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-language-version 1.9': $compilationArgs"
+                }
+
+                assert(compilationArgs.contains("-api-version 1.9")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-api-version 2.0': $compilationArgs"
+                }
+
+                assert(!compilationArgs.contains("-progressive")) {
+                    printBuildOutput()
+                    "Compiler arguments contains '-progressive': $compilationArgs"
+                }
+
+                assert(compilationArgs.contains("-opt-in another.CustomOptInAnnotation")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-opt-in another.CustomOptInAnnotation': $compilationArgs"
+                }
+
+                assert(compilationArgs.contains("-XXLanguage:+UnitConversionsOnArbitraryExpressions")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-XXLanguage:+UnitConversionsOnArbitraryExpressions': $compilationArgs"
+                }
+            }
+        }
+    }
+
+    @DisplayName("moduleName overrides compilation moduleName")
+    @JvmGradlePluginTests
+    @GradleTest
+    fun moduleNameProject(gradleVersion: GradleVersion) {
+        project(
+            projectName = "simpleProject",
+            gradleVersion = gradleVersion,
+            buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.DEBUG)
+        ) {
+            buildGradle.appendText(
+                //language=Groovy
+                """
+                |
+                |kotlin {
+                |    compilerOptions {
+                |         moduleName = "customModule"
+                |    }
+                |}
+                """.trimMargin()
+            )
+
+            build("compileKotlin") {
+                assertTasksExecuted(":compileKotlin")
+
+                val compilationArgs = output.lineSequence().first { it.contains("Kotlin compiler args:") }
+
+                assert(compilationArgs.contains("-module-name customModule")) {
+                    printBuildOutput()
+                    "Compiler arguments does not contain '-module-name customModule': $compilationArgs"
+                }
+            }
+        }
+    }
+}

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

@@ -15,11 +15,9 @@ import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.jvm.toolchain.JavaToolchainSpec
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.plugin.*
-import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsSingleTargetPreset
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmDefaultProjectModelContainer
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinPm20ProjectExtension
 import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatsService
 import org.jetbrains.kotlin.gradle.targets.js.calculateJsCompilerType
@@ -171,6 +169,17 @@ abstract class KotlinJvmProjectExtension(project: Project) : KotlinSingleJavaTar
         internal set
 
     open fun target(body: KotlinWithJavaTarget<KotlinJvmOptions, KotlinJvmCompilerOptions>.() -> Unit) = target.run(body)
+
+    val compilerOptions: KotlinJvmCompilerOptions =
+        project.objects.newInstance(KotlinJvmCompilerOptionsDefault::class.java)
+
+    fun compilerOptions(configure: Action<KotlinJvmCompilerOptions>) {
+        configure.execute(compilerOptions)
+    }
+
+    fun compilerOptions(configure: KotlinJvmCompilerOptions.() -> Unit) {
+        configure(compilerOptions)
+    }
 }
 
 abstract class Kotlin2JsProjectExtension(project: Project) : KotlinSingleJavaTargetExtension(project) {

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

@@ -68,7 +68,6 @@ internal open class KotlinJvmCompilerArgumentsContributor(
 ) : AbstractKotlinCompileArgumentsContributor<K2JVMCompilerArguments>(taskProvider) {
 
     private val taskName = taskProvider.taskName
-    private val moduleName = taskProvider.moduleName
     private val friendPaths = taskProvider.friendPaths
     private val compileClasspath = taskProvider.compileClasspath
     private val destinationDir = taskProvider.destinationDir
@@ -82,7 +81,7 @@ internal open class KotlinJvmCompilerArgumentsContributor(
 
         super.contributeArguments(args, flags)
 
-        args.moduleName = moduleName
+        args.moduleName = compilerOptions.moduleName.orNull
         logger.kotlinDebug { "$taskName | args.moduleName = ${args.moduleName}" }
 
         args.friendPaths = friendPaths.files.map { it.absolutePath }.toTypedArray()

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

@@ -63,7 +63,21 @@ internal open class KotlinJvmPlugin(
                 disambiguationClassifier = null // don't add anything to the task names
             }
 
-        (project.kotlinExtension as KotlinJvmProjectExtension).target = target
+        val kotlinExtension = project.kotlinExtension as KotlinJvmProjectExtension
+        kotlinExtension.target = target
+        kotlinExtension.compilerOptions.verbose.convention(project.logger.isDebugEnabled)
+        target.compilations.configureEach {
+            KotlinJvmCompilerOptionsHelper.syncOptionsAsConvention(
+                from = kotlinExtension.compilerOptions,
+                into = it.compilerOptions.options
+            )
+            it.compilerOptions.options.moduleName.convention(
+                kotlinExtension.compilerOptions.moduleName.orElse(
+                    @Suppress("DEPRECATION")
+                    project.providers.provider { it.moduleName }
+                )
+            )
+        }
 
         super.apply(project)
 

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.gradle.tasks.toSingleCompilerPluginOptions
 import org.jetbrains.kotlin.project.model.LanguageSettings
 import org.jetbrains.kotlin.statistics.metrics.BooleanMetrics
 import org.jetbrains.kotlin.statistics.metrics.StringMetrics
+import kotlin.properties.Delegates
 
 internal class DefaultLanguageSettingsBuilder : LanguageSettingsBuilder {
     private var languageVersionImpl: LanguageVersion? = null
@@ -48,7 +49,12 @@ internal class DefaultLanguageSettingsBuilder : LanguageSettingsBuilder {
             }
         }
 
-    override var progressiveMode: Boolean = false
+    // By using 'observable' delegate we are tracking value set by user and not default value,
+    // so we could propagate it to the compiler options only if it was configured explicitly
+    internal var setByUserProgressiveMode: Boolean? = null
+    override var progressiveMode: Boolean by Delegates.observable(false) { _, _, newValue ->
+        setByUserProgressiveMode = newValue
+    }
 
     private val enabledLanguageFeaturesImpl = mutableSetOf<LanguageFeature>()
 
@@ -102,25 +108,36 @@ internal class DefaultLanguageSettingsBuilder : LanguageSettingsBuilder {
 
 internal fun applyLanguageSettingsToCompilerOptions(
     languageSettingsBuilder: LanguageSettings,
-    compilerOptions: KotlinCommonCompilerOptions
+    compilerOptions: KotlinCommonCompilerOptions,
+    addFreeCompilerArgsAsConvention: Boolean = true,
 ) = with(compilerOptions) {
-    languageVersion.convention(languageSettingsBuilder.languageVersion?.let { KotlinVersion.fromVersion(it) })
+    val languageSettingsBuilderDefault = languageSettingsBuilder as DefaultLanguageSettingsBuilder
-    apiVersion.convention(languageSettingsBuilder.apiVersion?.let { KotlinVersion.fromVersion(it) })
+    languageSettingsBuilderDefault.languageVersion?.let {
-    progressiveMode.convention(languageSettingsBuilder.progressiveMode)
+        languageVersion.convention(KotlinVersion.fromVersion(it))
-    optIn.addAll(languageSettingsBuilder.optInAnnotationsInUse)
+    }
+    languageSettingsBuilderDefault.apiVersion?.let {
+        apiVersion.convention(KotlinVersion.fromVersion(it))
+    }
+    languageSettingsBuilderDefault.setByUserProgressiveMode?.let {
+        progressiveMode.convention(it)
+    }
+    if (languageSettingsBuilder.optInAnnotationsInUse.isNotEmpty()) optIn.addAll(languageSettingsBuilder.optInAnnotationsInUse)
 
-    val freeArgs = mutableListOf<String>().apply {
+    val freeArgs = mutableListOf<String>()
-        languageSettingsBuilder.enabledLanguageFeatures.forEach { featureName ->
+    languageSettingsBuilder.enabledLanguageFeatures.forEach { featureName ->
-            add("-XXLanguage:+$featureName")
+        freeArgs.add("-XXLanguage:+$featureName")
-        }
+    }
+    freeArgs.addAll(languageSettingsBuilderDefault.freeCompilerArgs)
 
-        if (languageSettingsBuilder is DefaultLanguageSettingsBuilder) {
+    if (freeArgs.isNotEmpty()) {
-            addAll(languageSettingsBuilder.freeCompilerArgs)
+        if (addFreeCompilerArgsAsConvention) {
+            freeCompilerArgs.convention(freeArgs)
+        } else {
+            freeCompilerArgs.addAll(freeArgs)
         }
     }
 
-    freeCompilerArgs.addAll(freeArgs)
+    // TODO: Fix it - get actual values on execution
-
     KotlinBuildStatsService.getInstance()?.apply {
         report(BooleanMetrics.KOTLIN_PROGRESSIVE_MODE, languageSettingsBuilder.progressiveMode)
         apiVersion.orNull?.also { v -> report(StringMetrics.KOTLIN_API_VERSION, v.version) }

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

@@ -41,6 +41,19 @@ open class KotlinJvmTargetConfigurator :
         }
     }
 
+    override fun configureCompilations(target: KotlinJvmTarget) {
+        super.configureCompilations(target)
+
+        target.compilations.configureEach {
+            it.compilerOptions.options.moduleName.convention(
+                target.project.providers.provider {
+                    @Suppress("DEPRECATION")
+                    it.moduleName
+                }
+            )
+        }
+    }
+
     override val testRunClass: Class<KotlinJvmTestRun>
         get() = KotlinJvmTestRun::class.java
 

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

@@ -56,6 +56,13 @@ class KotlinJvmWithJavaTargetPreset(
             Kotlin2JvmSourceSetProcessor(KotlinTasksProvider(), KotlinCompilationInfo(compilation))
         }
 
+        target.compilations.configureEach {
+            it.compilerOptions.options.moduleName.convention(
+                @Suppress("DEPRECATION")
+                project.providers.provider { it.moduleName }
+            )
+        }
+
         target.compilations.getByName("test").run {
             val main = target.compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
 

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

@@ -69,10 +69,8 @@ abstract class KotlinCompile @Inject constructor(
     KotlinCompilationTask<KotlinJvmCompilerOptions>,
     UsesKotlinJavaToolchain {
 
-    init {
+    @get:Internal // covered by compiler options
-        compilerOptions.moduleName.convention(moduleName)
+    abstract override val moduleName: Property<String>
-        compilerOptions.verbose.convention(logger.isDebugEnabled)
-    }
 
     final override val kotlinOptions: KotlinJvmOptions = KotlinJvmOptionsCompat(
         { this },

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

@@ -23,7 +23,6 @@ open class KotlinCompileArgumentsProvider<T : AbstractKotlinCompile<out CommonCo
 class KotlinJvmCompilerArgumentsProvider
     (taskProvider: KotlinCompile) : KotlinCompileArgumentsProvider<KotlinCompile>(taskProvider) {
     val taskName: String = taskProvider.name
-    val moduleName: String = taskProvider.moduleName.get()
     val friendPaths: FileCollection = taskProvider.friendPaths
     val compileClasspath: Iterable<File> = taskProvider.libraries
     val destinationDir: File = taskProvider.destinationDirectory.get().asFile

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

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.gradle.report.BuildMetricsService
 import org.jetbrains.kotlin.gradle.report.BuildReportsService
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.KOTLIN_BUILD_DIR_NAME
+import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
 import org.jetbrains.kotlin.gradle.utils.providerWithLazyConvention
 import org.jetbrains.kotlin.project.model.LanguageSettings
 
@@ -50,7 +51,11 @@ internal abstract class AbstractKotlinCompileConfig<TASK : AbstractKotlinCompile
                     if (it is KaptGenerateStubsTask) return@configure
 
                     applyLanguageSettingsToCompilerOptions(
-                        languageSettings.get(), (it as org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>).compilerOptions
+                        languageSettings.get(),
+                        (it as org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>).compilerOptions,
+                        // KotlinJsIrTarget and KotlinJsIrTargetConfigurator add additional freeCompilerArgs essentially
+                        // always overwriting convention value
+                        addFreeCompilerArgsAsConvention = it !is Kotlin2JsCompile
                     )
                 }
             }