[IR][cache] Fix for https://youtrack.jetbrains.com/issue/KT-44764

The .konanLibrary is cached for each declaration for performance purposes, but it is only ok to do it
after IR has been lowered to its final state (or at least when declarations aren't being moved around),
so the fix respects that by only taking .konanLibrary of a IrFile (it is assumed that files stay on their place
during entire backend lowering procedure).

(cherry picked from commit e021138368b48e306ba99a96f47d93ecbe039f4d)

.gitignore

@@ -54,6 +54,7 @@ build/
 .idea/artifacts/kotlin_test_js_ir_*
 .idea/artifacts/kotlin_stdlib_wasm_*
 .idea/jarRepositories.xml
+.idea/csv-plugin.xml
 kotlin-ultimate/
 node_modules/
 .rpt2_cache/
@@ -63,4 +64,4 @@ buildSrcTmp/
 distTmp/
 outTmp/
 /test.output
-/kotlin-native/dist
+/kotlin-native/dist

.idea/artifacts/kotlinx_cli_jvm_1_5_255_SNAPSHOT.xml

@@ -1,8 +1,6 @@
 <component name="ArtifactManager">
   <artifact type="jar" name="kotlinx.cli-jvm-1.5.255-SNAPSHOT">
     <output-path>$PROJECT_DIR$/kotlin-native/endorsedLibraries/kotlinx.cli/build/libs</output-path>
-    <root id="archive" name="kotlinx.cli-jvm-1.5.255-SNAPSHOT.jar">
-      <element id="module-output" name="kotlin.kotlin-native.endorsedLibraries.kotlinx.cli.jvmMain" />
-    </root>
+    <root id="archive" name="kotlinx.cli-jvm-1.5.255-SNAPSHOT.jar" />
   </artifact>
 </component>

.idea/runConfigurations/Generate_All_Tests.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Generate All Tests" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="Generate All Tests" type="GradleRunConfiguration" factoryName="Gradle" folderName="Generators">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -17,4 +17,4 @@
     </ExternalSystemSettings>
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/Generate_Compiler_Tests.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Generate Compiler Tests" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="Generate Compiler Tests" type="GradleRunConfiguration" factoryName="Gradle" folderName="Generators">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$/compiler" />

.idea/runConfigurations/Generate_FIR_Checker_Components_and_FIR_IDE_Diagnostics.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Generate FIR Checker Components and FIR/IDE Diagnostics" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="Generate FIR Checker Components and FIR/IDE Diagnostics" type="GradleRunConfiguration" factoryName="Gradle" folderName="Generators">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -21,4 +21,4 @@
     <DebugAllEnabled>false</DebugAllEnabled>
     <method v="2" />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/Generate_standard_library_sources.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Generate standard library sources" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="Generate standard library sources" type="GradleRunConfiguration" factoryName="Gradle" folderName="Stdlib">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$/libraries/tools/kotlin-stdlib-gen" />
@@ -17,4 +17,4 @@
     </ExternalSystemSettings>
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/IDEA.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA" type="GradleRunConfiguration" factoryName="Gradle" singleton="true">
+  <configuration default="false" name="IDEA" type="GradleRunConfiguration" factoryName="Gradle" singleton="true" folderName="IDEA">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -17,4 +17,4 @@
     </ExternalSystemSettings>
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/IDEA_Ultimate.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA Ultimate" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="IDEA Ultimate" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -17,4 +17,4 @@
     </ExternalSystemSettings>
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/IDEA_Ultimate__No_ProcessCanceledException__.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA Ultimate (No ProcessCanceledException) " type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="IDEA Ultimate (No ProcessCanceledException) " type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -17,4 +17,4 @@
     </ExternalSystemSettings>
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA (No ProcessCanceledException)" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="IDEA (No ProcessCanceledException)" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -17,4 +17,4 @@
     </ExternalSystemSettings>
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/IDEA__Not_Internal_.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA (Not Internal)" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="IDEA (Not Internal)" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -16,4 +16,4 @@
       <option name="vmOptions" value="" />
     </ExternalSystemSettings>
   </configuration>
-</component>
+</component>

.idea/runConfigurations/Test__KMM.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test: KMM" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="Test: KMM" type="GradleRunConfiguration" factoryName="Gradle" folderName="Tests">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -17,4 +17,4 @@
     </ExternalSystemSettings>
     <method v="2" />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/Test__public_API_binary_compatibility_validator__overwrite_results.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test: public API binary compatibility validator, overwrite results" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="Test: public API binary compatibility validator, overwrite results" type="GradleRunConfiguration" factoryName="Gradle" folderName="Stdlib">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$/libraries/tools/binary-compatibility-validator" />
@@ -18,4 +18,4 @@
     </ExternalSystemSettings>
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/Test__stdlib_js_public_kotlin_api_test__overwrite_results.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test: stdlib-js public kotlin api test, overwrite results" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="Test: stdlib-js public kotlin api test, overwrite results" type="GradleRunConfiguration" factoryName="Gradle" folderName="Stdlib">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -19,4 +19,4 @@
     <GradleScriptDebugEnabled>false</GradleScriptDebugEnabled>
     <method v="2" />
   </configuration>
-</component>
+</component>

benchmarks/build.gradle.kts

@@ -92,18 +92,16 @@ benchmark {
     }
 }
 
-tasks.named("classes") {
-    doLast {
-        tasks.named("mainBenchmarkJar", Zip::class.java) {
-            isZip64 = true
-            archiveName = "benchmarks.jar"
-        }
-        listOf("mainBenchmark", "mainFirBenchmark", "mainNiBenchmark").forEach {
-            tasks.named(it, JavaExec::class.java) {
-                systemProperty("idea.home.path", intellijRootDir().canonicalPath)
-            }
-        }
-    }
+tasks.matching { it is Zip && it.name == "mainBenchmarkJar" }.configureEach {
+    this as Zip
+    isZip64 = true
+    archiveFileName.set("benchmarks.jar")
+}
+
+val benchmarkTasks = listOf("mainBenchmark", "mainFirBenchmark", "mainNiBenchmark")
+tasks.matching { it is JavaExec && it.name in benchmarkTasks }.configureEach {
+    this as JavaExec
+    systemProperty("idea.home.path", intellijRootDir().canonicalPath)
 }
 
 tasks.register<JavaExec>("runBenchmark") {

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
-import org.jetbrains.kotlin.fir.createSession
+import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
@@ -150,7 +150,7 @@ abstract class AbstractSimpleFileBenchmark {
     private fun analyzeGreenFileIr(bh: Blackhole) {
         val scope = GlobalSearchScope.filesScope(env.project, listOf(file.virtualFile))
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
-        val session = createSession(env, scope)
+        val session = createSessionForTests(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
 

build-common/src/org/jetbrains/kotlin/build/JvmBuildMetaInfo.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.build
 
+import org.jetbrains.kotlin.load.kotlin.JvmBytecodeBinaryVersion
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
 
 /**

build-common/src/org/jetbrains/kotlin/build/generatedFiles.kt

@@ -26,11 +26,13 @@ open class GeneratedFile(
     val outputFile: File
 ) {
     val sourceFiles = sourceFiles.sortedBy { it.path }
+
+    override fun toString(): String = "${this::class.java.simpleName}: $outputFile"
 }
 
-class GeneratedJvmClass (
-        sourceFiles: Collection<File>,
-        outputFile: File
+class GeneratedJvmClass(
+    sourceFiles: Collection<File>,
+    outputFile: File
 ) : GeneratedFile(sourceFiles, outputFile) {
     val outputClass = LocalFileKotlinClass.create(outputFile).sure {
         "Couldn't load KotlinClass from $outputFile; it may happen because class doesn't have valid Kotlin annotations"

build.gradle.kts

@@ -182,7 +182,7 @@ extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
 extra["versions.completion-ranking-kotlin"] = "0.1.3"
-extra["versions.r8"] = "2.0.88"
+extra["versions.r8"] = "2.1.75"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -242,6 +242,7 @@ extra["compilerModules"] = arrayOf(
     ":compiler:ir.psi2ir",
     ":compiler:ir.backend.common",
     ":compiler:backend.jvm",
+    ":compiler:backend.jvm:backend.jvm.entrypoint",
     ":compiler:backend.js",
     ":compiler:backend.wasm",
     ":compiler:ir.serialization.common",
@@ -564,10 +565,13 @@ allprojects {
     }
 }
 
-gradle.buildFinished {
-    val taskGraph = gradle?.taskGraph
-    if (taskGraph != null) {
-        taskGraph.allTasks
+if ((gradle.startParameter as? org.gradle.api.internal.StartParameterInternal)?.isConfigurationCache != true) {
+    // TODO: remove it once Gradle is bumped to 6.8:
+    // See https://docs.gradle.org/6.8/release-notes.html#more-cache-hits-when-empty-directories-are-present
+    gradle.buildFinished {
+        val taskGraph = gradle?.taskGraph
+        if (taskGraph != null) {
+            taskGraph.allTasks
                 .filterIsInstance<SourceTask>()
                 .filter { it.didWork }
                 .forEach {
@@ -577,6 +581,7 @@ gradle.buildFinished {
                         }
                     }
                 }
+        }
     }
 }
 
@@ -620,17 +625,12 @@ val ideaPlugin by task<Task> {
 }
 
 tasks {
-    named("clean") {
-        doLast {
-            delete("$buildDir/repo")
-            delete(distDir)
-        }
+    named<Delete>("clean") {
+        delete += setOf("$buildDir/repo", distDir)
     }
 
-    register("cleanupArtifacts") {
-        doLast {
-            delete(artifactsDir)
-        }
+    register<Delete>("cleanupArtifacts") {
+        delete = setOf(artifactsDir)
     }
 
     listOf("clean", "assemble", "install").forEach { taskName ->
@@ -729,10 +729,12 @@ tasks {
     register("scriptingTest") {
         dependsOn("dist")
         dependsOn(":kotlin-script-util:test")
-        dependsOn(":kotlin-scripting-compiler-embeddable:test")
+        dependsOn(":kotlin-scripting-compiler:test")
+        dependsOn(":kotlin-scripting-compiler:testWithIr")
         dependsOn(":kotlin-scripting-common:test")
         dependsOn(":kotlin-scripting-jvm:test")
         dependsOn(":kotlin-scripting-jvm-host-test:test")
+        dependsOn(":kotlin-scripting-jvm-host-test:testWithIr")
         dependsOn(":kotlin-scripting-dependencies:test")
         dependsOn(":kotlin-scripting-dependencies-maven:test")
         dependsOn(":kotlin-scripting-jsr223-test:test")
@@ -740,6 +742,7 @@ tasks {
 //        dependsOn(":kotlin-scripting-jvm-host-test:embeddableTest")
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
+        dependsOn(":kotlin-main-kts-test:testWithIr")
         dependsOn(":kotlin-scripting-ide-services-test:test")
         dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
         dependsOn(":kotlin-scripting-js-test:test")
@@ -891,17 +894,11 @@ tasks {
         if (Ide.IJ()) {
             dependsOn(
                 ":libraries:tools:new-project-wizard:test",
-                ":libraries:tools:new-project-wizard:new-project-wizard-cli:test",
-                ":idea:idea-new-project-wizard:test" // Temporary here. Remove after enabling builds for ideaIntegrationsTests
+                ":libraries:tools:new-project-wizard:new-project-wizard-cli:test"
             )
         }
     }
 
-    register("ideaIntegrationsTests") {
-        if (Ide.IJ()) {
-            dependsOn(":idea:idea-new-project-wizard:test")
-        }
-    }
 
     register("kaptIdeTest") {
         dependsOn(":kotlin-annotation-processing:test")
@@ -1208,7 +1205,8 @@ val Jar.outputFile: File
 val Project.sourceSetsOrNull: SourceSetContainer?
     get() = convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets
 
-val disableVerificationTasks = System.getProperty("disable.verification.tasks") == "true"
+val disableVerificationTasks = providers.systemProperty("disable.verification.tasks")
+    .forUseAtConfigurationTime().orNull?.toBoolean() ?: false
 if (disableVerificationTasks) {
     gradle.taskGraph.whenReady {
         allTasks.forEach {

buildSrc/build.gradle.kts

@@ -161,7 +161,7 @@ dependencies {
 
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 
-    implementation("org.gradle:test-retry-gradle-plugin:1.1.9")
+    implementation("org.gradle:test-retry-gradle-plugin:1.2.0")
     implementation("com.gradle.enterprise:test-distribution-gradle-plugin:1.2.1")
 
     compileOnly(gradleApi())
@@ -199,6 +199,7 @@ java {
 }
 
 tasks.withType<KotlinCompile>().configureEach {
+    kotlinOptions.allWarningsAsErrors = true
     kotlinOptions.freeCompilerArgs += listOf(
         "-Xopt-in=kotlin.RequiresOptIn",
         "-Xskip-runtime-version-check",
@@ -262,4 +263,4 @@ gradlePlugin {
             implementationClass = "org.jetbrains.kotlin.NativeInteropPlugin"
         }
     }
-}
+}

buildSrc/src/main/kotlin/InstrumentJava.kt

@@ -0,0 +1,51 @@
+import org.gradle.api.Action
+import org.gradle.api.Task
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.SourceSet
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.kotlin.dsl.provideDelegate
+import org.gradle.kotlin.dsl.withGroovyBuilder
+
+/*
+ * Copyright 2010-2021 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.
+ */
+
+class InstrumentJava(@Transient val javaInstrumentator: Configuration, @Transient val sourceSet: SourceSet) : Action<Task> {
+    private val instrumentatorClasspath: String by lazy {
+        javaInstrumentator.asPath
+    }
+
+    private val srcDirs: FileCollection by lazy {
+        sourceSet.allJava.sourceDirectories
+    }
+
+    override fun execute(task: Task) {
+        require(task is JavaCompile) { "$task is not of type JavaCompile!" }
+        task.doLast {
+            task.ant.withGroovyBuilder {
+                "taskdef"(
+                    "name" to "instrumentIdeaExtensions",
+                    "classpath" to instrumentatorClasspath,
+                    "loaderref" to "java2.loader",
+                    "classname" to "com.intellij.ant.InstrumentIdeaExtensions"
+                )
+            }
+
+            val javaSourceDirectories = srcDirs.filter { it.exists() }
+
+            task.ant.withGroovyBuilder {
+                javaSourceDirectories.forEach { directory ->
+                    "instrumentIdeaExtensions"(
+                        "srcdir" to directory,
+                        "destdir" to task.destinationDir,
+                        "classpath" to task.classpath.asPath,
+                        "includeantruntime" to false,
+                        "instrumentNotNull" to true
+                    )
+                }
+            }
+        }
+    }
+}

buildSrc/src/main/kotlin/artifacts.kt

@@ -25,7 +25,6 @@ import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.Upload
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
-import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.kotlin.dsl.*
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
 import plugins.KotlinBuildPublishingPlugin

buildSrc/src/main/kotlin/copyright.kt

@@ -8,48 +8,37 @@ package tasks
 import groovy.util.Node
 import groovy.util.XmlParser
 import org.gradle.api.DefaultTask
-import org.gradle.api.Project
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputFile
 import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
-import java.io.File
 import java.util.*
 
-
-
-
-open class WriteCopyrightToFile : DefaultTask() {
-
+abstract class WriteCopyrightToFile : DefaultTask() {
     @InputFile
-    var path = project.file("${project.rootDir}/.idea/copyright/apache.xml")
+    val path = project.file("${project.rootDir}/.idea/copyright/apache.xml")
 
-    @OutputFile
-    var outputFile: File? = null
+    @get:OutputFile
+    abstract val outputFile: RegularFileProperty
 
-    @Input
-    var commented: Boolean = true
+    @get:Input
+    val commented: Property<Boolean> = project.objects.property(Boolean::class.java).convention(true)
 
     @TaskAction
     fun write() {
-        if (commented) {
-            outputFile!!.writeText(project.readCopyrightCommented())
-        } else {
-            outputFile!!.writeText(project.readCopyright())
-        }
+        val file = outputFile.asFile.get()
+        file.writeText(if (commented.get()) readCopyrightCommented() else readCopyright())
     }
 
-
-    fun Project.readCopyright(): String {
-        val file = rootDir.resolve(".idea/copyright/apache.xml")
-
-        assert(file.exists()) {
-            "File $file with copyright not found"
+    private fun readCopyright(): String {
+        assert(path.exists()) {
+            "File $path with copyright not found"
         }
 
-
         val xmlParser = XmlParser()
-        val node = xmlParser.parse(file)
+        val node = xmlParser.parse(path)
         assert(node.attribute("name") == "CopyrightManager") {
             "Format changed occasionally?"
         }
@@ -59,7 +48,7 @@ open class WriteCopyrightToFile : DefaultTask() {
         return noticeNode.attribute("value").toString().replace("&#36;today.year", GregorianCalendar()[Calendar.YEAR].toString())
     }
 
-    fun Project.readCopyrightCommented(): String {
+    private fun readCopyrightCommented(): String {
         return "/*\n" + readCopyright().prependIndent(" * ") + "\n */"
     }
 }

buildSrc/src/main/kotlin/embeddable.kt

@@ -128,7 +128,6 @@ fun Project.rewriteDepsToShadedJar(
         archiveClassifier.set("original")
     }
 
-    val compilerDummyJarFile by lazy { configurations.getAt("compilerDummyJar").singleFile }
 
     shadowJarTask.configure {
         dependsOn(originalJarTask)
@@ -136,7 +135,8 @@ fun Project.rewriteDepsToShadedJar(
 
         // When Gradle traverses the inputs, reject the shaded compiler JAR,
         // which leads to the content of that JAR being excluded as well:
-        exclude { it.file == compilerDummyJarFile }
+        val compilerDummyJarFile = project.provider { configurations.getByName("compilerDummyJar").singleFile }
+        exclude { it.file == compilerDummyJarFile.get() }
 
         archiveClassifier.set("original")
         body()

buildSrc/src/main/kotlin/instrument.kt

@@ -21,15 +21,18 @@ import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
+import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.internal.ConventionTask
 import org.gradle.api.plugins.ExtensionAware
 import org.gradle.api.tasks.*
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.kotlin.dsl.*
 import java.io.File
+import javax.inject.Inject
 
 fun Project.configureFormInstrumentation() {
-    plugins.matching { it::class.java.canonicalName.startsWith("org.jetbrains.kotlin.gradle.plugin") }.all {
+    plugins.matching { it::class.java.canonicalName.startsWith("org.jetbrains.kotlin.gradle.plugin") }.configureEach {
         // When we change the output classes directory, Gradle will automatically configure
         // the test compile tasks to use the instrumented classes. Normally this is fine,
         // however, it causes problems for Kotlin projects:
@@ -42,31 +45,36 @@ fun Project.configureFormInstrumentation() {
 
         // This fails when we change the classes dir. The easiest fix is to prepend the
         // classes from the "friendly directory" to the compile classpath.
-        val testCompile = tasks.findByName("compileTestKotlin") as AbstractCompile?
-        testCompile?.doFirst {
-            val originalClassesDirs = files((mainSourceSet as ExtensionAware).extra.get("classesDirsCopy"))
+        if (!tasks.names.contains("compileTestKotlin")) return@configureEach
 
-            testCompile.classpath = (testCompile.classpath
-                    - mainSourceSet.output.classesDirs
-                    + originalClassesDirs)
+        tasks.named<AbstractCompile>("compileTestKotlin") {
+            val objects = project.objects
+            val classesDirs = project.mainSourceSet.output.classesDirs
+            val classesDirsCopy = project.provider { (mainSourceSet as ExtensionAware).extra.get("classesDirsCopy") }
+            doFirst {
+                val originalClassesDirs = objects.fileCollection().from(classesDirsCopy)
 
-            // Since Kotlin 1.3.60, the friend paths available to the test compile task are calculated as the main source set's
-            // output.classesDirs. Since the classesDirs are excluded from the classpath (replaced by the originalClassesDirs),
-            // in order to be able to access the internals of 'main', tests need to receive the original classes dirs as a
-            // -Xfriend-paths compiler argument as well.
-            fun addFreeCompilerArgs(kotlinCompileTask: AbstractCompile, vararg args: String) {
-                val getKotlinOptions = kotlinCompileTask::class.java.getMethod("getKotlinOptions")
-                val kotlinOptions = getKotlinOptions(kotlinCompileTask)
+                classpath = (classpath
+                        - classesDirs
+                        + originalClassesDirs)
 
-                val getFreeCompilerArgs = kotlinOptions::class.java.getMethod("getFreeCompilerArgs")
-                val freeCompilerArgs = getFreeCompilerArgs(kotlinOptions) as List<*>
+                // Since Kotlin 1.3.60, the friend paths available to the test compile task are calculated as the main source set's
+                // output.classesDirs. Since the classesDirs are excluded from the classpath (replaced by the originalClassesDirs),
+                // in order to be able to access the internals of 'main', tests need to receive the original classes dirs as a
+                // -Xfriend-paths compiler argument as well.
+                fun addFreeCompilerArgs(kotlinCompileTask: AbstractCompile, vararg args: String) {
+                    val getKotlinOptions = kotlinCompileTask::class.java.getMethod("getKotlinOptions")
+                    val kotlinOptions = getKotlinOptions(kotlinCompileTask)
 
-                val setFreeCompilerArgs = kotlinOptions::class.java.getMethod("setFreeCompilerArgs", List::class.java)
-                setFreeCompilerArgs(kotlinOptions, freeCompilerArgs + args)
+                    val getFreeCompilerArgs = kotlinOptions::class.java.getMethod("getFreeCompilerArgs")
+                    val freeCompilerArgs = getFreeCompilerArgs(kotlinOptions) as List<*>
+
+                    val setFreeCompilerArgs = kotlinOptions::class.java.getMethod("setFreeCompilerArgs", List::class.java)
+                    setFreeCompilerArgs(kotlinOptions, freeCompilerArgs + args)
+                }
+                addFreeCompilerArgs(this as AbstractCompile, "-Xfriend-paths=" + originalClassesDirs.joinToString(",")  { it.absolutePath })
             }
-            addFreeCompilerArgs(testCompile, "-Xfriend-paths=" + originalClassesDirs.joinToString(",")  { it.absolutePath })
         }
-
     }
 
     val instrumentationClasspathCfg = configurations.create("instrumentationClasspath")
@@ -76,7 +84,7 @@ fun Project.configureFormInstrumentation() {
     }
 
     afterEvaluate {
-        sourceSets.all { sourceSetParam ->
+        sourceSets.forEach { sourceSetParam ->
             // This copy will ignore filters, but they are unlikely to be used.
             val classesDirs = (sourceSetParam.output.classesDirs as ConfigurableFileCollection).from as Collection<Any>
 
@@ -88,66 +96,82 @@ fun Project.configureFormInstrumentation() {
             (sourceSetParam.output.classesDirs as ConfigurableFileCollection).setFrom(instrumentedClassesDir)
             val instrumentTask =
                 project.tasks.register(sourceSetParam.getTaskName("instrument", "classes"), IntelliJInstrumentCodeTask::class.java) {
-                    dependsOn(sourceSetParam.classesTaskName).onlyIf { !classesDirsCopy.isEmpty }
-                    sourceSet = sourceSetParam
-                    instrumentationClasspath = instrumentationClasspathCfg
-                    originalClassesDirs = classesDirsCopy
-                    output = instrumentedClassesDir
-                    outputs.dir(instrumentedClassesDir)
+                    dependsOn(sourceSetParam.classesTaskName)
+                    compileClasspath.from(sourceSetParam.compileClasspath)
+                    sourceDirs.from(project.files({ sourceSetParam.allSource.srcDirs.filter { !sourceSetParam.resources.contains(it) && it.exists() } }))
+                    instrumentationClasspathConfiguration = instrumentationClasspathCfg
+                    originalClassesDirs.from(classesDirsCopy)
+                    output.set(instrumentedClassesDir)
                 }
 
             // Ensure that our task is invoked when the source set is built
             sourceSetParam.compiledBy(instrumentTask)
-            @Suppress("UNUSED_EXPRESSION")
-            true
         }
     }
 }
 
 @CacheableTask
-open class IntelliJInstrumentCodeTask : ConventionTask() {
+abstract class IntelliJInstrumentCodeTask : ConventionTask() {
     companion object {
         private const val FILTER_ANNOTATION_REGEXP_CLASS = "com.intellij.ant.ClassFilterAnnotationRegexp"
         private const val LOADER_REF = "java2.loader"
     }
 
-    @Classpath
-    var instrumentationClasspath: Configuration? = null
+    @Transient
+    @Internal
+    lateinit var instrumentationClasspathConfiguration: Configuration
 
-    @InputFiles
-    @PathSensitive(PathSensitivity.RELATIVE)
-    var originalClassesDirs: FileCollection? = null
+    @get:Classpath
+    val instrumentationClasspath: String by lazy {
+        instrumentationClasspathConfiguration.asPath
+    }
+
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    @get:SkipWhenEmpty
+    abstract val originalClassesDirs: ConfigurableFileCollection
 
     @get:Input
     var instrumentNotNull: Boolean = false
 
-    @Internal
-    var sourceSet: SourceSet? = null
+    @get:InputFiles
+    @get:Classpath
+    abstract val compileClasspath: ConfigurableFileCollection
+
+    // Instrumentation needs to have access to sources of forms for inclusion
+    private val depSourceDirectorySets by lazy {
+        project.configurations["compile"].dependencies.withType(ProjectDependency::class.java)
+            .map { p -> p.dependencyProject.mainSourceSet.allSource.sourceDirectories }
+    }
 
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    val sourceDirs: FileCollection
-        get() = project.files(sourceSet!!.allSource.srcDirs.filter { !sourceSet!!.resources.contains(it) && it.exists() })
+    abstract val sourceDirs: ConfigurableFileCollection
 
     @get:OutputDirectory
-    lateinit var output: File
+    abstract val output: RegularFileProperty
+
+    @get:Inject
+    abstract val fs: FileSystemOperations
 
     @TaskAction
     fun instrumentClasses() {
         logger.info(
-            "input files are: ${originalClassesDirs?.joinToString(
-                "; ",
-                transform = { "'${it.name}'${if (it.exists()) "" else " (does not exists)"}" })}"
+            "input files are: ${
+                originalClassesDirs.joinToString(
+                    "; ",
+                    transform = { "'${it.name}'${if (it.exists()) "" else " (does not exists)"}" })
+            }"
         )
-        output.deleteRecursively()
+        output.asFile.get().deleteRecursively()
         copyOriginalClasses()
 
-        val classpath = instrumentationClasspath!!
+        val classpath = instrumentationClasspath
 
         ant.withGroovyBuilder {
             "taskdef"(
                 "name" to "instrumentIdeaExtensions",
-                "classpath" to classpath.asPath,
+                "classpath" to classpath,
                 "loaderref" to LOADER_REF,
                 "classname" to "com.intellij.ant.InstrumentIdeaExtensions"
             )
@@ -155,14 +179,14 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
 
         logger.info("Compiling forms and instrumenting code with nullability preconditions")
         if (instrumentNotNull) {
-            prepareNotNullInstrumenting(classpath.asPath)
+            prepareNotNullInstrumenting(classpath)
         }
 
         instrumentCode(sourceDirs, instrumentNotNull)
     }
 
     private fun copyOriginalClasses() {
-        project.copy {
+        fs.copy {
             from(originalClassesDirs)
             into(output)
         }
@@ -181,12 +205,10 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
 
     private fun instrumentCode(srcDirs: FileCollection, instrumentNotNull: Boolean) {
         val headlessOldValue = System.setProperty("java.awt.headless", "true")
+        val output = output.get().asFile
 
-        // Instrumentation needs to have access to sources of forms for inclusion
-        val depSourceDirectorySets = project.configurations["compile"].dependencies.withType(ProjectDependency::class.java)
-            .map { p -> p.dependencyProject.mainSourceSet.allSource.sourceDirectories }
         val instrumentationClasspath =
-            depSourceDirectorySets.fold(sourceSet!!.compileClasspath) { acc, v -> acc + v }.asPath.also {
+            depSourceDirectorySets.fold(compileClasspath as FileCollection) { acc, v -> acc + v }.asPath.also {
                 logger.info("Using following dependency source dirs: $it")
             }
 

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -64,6 +64,9 @@ private fun createMavenMarkerPublication(
 ): MavenPublication {
     return publications.create<MavenPublication>(declaration.name.toString() + "PluginMarkerMaven") {
         val pluginId: String = declaration.id
+        val cGroupId = coordinates.groupId
+        val cArtifactId = coordinates.artifactId
+        val cVersion = coordinates.version
         artifactId = pluginId + PLUGIN_MARKER_SUFFIX
         groupId = pluginId
         pom.withXml {
@@ -72,11 +75,11 @@ private fun createMavenMarkerPublication(
             val dependencies = root.appendChild(document.createElement("dependencies"))
             val dependency = dependencies.appendChild(document.createElement("dependency"))
             val groupId = dependency.appendChild(document.createElement("groupId"))
-            groupId.textContent = coordinates.groupId
+            groupId.textContent = cGroupId
             val artifactId = dependency.appendChild(document.createElement("artifactId"))
-            artifactId.textContent = coordinates.artifactId
+            artifactId.textContent = cArtifactId
             val version = dependency.appendChild(document.createElement("version"))
-            version.textContent = coordinates.version
+            version.textContent = cVersion
         }
 
         pom.name.set(declaration.displayName)

buildSrc/src/main/kotlin/plugins/DexMethodCount.kt

@@ -6,12 +6,15 @@
 import com.jakewharton.dex.*
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 import org.gradle.jvm.tasks.Jar
 import java.io.File
 
 @CacheableTask
-open class DexMethodCount : DefaultTask() {
+abstract class DexMethodCount : DefaultTask() {
 
     data class Counts(
         val total: Int,
@@ -24,16 +27,18 @@ open class DexMethodCount : DefaultTask() {
     @Classpath
     lateinit var jarFile: File
 
-    @Optional
-    @Input
-    var ownPackages: List<String>? = null
+    @get:Optional
+    @get:Input
+    abstract val ownPackages: ListProperty<String>
 
     @Internal
     var artifactName: String? = null
 
+    private val projectName = project.name
+
     @get:Input
     val artifactOrArchiveName: String
-        get() = artifactName ?: project.name
+        get() = artifactName ?: projectName
 
     fun from(jar: Jar) {
         jarFile = jar.archiveFile.get().asFile
@@ -45,8 +50,9 @@ open class DexMethodCount : DefaultTask() {
     lateinit var counts: Counts
 
     @get:OutputFile
-    val detailOutputFile: File
-        get() = project.buildDir.resolve("$artifactOrArchiveName-method-count.txt")
+    val detailOutputFile: File by lazy {
+        project.buildDir.resolve("$artifactOrArchiveName-method-count.txt")
+    }
 
     @TaskAction
     fun invoke() {
@@ -59,9 +65,9 @@ open class DexMethodCount : DefaultTask() {
         val byPackage = this.groupingBy { it.`package` }.eachCount()
         val byClass = this.groupingBy { it.declaringType }.eachCount()
 
-        val ownPackages = ownPackages?.map { "$it." }
-        val byOwnPackages = if (ownPackages != null) {
-            this.partition { method -> ownPackages.any { method.declaringType.startsWith(it) } }.let {
+        val ownPackages = ownPackages.map { list -> list.map { "$it." } }
+        val byOwnPackages = if (ownPackages.isPresent) {
+            this.partition { method -> ownPackages.get().any { method.declaringType.startsWith(it) } }.let {
                 it.first.size to it.second.size
             }
         } else (null to null)
@@ -78,7 +84,7 @@ open class DexMethodCount : DefaultTask() {
     private fun outputDetails(counts: Counts) {
         detailOutputFile.printWriter().use { writer ->
             writer.println("${counts.total.padRight()}\tTotal methods")
-            ownPackages?.let { packages ->
+            ownPackages.orNull?.let { packages ->
                 writer.println("${counts.totalOwnPackages?.padRight()}\tTotal methods from packages ${packages.joinToString { "$it.*" }}")
                 writer.println("${counts.totalOtherPackages?.padRight()}\tTotal methods from other packages")
             }
@@ -96,23 +102,24 @@ open class DexMethodCount : DefaultTask() {
     }
 }
 
-open class DexMethodCountStats : DefaultTask() {
-
-    @Internal
-    lateinit var from: TaskProvider<DexMethodCount>
-
+abstract class DexMethodCountStats : DefaultTask() {
     @get:InputFile
-    internal val inputFile
-        get() = from.get().detailOutputFile
+    internal abstract val inputFile: RegularFileProperty
+
+    @get:Input
+    internal abstract val artifactOrArchiveName: Property<String>
+
+    @get:Input
+    @get:Optional
+    internal abstract val ownPackages: ListProperty<String>
 
     @TaskAction
     private fun printStats() {
-        val artifactOrArchiveName = from.get().artifactOrArchiveName
-        inputFile.reader().useLines { lines ->
+        val artifactOrArchiveName = artifactOrArchiveName.get()
+        inputFile.get().asFile.reader().useLines { lines ->
             fun String.getStatValue() = substringBefore("\t").trim()
 
-            val ownPackages = from.get().ownPackages
-            val statsLineCount = if (ownPackages == null) 1 else 3
+            val statsLineCount = if (!ownPackages.isPresent) 1 else 3
             val stats = lines.take(statsLineCount).map { it.getStatValue() }.toList()
 
             val total = stats[0]
@@ -122,7 +129,7 @@ open class DexMethodCountStats : DefaultTask() {
                 println("##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}' value='$total']")
             }
 
-            ownPackages?.let { packages ->
+            ownPackages.map { packages ->
                 val totalOwnPackages = stats[1]
                 val totalOtherPackages = stats[2]
 
@@ -141,7 +148,9 @@ open class DexMethodCountStats : DefaultTask() {
 fun Project.printStats(dexMethodCount: TaskProvider<DexMethodCount>) {
     val dexMethodCountStats = tasks.register("dexMethodCountStats", DexMethodCountStats::class.java) {
         dependsOn(dexMethodCount)
-        from = dexMethodCount
+        inputFile.set(dexMethodCount.flatMap { objects.fileProperty().apply { set(it.detailOutputFile) } })
+        artifactOrArchiveName.set(dexMethodCount.map { it.artifactOrArchiveName })
+        ownPackages.set(dexMethodCount.flatMap { it.ownPackages })
     }
 
     dexMethodCount.configure {

buildSrc/src/main/kotlin/tasks.kt

@@ -9,11 +9,14 @@
 
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.artifacts.ProjectDependency
+import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.internal.tasks.testing.filter.DefaultTestFilter
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.testing.Test
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
+import org.gradle.kotlin.dsl.support.serviceOf
 import java.io.File
 import java.lang.Character.isLowerCase
 import java.lang.Character.isUpperCase
@@ -80,129 +83,141 @@ fun Project.projectTest(
     shortenTempRootName: Boolean = false,
     jUnit5Enabled: Boolean = false,
     body: Test.() -> Unit = {}
-): TaskProvider<Test> = getOrCreateTask(taskName) {
-    doFirst {
-        val commandLineIncludePatterns = (filter as? DefaultTestFilter)?.commandLineIncludePatterns ?: mutableSetOf()
-        val patterns = filter.includePatterns + commandLineIncludePatterns
-        if (patterns.isEmpty() || patterns.any { '*' in it }) return@doFirst
-        patterns.forEach { pattern ->
-            var isClassPattern = false
-            val maybeMethodName = pattern.substringAfterLast('.')
-            val maybeClassFqName = if (maybeMethodName.isFirstChar(::isLowerCase)) {
-                pattern.substringBeforeLast('.')
-            } else {
-                isClassPattern = true
-                pattern
-            }
-
-            if (!maybeClassFqName.substringAfterLast('.').isFirstChar(::isUpperCase)) {
-                return@forEach
-            }
-
-            val classFileNameWithoutExtension = maybeClassFqName.replace('.', '/')
-            val classFileName = "$classFileNameWithoutExtension.class"
-
-            if (isClassPattern) {
-                val innerClassPattern = "$pattern$*"
-                if (pattern in commandLineIncludePatterns) {
-                    commandLineIncludePatterns.add(innerClassPattern)
-                    (filter as? DefaultTestFilter)?.setCommandLineIncludePatterns(commandLineIncludePatterns)
-                } else {
-                    filter.includePatterns.add(innerClassPattern)
-                }
-            }
-
-            val parentNames = if (jUnit5Enabled) {
-                /*
-                 * If we run test from inner test class with junit 5 we need
-                 *   to include all containing classes of our class
-                 */
-                val nestedNames = classFileNameWithoutExtension.split("$")
-                mutableListOf(nestedNames.first()).also {
-                    for (s in nestedNames.subList(1, nestedNames.size)) {
-                        it += "${it.last()}\$$s"
-                    }
-                }
-            } else emptyList()
-
-            include { treeElement ->
-                val path = treeElement.path
-                if (treeElement.isDirectory) {
-                    classFileNameWithoutExtension.startsWith(path)
-                } else {
-                    if (jUnit5Enabled) {
-                        path == classFileName || (path.endsWith(".class") && parentNames.any { path.startsWith(it) })
-                    } else {
-                        path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
-                    }
-                }
-            }
-        }
+): TaskProvider<Test> {
+    val shouldInstrument = project.providers.gradleProperty("kotlin.test.instrumentation.disable")
+        .forUseAtConfigurationTime().orNull?.toBoolean() != true
+    if (shouldInstrument) {
+        evaluationDependsOn(":test-instrumenter")
     }
-
-    if (project.findProperty("kotlin.test.instrumentation.disable")?.toString()?.toBoolean() != true) {
+    return getOrCreateTask<Test>(taskName) {
         doFirst {
-            val agent = tasks.findByPath(":test-instrumenter:jar")!!.outputs.files.singleFile
-            val args = project.findProperty("kotlin.test.instrumentation.args")?.let { "=$it" }.orEmpty()
-            jvmArgs("-javaagent:$agent$args")
-        }
-        dependsOn(":test-instrumenter:jar")
-    }
+            val commandLineIncludePatterns = (filter as? DefaultTestFilter)?.commandLineIncludePatterns ?: mutableSetOf()
+            val patterns = filter.includePatterns + commandLineIncludePatterns
+            if (patterns.isEmpty() || patterns.any { '*' in it }) return@doFirst
+            patterns.forEach { pattern ->
+                var isClassPattern = false
+                val maybeMethodName = pattern.substringAfterLast('.')
+                val maybeClassFqName = if (maybeMethodName.isFirstChar(::isLowerCase)) {
+                    pattern.substringBeforeLast('.')
+                } else {
+                    isClassPattern = true
+                    pattern
+                }
 
-    jvmArgs(
-        "-ea",
-        "-XX:+HeapDumpOnOutOfMemoryError",
-        "-XX:+UseCodeCacheFlushing",
-        "-XX:ReservedCodeCacheSize=256m",
-        "-Djna.nosys=true"
-    )
+                if (!maybeClassFqName.substringAfterLast('.').isFirstChar(::isUpperCase)) {
+                    return@forEach
+                }
 
-    maxHeapSize = "1600m"
-    systemProperty("idea.is.unit.test", "true")
-    systemProperty("idea.home.path", intellijRootDir().canonicalPath)
-    systemProperty("java.awt.headless", "true")
-    environment("NO_FS_ROOTS_ACCESS_CHECK", "true")
-    environment("PROJECT_CLASSES_DIRS", testSourceSet.output.classesDirs.asPath)
-    environment("PROJECT_BUILD_DIR", buildDir)
-    systemProperty("jps.kotlin.home", rootProject.extra["distKotlinHomeDir"]!!)
-    systemProperty("kotlin.ni", if (rootProject.hasProperty("newInferenceTests")) "true" else "false")
-    systemProperty("org.jetbrains.kotlin.skip.muted.tests", if (rootProject.hasProperty("skipMutedTests")) "true" else "false")
+                val classFileNameWithoutExtension = maybeClassFqName.replace('.', '/')
+                val classFileName = "$classFileNameWithoutExtension.class"
 
-    if (Platform[202].orHigher()) {
-        systemProperty("idea.ignore.disabled.plugins", "true")
-    }
+                if (isClassPattern) {
+                    val innerClassPattern = "$pattern$*"
+                    if (pattern in commandLineIncludePatterns) {
+                        commandLineIncludePatterns.add(innerClassPattern)
+                        (filter as? DefaultTestFilter)?.setCommandLineIncludePatterns(commandLineIncludePatterns)
+                    } else {
+                        filter.includePatterns.add(innerClassPattern)
+                    }
+                }
 
-    var subProjectTempRoot: Path? = null
-    doFirst {
-        val teamcity = rootProject.findProperty("teamcity") as? Map<*, *>
-        val systemTempRoot =
-            // TC by default doesn't switch `teamcity.build.tempDir` to 'java.io.tmpdir' so it could cause to wasted disk space
-            // Should be fixed soon on Teamcity side
-            (teamcity?.get("teamcity.build.tempDir") as? String)
-                ?: System.getProperty("java.io.tmpdir")
-        systemTempRoot.let {
-            val prefix = (project.name + "Project_" + taskName + "_").takeUnless { shortenTempRootName }
-            subProjectTempRoot = Files.createTempDirectory(File(systemTempRoot).toPath(), prefix)
-            systemProperty("java.io.tmpdir", subProjectTempRoot.toString())
-        }
-    }
+                val parentNames = if (jUnit5Enabled) {
+                    /*
+                     * If we run test from inner test class with junit 5 we need
+                     *   to include all containing classes of our class
+                     */
+                    val nestedNames = classFileNameWithoutExtension.split("$")
+                    mutableListOf(nestedNames.first()).also {
+                        for (s in nestedNames.subList(1, nestedNames.size)) {
+                            it += "${it.last()}\$$s"
+                        }
+                    }
+                } else emptyList()
 
-    doLast {
-        subProjectTempRoot?.let {
-            try {
-                delete(it)
-            } catch (e: Exception) {
-                project.logger.warn("Can't delete test temp root folder $it", e.printStackTrace())
+                include { treeElement ->
+                    val path = treeElement.path
+                    if (treeElement.isDirectory) {
+                        classFileNameWithoutExtension.startsWith(path)
+                    } else {
+                        if (jUnit5Enabled) {
+                            path == classFileName || (path.endsWith(".class") && parentNames.any { path.startsWith(it) })
+                        } else {
+                            path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
+                        }
+                    }
+                }
             }
         }
-    }
 
-    if (parallel && !jUnit5Enabled) {
-        maxParallelForks =
-            project.findProperty("kotlin.test.maxParallelForks")?.toString()?.toInt()
-                ?: (Runtime.getRuntime().availableProcessors() / if (kotlinBuildProperties.isTeamcityBuild) 2 else 4).coerceAtLeast(1)
-    }
-    body()
+        if (shouldInstrument) {
+            val instrumentationArgsProperty = project.providers.gradleProperty("kotlin.test.instrumentation.args")
+            val testInstrumenterOutputs = project.tasks.findByPath(":test-instrumenter:jar")!!.outputs.files
+            doFirst {
+                val agent = testInstrumenterOutputs.singleFile
+                val args = instrumentationArgsProperty.orNull?.let { "=$it" }.orEmpty()
+                jvmArgs("-javaagent:$agent$args")
+            }
+            dependsOn(":test-instrumenter:jar")
+        }
+
+        jvmArgs(
+            "-ea",
+            "-XX:+HeapDumpOnOutOfMemoryError",
+            "-XX:+UseCodeCacheFlushing",
+            "-XX:ReservedCodeCacheSize=256m",
+            "-Djna.nosys=true"
+        )
+
+        maxHeapSize = "1600m"
+        systemProperty("idea.is.unit.test", "true")
+        systemProperty("idea.home.path", project.intellijRootDir().canonicalPath)
+        systemProperty("java.awt.headless", "true")
+        environment("NO_FS_ROOTS_ACCESS_CHECK", "true")
+        environment("PROJECT_CLASSES_DIRS", project.testSourceSet.output.classesDirs.asPath)
+        environment("PROJECT_BUILD_DIR", project.buildDir)
+        systemProperty("jps.kotlin.home", project.rootProject.extra["distKotlinHomeDir"]!!)
+        systemProperty("kotlin.ni", if (project.rootProject.hasProperty("newInferenceTests")) "true" else "false")
+        systemProperty("org.jetbrains.kotlin.skip.muted.tests", if (project.rootProject.hasProperty("skipMutedTests")) "true" else "false")
+
+        if (Platform[202].orHigher()) {
+            systemProperty("idea.ignore.disabled.plugins", "true")
+        }
+
+        var subProjectTempRoot: Path? = null
+        val projectName = project.name
+        val teamcity = project.rootProject.findProperty("teamcity") as? Map<*, *>
+        doFirst {
+            val systemTempRoot =
+                // TC by default doesn't switch `teamcity.build.tempDir` to 'java.io.tmpdir' so it could cause to wasted disk space
+                // Should be fixed soon on Teamcity side
+                (teamcity?.get("teamcity.build.tempDir") as? String)
+                    ?: System.getProperty("java.io.tmpdir")
+            systemTempRoot.let {
+                val prefix = (projectName + "Project_" + taskName + "_").takeUnless { shortenTempRootName }
+                subProjectTempRoot = Files.createTempDirectory(File(systemTempRoot).toPath(), prefix)
+                systemProperty("java.io.tmpdir", subProjectTempRoot.toString())
+            }
+        }
+
+        val fs = project.serviceOf<FileSystemOperations>()
+        doLast {
+            subProjectTempRoot?.let {
+                try {
+                    fs.delete {
+                        delete(it)
+                    }
+                } catch (e: Exception) {
+                    logger.warn("Can't delete test temp root folder $it", e.printStackTrace())
+                }
+            }
+        }
+
+        if (parallel && !jUnit5Enabled) {
+            maxParallelForks =
+                project.providers.gradleProperty("kotlin.test.maxParallelForks").forUseAtConfigurationTime().orNull?.toInt()
+                    ?: (Runtime.getRuntime().availableProcessors() / if (project.kotlinBuildProperties.isTeamcityBuild) 2 else 4).coerceAtLeast(1)
+        }
+    }.apply { configure(body) }
 }
 
 private inline fun String.isFirstChar(f: (Char) -> Boolean) = isNotEmpty() && f(first())
@@ -229,18 +244,25 @@ private fun Task.useAndroidConfiguration(systemPropertyName: String, configName:
     val configuration = with(project) {
         configurations.getOrCreate(configName)
             .also {
-                dependencies.add(
-                    configName,
-                    dependencies.project(":dependencies:android-sdk", configuration = configName)
-                )
+                if (it.allDependencies.matching { dep ->
+                        dep is ProjectDependency &&
+                                dep.targetConfiguration == configName &&
+                                dep.dependencyProject.path == ":dependencies:android-sdk"
+                    }.count() == 0) {
+                    dependencies.add(
+                        configName,
+                        dependencies.project(":dependencies:android-sdk", configuration = configName)
+                    )
+                }
             }
     }
 
     dependsOn(configuration)
 
     if (this is Test) {
+        val androidFilePath = configuration.singleFile.canonicalPath
         doFirst {
-            systemProperty(systemPropertyName, configuration.singleFile.canonicalPath)
+            systemProperty(systemPropertyName, androidFilePath)
         }
     }
 }

buildSrc/src/main/kotlin/testDistribution.kt

@@ -9,13 +9,13 @@ import org.gradle.internal.os.OperatingSystem
 
 
 fun Test.configureTestDistribution(configure: TestDistributionExtension.() -> Unit = {}) {
+    if (extensions.findByType(TestDistributionExtension::class.java) == null) return
+
     val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
-    val testDistributionEnabled = project.findProperty("kotlin.build.test.distribution.enabled")?.toString()?.toBoolean()
-        ?: isTeamcityBuild
 
     useJUnitPlatform()
     extensions.configure(TestDistributionExtension::class.java) {
-        enabled.set(testDistributionEnabled)
+        enabled.set(true)
         maxRemoteExecutors.set(20)
         if (isTeamcityBuild) {
             requirements.set(setOf("os=${OperatingSystem.current().familyName}"))

compiler/backend.common.jvm/src/org/jetbrains/kotlin/types/AbstractTypeMapper.kt

@@ -116,6 +116,12 @@ object AbstractTypeMapper {
                 return asmType
             }
 
+            typeConstructor.isScript() -> {
+                val asmType = AsmTypes.JAVA_CLASS_TYPE
+                with(context) { sw?.writeGenericType(type, asmType, mode) }
+                return asmType
+            }
+
             typeConstructor.isTypeParameter() -> {
                 val typeParameter = typeConstructor as TypeParameterMarker
                 return mapType(context, typeParameter.representativeUpperBound(), mode, null).also { asmType ->

compiler/backend/src/org/jetbrains/kotlin/codegen/BaseExpressionCodegen.kt

@@ -51,7 +51,6 @@ interface BaseExpressionCodegen {
 
     fun consumeReifiedOperationMarker(typeParameter: TypeParameterMarker)
 
-    @JvmDefault
     fun putReifiedOperationMarkerIfTypeIsReifiedParameter(type: KotlinTypeMarker, operationKind: OperationKind) {
         with(typeSystem) {
             val (typeParameter, second) = extractReificationArgument(type) ?: return

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -88,6 +88,7 @@ import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
 import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContextImpl;
 import org.jetbrains.kotlin.types.expressions.DoubleColonLHS;
+import org.jetbrains.kotlin.types.model.KotlinTypeMarker;
 import org.jetbrains.kotlin.types.model.TypeParameterMarker;
 import org.jetbrains.kotlin.types.typesApproximation.CapturedTypeApproximationKt;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
@@ -5532,4 +5533,11 @@ The "returned" value of try expression with no finally is either the last expres
             parentCodegen.getReifiedTypeParametersUsages().addUsedReifiedParameter(typeParameterDescriptor.getName().asString());
         }
     }
+
+    @Override
+    public void putReifiedOperationMarkerIfTypeIsReifiedParameter(
+            @NotNull KotlinTypeMarker type, @NotNull ReifiedTypeInliner.OperationKind operationKind
+    ) {
+        BaseExpressionCodegen.DefaultImpls.putReifiedOperationMarkerIfTypeIsReifiedParameter(this, type, operationKind);
+    }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java

@@ -1152,8 +1152,10 @@ public class FunctionCodegen {
 
         // $default methods are never private to be accessible from other class files (e.g. inner) without the need of synthetic accessors
         // $default methods are never protected to be accessible from subclass nested classes
+        // TODO: maybe best to generate private default in interface as private
         int visibilityFlag =
-                DescriptorVisibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor)
+                (!isInterface(functionDescriptor.getContainingDeclaration()) || kind == OwnerKind.DEFAULT_IMPLS) &&
+                (DescriptorVisibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor))
                 ? AsmUtil.NO_FLAG_PACKAGE_PRIVATE : Opcodes.ACC_PUBLIC;
         int flags = visibilityFlag | getDeprecatedAccessFlag(functionDescriptor) | ACC_SYNTHETIC;
         if (!(functionDescriptor instanceof ConstructorDescriptor &&
@@ -1689,7 +1691,7 @@ public class FunctionCodegen {
             return (kind != OwnerKind.DEFAULT_IMPLS && !isSyntheticInCompatibilityOrJvmDefault) ||
                    (kind == OwnerKind.DEFAULT_IMPLS &&
                     (isSyntheticInCompatibilityOrJvmDefault ||
-                     (mode.isCompatibility() && !JvmAnnotationUtilKt.hasJvmDefaultNoCompatibilityAnnotation(containingDeclaration))));
+                     (mode.isCompatibility() && !JvmAnnotationUtilKt.hasJvmDefaultNoCompatibilityAnnotation(containingDeclaration))) && !DescriptorVisibilities.isPrivate(memberDescriptor.getVisibility()));
         } else {
             switch (kind) {
                 case DEFAULT_IMPLS: return true;

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt

@@ -34,9 +34,13 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtTypeAlias
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.MemberComparator
+import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import org.jetbrains.kotlin.resolve.jvm.annotations.JVM_SYNTHETIC_ANNOTATION_FQ_NAME
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.MultifileClass
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.MultifileClassPart
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin
@@ -125,8 +129,19 @@ class MultifileClassCodegenImpl(
         val superClassForFacade = if (shouldGeneratePartHierarchy) partInternalNamesSorted.last() else J_L_OBJECT
 
         state.factory.newVisitor(MultifileClass(files.firstOrNull(), actualPackageFragment), facadeClassType, files).apply {
+            var attributes = FACADE_CLASS_ATTRIBUTES
+
+            val nonJvmSyntheticParts = files.filterNot { it.isJvmSynthetic() }
+            if (nonJvmSyntheticParts.isEmpty()) {
+                attributes = attributes or Opcodes.ACC_SYNTHETIC
+            } else if (nonJvmSyntheticParts.size < files.size) {
+                for (part in nonJvmSyntheticParts) {
+                    state.diagnostics.report(ErrorsJvm.NOT_ALL_MULTIFILE_CLASS_PARTS_ARE_JVM_SYNTHETIC.on(part.packageDirective ?: part))
+                }
+            }
+
             defineClass(
-                singleSourceFile, state.classFileVersion, FACADE_CLASS_ATTRIBUTES,
+                singleSourceFile, state.classFileVersion, attributes,
                 facadeClassType.internalName, null, superClassForFacade, emptyArray()
             )
             if (singleSourceFile != null) {
@@ -146,6 +161,13 @@ class MultifileClassCodegenImpl(
         }
     }
 
+    private fun KtFile.isJvmSynthetic(): Boolean {
+        return annotationEntries.any { entry ->
+            val descriptor = state.bindingContext[BindingContext.ANNOTATION, entry]
+            descriptor?.annotationClass?.let(DescriptorUtils::getFqNameSafe) == JVM_SYNTHETIC_ANNOTATION_FQ_NAME
+        }
+    }
+
     override fun generate() {
         assert(delegateGenerationTasks.isEmpty()) { "generate() is called twice for facade class $facadeFqName" }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperClasses.kt

@@ -36,14 +36,16 @@ class SamWrapperClasses(private val state: GenerationState) {
         expressionCodegen: ExpressionCodegen,
         contextDescriptor: CallableMemberDescriptor
     ): Type {
-        val isInsideInline = InlineUtil.isInlineOrContainingInline(expressionCodegen.context.contextDescriptor) ||
-                isInsideInlineLambdaContext(expressionCodegen.context, state)
+        val parentContext = expressionCodegen.context
+        val isInsideInline = InlineUtil.isInlineOrContainingInline(parentContext.contextDescriptor) ||
+                isInsideInlineLambdaContext(parentContext, state)
         return samInterfaceToWrapperClass.getOrPut(WrapperKey(samType, file, isInsideInline)) {
-            SamWrapperCodegen(state, samType, expressionCodegen.parentCodegen, isInsideInline).genWrapper(file, contextDescriptor)
+            SamWrapperCodegen(state, samType, expressionCodegen.parentCodegen, parentContext, isInsideInline)
+                .genWrapper(file, contextDescriptor)
         }
     }
 
-    private fun isInsideInlineLambdaContext(context: CodegenContext<*>, state: GenerationState):Boolean {
+    private fun isInsideInlineLambdaContext(context: CodegenContext<*>, state: GenerationState): Boolean {
         var parent: CodegenContext<*>? = context
         while (parent != null && parent != state.rootContext) {
             if (parent is InlineLambdaContext) return true

compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java

@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
 import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.context.CodegenContext;
-import org.jetbrains.kotlin.codegen.context.FieldOwnerContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.config.LanguageFeature;
@@ -64,6 +63,7 @@ public class SamWrapperCodegen {
     private final KotlinTypeMapper typeMapper;
     private final SamType samType;
     private final MemberCodegen<?> parentCodegen;
+    private final CodegenContext<?> parentContext;
     private final int visibility;
     private final int classFlags;
     public static final String SAM_WRAPPER_SUFFIX = "$0";
@@ -72,6 +72,7 @@ public class SamWrapperCodegen {
             @NotNull GenerationState state,
             @NotNull SamType samType,
             @NotNull MemberCodegen<?> parentCodegen,
+            @NotNull CodegenContext<?> parentContext,
             boolean isInsideInline
     ) {
         this.state = state;
@@ -79,6 +80,7 @@ public class SamWrapperCodegen {
         this.typeMapper = state.getTypeMapper();
         this.samType = samType;
         this.parentCodegen = parentCodegen;
+        this.parentContext = parentContext;
         visibility = isInsideInline ? ACC_PUBLIC : NO_FLAG_PACKAGE_PRIVATE;
         int synth = state.getLanguageVersionSettings().supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic) ? ACC_SYNTHETIC : 0;
         classFlags = visibility | ACC_FINAL | ACC_SUPER | synth;
@@ -170,7 +172,6 @@ public class SamWrapperCodegen {
 
     private void generateInnerClassInformation(@NotNull KtFile file, Type asmType, ClassBuilder cv) {
         parentCodegen.addSyntheticAnonymousInnerClass(new SyntheticInnerClassInfo(asmType.getInternalName(), classFlags));
-        FieldOwnerContext<?> parentContext = parentCodegen.context;
         CodegenContext<?> outerContext = MemberCodegen.getNonInlineOuterContext(parentContext);
         assert outerContext != null :
                 "Outer context for SAM wrapper " + asmType.getInternalName() + " is null, parentContext:" + parentContext;

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineTransformerMethodVisitor.kt

@@ -1217,6 +1217,27 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
     fun isAlive(insnIndex: Int, variableIndex: Int): Boolean =
         liveness[insnIndex].isAlive(variableIndex)
 
+    fun nextSuspensionPointEndLabel(insn: AbstractInsnNode): LabelNode {
+        val suspensionPoint =
+            InsnSequence(insn, method.instructions.last).firstOrNull { isAfterSuspendMarker(it) } ?: method.instructions.last
+        return suspensionPoint as? LabelNode ?: suspensionPoint.findNextOrNull { it is LabelNode } as LabelNode
+    }
+
+    fun nextSuspensionPointStartLabel(insn: AbstractInsnNode): LabelNode {
+        val suspensionPoint =
+            InsnSequence(insn, method.instructions.last).firstOrNull { isBeforeSuspendMarker(it) } ?: method.instructions.last
+        return suspensionPoint as? LabelNode ?: suspensionPoint.findPreviousOrNull { it is LabelNode } as LabelNode
+    }
+
+    fun min(a: LabelNode, b: LabelNode): LabelNode =
+        if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) a else b
+
+    fun max(a: LabelNode, b: LabelNode): LabelNode =
+        if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) b else a
+
+    fun containsSuspensionPoint(a: LabelNode, b: LabelNode): Boolean =
+        InsnSequence(min(a, b), max(a, b)).none { isBeforeSuspendMarker(it) }
+
     val oldLvt = arrayListOf<LocalVariableNode>()
     for (record in method.localVariables) {
         oldLvt += record
@@ -1237,23 +1258,35 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
                 // No variable in LVT -> do not add one
                 val lvtRecord = oldLvt.findRecord(insnIndex, variableIndex) ?: continue
                 if (lvtRecord.name == CONTINUATION_VARIABLE_NAME) continue
-                val endLabel = insn as? LabelNode ?: insn.findNextOrNull { it is LabelNode } as? LabelNode ?: continue
+                // Extend lvt record to the next suspension point
+                val endLabel = min(lvtRecord.end, nextSuspensionPointEndLabel(insn))
                 // startLabel can be null in case of parameters
                 @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
                 // Attempt to extend existing local variable node corresponding to the record in
                 // the original local variable table.
-                var recordToExtend: LocalVariableNode? = oldLvtNodeToLatestNewLvtNode[lvtRecord]
-                if (recordToExtend != null && InsnSequence(recordToExtend.end, startLabel).none { isBeforeSuspendMarker(it) }) {
+                val recordToExtend: LocalVariableNode? = oldLvtNodeToLatestNewLvtNode[lvtRecord]
+                if (recordToExtend != null && containsSuspensionPoint(recordToExtend.end, startLabel)) {
                     recordToExtend.end = endLabel
                 } else {
                     val node = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
-                    method.localVariables.add(node)
+                    if (lvtRecord !in oldLvtNodeToLatestNewLvtNode) {
+                        method.localVariables.add(node)
+                    }
                     oldLvtNodeToLatestNewLvtNode[lvtRecord] = node
                 }
             }
         }
     }
 
+    val deadVariables = arrayListOf<Int>()
+    outer@for (variableIndex in start until method.maxLocals) {
+        if (oldLvt.none { it.index == variableIndex }) continue
+        for (insnIndex in 0 until (method.instructions.size() - 1)) {
+            if (isAlive(insnIndex, variableIndex)) continue@outer
+        }
+        deadVariables += variableIndex
+    }
+
     for (variable in oldLvt) {
         // $continuation and $result are dead, but they are used by debugger, as well as fake inliner variables
         // For example, $continuation is used to create async stack trace
@@ -1262,10 +1295,26 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
             isFakeLocalVariableForInline(variable.name)
         ) {
             method.localVariables.add(variable)
+            continue
         }
         // this acts like $continuation for lambdas. For example, it is used by debugger to create async stack trace. Keep it.
         if (variable.name == "this" && !isForNamedFunction) {
             method.localVariables.add(variable)
+            continue
+        }
+
+        // Shrink LVT records of dead variables to the next suspension point
+        if (variable.index in deadVariables) {
+            method.localVariables.add(
+                LocalVariableNode(
+                    variable.name,
+                    variable.desc,
+                    variable.signature,
+                    variable.start,
+                    nextSuspensionPointStartLabel(variable.start),
+                    variable.index
+                )
+            )
         }
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt

@@ -108,11 +108,9 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         )
     }
 
-    protected fun generateStub(resolvedCall: ResolvedCall<*>?, codegen: BaseExpressionCodegen) {
+    protected fun generateStub(text: String, codegen: BaseExpressionCodegen) {
         leaveTemps()
-        assert(resolvedCall != null)
-        val message = "Call is part of inline cycle: " + resolvedCall!!.call.callElement.text
-        AsmUtil.genThrow(codegen.v, "java/lang/UnsupportedOperationException", message)
+        AsmUtil.genThrow(codegen.v, "java/lang/UnsupportedOperationException", "Call is part of inline cycle: $text")
     }
 
     protected fun endCall(result: InlineResult, registerLineNumberAfterwards: Boolean) {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt

@@ -60,8 +60,8 @@ class PsiInlineCodegen(
         callDefault: Boolean,
         codegen: ExpressionCodegen
     ) {
-        if (!state.globalInlineContext.enterIntoInlining(resolvedCall?.resultingDescriptor, resolvedCall?.call?.callElement)) {
-            generateStub(resolvedCall, codegen)
+        if (!state.globalInlineContext.enterIntoInlining(functionDescriptor, resolvedCall?.call?.callElement)) {
+            generateStub(resolvedCall?.call?.callElement?.text ?: "<no source>", codegen)
             return
         }
         try {

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/Util.kt

@@ -61,7 +61,7 @@ class InsnSequence(val from: AbstractInsnNode, val to: AbstractInsnNode?) : Sequ
     }
 }
 
-fun InsnList.asSequence() = InsnSequence(this)
+fun InsnList.asSequence(): Sequence<AbstractInsnNode> = if (size() == 0) emptySequence() else InsnSequence(this)
 
 fun MethodNode.prepareForEmitting() {
     stripOptimizationMarkers()

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/transformer/MethodTransformer.java

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.codegen.optimization.transformer;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.org.objectweb.asm.tree.MethodNode;
 import org.jetbrains.org.objectweb.asm.tree.analysis.*;
 
@@ -31,7 +32,7 @@ public abstract class MethodTransformer {
             return analyzer.analyze(internalClassName, node);
         }
         catch (AnalyzerException e) {
-            throw new RuntimeException(e);
+            throw ExceptionUtilsKt.rethrow(e);
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -213,13 +213,13 @@ class GenerationState private constructor(
         val fromConfig = configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS)
         if (fromConfig != null && target >= fromConfig.minJvmTarget)
             fromConfig
-        else {
-            // TODO wait for KT-44844 (properly support 'invokedynamic' in JPS incremental compilation)
-            // Use JvmClosureGenerationScheme.INDY if
-            //  JVM target is at least JVM_1_8 &&
-            //  SamWrapperClassesAreSynthetic language feature is supported
+        else if (
+            target >= JvmClosureGenerationScheme.INDY.minJvmTarget &&
+            languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic)
+        )
+            JvmClosureGenerationScheme.INDY
+        else
             JvmClosureGenerationScheme.CLASS
-        }
     }
 
     val lambdasScheme = run {

compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.JvmAnalysisFlags
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
+import org.jetbrains.kotlin.load.kotlin.JvmBytecodeBinaryVersion
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor
 
@@ -31,6 +32,9 @@ fun writeKotlinMetadata(
 ) {
     val av = cb.newAnnotation(JvmAnnotationNames.METADATA_DESC, true)
     av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, state.metadataVersion.toArray())
+    if (!state.metadataVersion.isAtLeast(1, 5, 0)) {
+        av.visit("bv", JvmBytecodeBinaryVersion.INSTANCE.toArray())
+    }
     av.visit(JvmAnnotationNames.KIND_FIELD_NAME, kind.id)
     var flags = extraFlags
     if (state.languageVersionSettings.isPreRelease()) {

compiler/build.gradle.kts

@@ -103,8 +103,11 @@ projectTest(parallel = true) {
 
     workingDir = rootDir
     systemProperty("kotlin.test.script.classpath", testSourceSet.output.classesDirs.joinToString(File.pathSeparator))
+    val antLauncherJarPathProvider = project.provider {
+        antLauncherJar.asPath
+    }
     doFirst {
-        systemProperty("kotlin.ant.classpath", antLauncherJar.asPath)
+        systemProperty("kotlin.ant.classpath", antLauncherJarPathProvider.get())
         systemProperty("kotlin.ant.launcher.class", "org.apache.tools.ant.Main")
     }
 }

compiler/cli/bin/kotlinc

@@ -52,6 +52,10 @@ while [ $# -gt 0 ]; do
       ;;
     -J*)
       java_args=("${java_args[@]}" "${1:2}")
+      if [ "x${1:2}" = "x" ]; then
+        echo "error: empty -J argument"
+        exit 1
+      fi
       shift
       ;;
     *)

compiler/cli/bin/kotlinc.bat

@@ -28,6 +28,10 @@ set _arg=%~1
 if "%_arg%" == "" goto loopend
 
 if "%_arg:~0,2%"=="-J" (
+  if "%_arg:~2%"=="" (
+    echo error: empty -J argument
+    goto error
+  )
   set JAVA_OPTS=%JAVA_OPTS% "%_arg:~2%"
 ) else (
   if "%_arg:~0,2%"=="-D" (
@@ -67,7 +71,6 @@ if "!_KOTLIN_RUNNER!"=="1" (
     %_KOTLIN_COMPILER% %KOTLIN_OPTS%
 )
 
-exit /b %ERRORLEVEL%
 goto end
 
 rem ##########################################################################
@@ -103,5 +106,8 @@ rem Needs to be executed in the EnableDelayedExpansion mode.
   )
 goto :eof
 
+:error
+set ERRORLEVEL=1
+
 :end
-endlocal
+exit /b %ERRORLEVEL%

compiler/cli/build.gradle.kts

@@ -12,6 +12,7 @@ dependencies {
     compile(project(":compiler:backend-common"))
     compile(project(":compiler:backend"))
     compile(project(":compiler:backend.jvm"))
+    implementation(project(":compiler:backend.jvm:backend.jvm.entrypoint"))
     compile(project(":compiler:ir.backend.common"))
     compile(project(":compiler:light-classes"))
     compile(project(":compiler:serialization"))

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/Properties.kt

@@ -16,8 +16,54 @@
 
 package org.jetbrains.kotlin.cli.common
 
-val KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY = "kotlin.environment.keepalive"
+import com.intellij.util.LineSeparator
+import java.util.*
 
+enum class CompilerSystemProperties(val property: String) {
+    COMPILE_DAEMON_ENABLED_PROPERTY("kotlin.daemon.enabled"),
+    COMPILE_DAEMON_JVM_OPTIONS_PROPERTY("kotlin.daemon.jvm.options"),
+    COMPILE_DAEMON_OPTIONS_PROPERTY("kotlin.daemon.options"),
+    COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY("kotlin.daemon.client.options"),
+    COMPILE_DAEMON_CLIENT_ALIVE_PATH_PROPERTY("kotlin.daemon.client.alive.path"),
+    COMPILE_DAEMON_LOG_PATH_PROPERTY("kotlin.daemon.log.path"),
+    COMPILE_DAEMON_REPORT_PERF_PROPERTY("kotlin.daemon.perf"),
+    COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY("kotlin.daemon.verbose"),
+    COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY("kotlin.daemon.startup.timeout"),
+    JAVA_RMI_SERVER_HOSTNAME("java.rmi.server.hostname"),
+    DAEMON_RMI_SOCKET_BACKLOG_SIZE_PROPERTY("kotlin.daemon.socket.backlog.size"),
+    DAEMON_RMI_SOCKET_CONNECT_ATTEMPTS_PROPERTY("kotlin.daemon.socket.connect.attempts"),
+    DAEMON_RMI_SOCKET_CONNECT_INTERVAL_PROPERTY("kotlin.daemon.socket.connect.interval"),
+    KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY("kotlin.environment.keepalive"),
+    COMPILE_DAEMON_CUSTOM_RUN_FILES_PATH_FOR_TESTS("kotlin.daemon.custom.run.files.path.for.tests"),
+    KOTLIN_COLORS_ENABLED_PROPERTY("kotlin.colors.enabled"),
+    OS_NAME("os.name")
+    ;
+
+    var value
+        get() = systemPropertyGetter(property)
+        set(value) {
+            systemPropertySetter(property, value!!)
+        }
+
+    fun clear(): String? = systemPropertyCleaner(property)
+
+    companion object {
+        var systemPropertyGetter: (String) -> String? = {
+            System.getProperty(it)
+        }
+
+        var systemPropertySetter: (String, String) -> String? = { key, value ->
+            System.setProperty(key, value)
+        }
+
+        var systemPropertyCleaner: (String) -> String? = { key ->
+            System.clearProperty(key)
+        }
+    }
+}
+
+val isWindows: Boolean
+    get() = CompilerSystemProperties.OS_NAME.value!!.toLowerCase(Locale.ENGLISH).startsWith("windows")
 
 fun String?.toBooleanLenient(): Boolean? = when (this?.toLowerCase()) {
     null -> false

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLITool.kt

@@ -205,8 +205,8 @@ abstract class CLITool<A : CommonToolArguments> {
             if (System.getProperty("java.awt.headless") == null) {
                 System.setProperty("java.awt.headless", "true")
             }
-            if (System.getProperty(PlainTextMessageRenderer.KOTLIN_COLORS_ENABLED_PROPERTY) == null) {
-                System.setProperty(PlainTextMessageRenderer.KOTLIN_COLORS_ENABLED_PROPERTY, "true")
+            if (CompilerSystemProperties.KOTLIN_COLORS_ENABLED_PROPERTY.value == null) {
+                CompilerSystemProperties.KOTLIN_COLORS_ENABLED_PROPERTY.value = "true"
             }
 
             setupIdeaStandaloneExecution()

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/PlainTextMessageRenderer.java

@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.cli.common.messages;
 
-import com.intellij.openapi.util.SystemInfo;
-import com.intellij.util.LineSeparator;
 import kotlin.text.StringsKt;
 import org.fusesource.jansi.Ansi;
 import org.fusesource.jansi.internal.CLibrary;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties;
+import org.jetbrains.kotlin.cli.common.PropertiesKt;
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.CapitalizeDecapitalizeKt;
 
 import java.util.EnumSet;
@@ -31,13 +31,12 @@ import java.util.Set;
 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*;
 
 public abstract class PlainTextMessageRenderer implements MessageRenderer {
-    public static final String KOTLIN_COLORS_ENABLED_PROPERTY = "kotlin.colors.enabled";
     public static final boolean COLOR_ENABLED;
 
     static {
         boolean colorEnabled = false;
         // TODO: investigate why ANSI escape codes on Windows only work in REPL for some reason
-        if (!SystemInfo.isWindows && "true".equals(System.getProperty(KOTLIN_COLORS_ENABLED_PROPERTY))) {
+        if (!PropertiesKt.isWindows() && "true".equals(CompilerSystemProperties.KOTLIN_COLORS_ENABLED_PROPERTY.getValue())) {
             try {
                 // AnsiConsole doesn't check isatty() for stderr (see https://github.com/fusesource/jansi/pull/35).
                 colorEnabled = CLibrary.isatty(CLibrary.STDERR_FILENO) != 0;
@@ -49,7 +48,7 @@ public abstract class PlainTextMessageRenderer implements MessageRenderer {
         COLOR_ENABLED = colorEnabled;
     }
 
-    private static final String LINE_SEPARATOR = LineSeparator.getSystemLineSeparator().getSeparatorString();
+    private static final String LINE_SEPARATOR = System.lineSeparator();
 
     private static final Set<CompilerMessageSeverity> IMPORTANT_MESSAGE_SEVERITIES = EnumSet.of(EXCEPTION, ERROR, STRONG_WARNING, WARNING);
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/output/outputUtils.kt

@@ -23,13 +23,24 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import java.io.File
+import java.io.FileNotFoundException
 
 fun OutputFileCollection.writeAll(outputDir: File, report: ((file: OutputFile, sources: List<File>, output: File) -> Unit)?) {
     for (file in asList()) {
         val sources = file.sourceFiles
         val output = File(outputDir, file.relativePath)
         report?.invoke(file, sources, output)
-        FileUtil.writeToFile(output, file.asByteArray())
+        try {
+            FileUtil.writeToFile(output, file.asByteArray())
+        } catch (e: FileNotFoundException) {
+            if (outputDir.isDirectory) {
+                // output directory exists
+                throw NoPermissionException("error while writing $output (Permission denied)", e)
+            }
+            // Failed to create directory, possibly due to lack of write permission or clash with existing file.
+            // In both cases, the directory will not exist, so for the sake of simplicity, we treat them same way.
+            throw e
+        }
     }
 }
 
@@ -38,8 +49,16 @@ fun OutputFileCollection.writeAllTo(outputDir: File) {
 }
 
 fun OutputFileCollection.writeAll(outputDir: File, messageCollector: MessageCollector, reportOutputFiles: Boolean) {
-    if (!reportOutputFiles) writeAllTo(outputDir)
-    else writeAll(outputDir) { _, sources, output ->
-        messageCollector.report(CompilerMessageSeverity.OUTPUT, OutputMessageUtil.formatOutputMessage(sources, output))
+    try {
+        if (!reportOutputFiles) writeAllTo(outputDir)
+        else writeAll(outputDir) { _, sources, output ->
+            messageCollector.report(CompilerMessageSeverity.OUTPUT, OutputMessageUtil.formatOutputMessage(sources, output))
+        }
+    } catch (e: NoPermissionException) {
+        messageCollector.report(CompilerMessageSeverity.ERROR, e.message!!)
+    } catch (e: FileNotFoundException) {
+        messageCollector.report(CompilerMessageSeverity.ERROR, "directory not found: $outputDir")
     }
 }
+
+private class NoPermissionException(message: String, cause: Throwable?) : IllegalStateException(message, cause)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java

@@ -24,6 +24,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.modules.ModuleChunk;
 import org.jetbrains.kotlin.cli.common.modules.ModuleXmlParser;
@@ -104,16 +105,26 @@ public class CompileEnvironmentUtil {
     }
 
     public static void writeToJar(
-            File jarPath, boolean jarRuntime, boolean noReflect, boolean resetJarTimestamps, FqName mainClass, OutputFileCollection outputFiles
+            File jarPath,
+            boolean jarRuntime,
+            boolean noReflect,
+            boolean resetJarTimestamps,
+            FqName mainClass,
+            OutputFileCollection outputFiles,
+            MessageCollector messageCollector
     ) {
         FileOutputStream outputStream = null;
         try {
+            // we should try to create the output dir first
+            if (jarPath.getParentFile() != null) {
+                jarPath.getParentFile().mkdirs();
+            }
             outputStream = new FileOutputStream(jarPath);
             doWriteToJar(outputFiles, outputStream, mainClass, jarRuntime, noReflect, resetJarTimestamps);
             outputStream.close();
         }
         catch (FileNotFoundException e) {
-            throw new CompileEnvironmentException("Invalid jar path " + jarPath, e);
+            messageCollector.report(CompilerMessageSeverity.ERROR, "Invalid jar path: " + jarPath, null);
         }
         catch (IOException e) {
             throw ExceptionUtilsKt.rethrow(e);

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -58,7 +58,7 @@ import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.CliModuleVisibilityManagerImpl
-import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
@@ -498,16 +498,13 @@ class KotlinCoreEnvironment private constructor(
                 }
                 // Disposing of the environment is unsafe in production then parallel builds are enabled, but turning it off universally
                 // breaks a lot of tests, therefore it is disabled for production and enabled for tests
-                if (System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY).toBooleanLenient() != true) {
+                if (CompilerSystemProperties.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY.value.toBooleanLenient() != true) {
                     // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ)
                     // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well
-                    @Suppress("ObjectLiteralToLambda") // Disposer tree depends on identity of disposables.
-                    Disposer.register(parentDisposable, object : Disposable {
-                        override fun dispose() {
-                            synchronized(APPLICATION_LOCK) {
-                                if (--ourProjectCount <= 0) {
-                                    disposeApplicationEnvironment()
-                                }
+                    Disposer.register(parentDisposable, Disposable {
+                        synchronized(APPLICATION_LOCK) {
+                            if (--ourProjectCount <= 0) {
+                                disposeApplicationEnvironment()
                             }
                         }
                     })

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection
 import org.jetbrains.kotlin.backend.common.output.SimpleOutputFileCollection
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
-import org.jetbrains.kotlin.backend.jvm.JvmGeneratorExtensions
+import org.jetbrains.kotlin.backend.jvm.JvmGeneratorExtensionsImpl
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.backend.jvm.jvmPhases
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
@@ -57,9 +57,7 @@ import org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
 import org.jetbrains.kotlin.fir.checkers.registerExtendedCommonCheckers
-import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
-import org.jetbrains.kotlin.fir.session.FirJvmModuleInfo
-import org.jetbrains.kotlin.fir.session.FirSessionFactory
+import org.jetbrains.kotlin.fir.createSessionWithDependencies
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
@@ -88,7 +86,7 @@ object KotlinToJVMBytecodeCompiler {
             val includeRuntime = configuration.get(JVMConfigurationKeys.INCLUDE_RUNTIME, false)
             val noReflect = configuration.get(JVMConfigurationKeys.NO_REFLECT, false)
             val resetJarTimestamps = !configuration.get(JVMConfigurationKeys.NO_RESET_JAR_TIMESTAMPS, false)
-            CompileEnvironmentUtil.writeToJar(jarPath, includeRuntime, noReflect, resetJarTimestamps, mainClassFqName, outputFiles)
+            CompileEnvironmentUtil.writeToJar(jarPath, includeRuntime, noReflect, resetJarTimestamps, mainClassFqName, outputFiles, messageCollector)
             if (reportOutputFiles) {
                 val message = OutputMessageUtil.formatOutputMessage(outputFiles.asList().flatMap { it.sourceFiles }.distinct(), jarPath)
                 messageCollector.report(OUTPUT, message)
@@ -318,25 +316,26 @@ object KotlinToJVMBytecodeCompiler {
             if (!checkKotlinPackageUsage(environment, ktFiles)) return false
             val moduleConfiguration = projectConfiguration.applyModuleProperties(module, buildFile)
 
-            val scope = GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile })
+            val sourceScope = GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile })
                 .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
-            val provider = FirProjectSessionProvider()
 
-            val librariesModuleInfo = FirJvmModuleInfo.createForLibraries()
             val librariesScope = ProjectScope.getLibrariesScope(project)
-            FirSessionFactory.createLibrarySession(
-                librariesModuleInfo, provider, librariesScope,
-                project, environment.createPackagePartProvider(librariesScope)
-            )
 
-            val moduleInfo = FirJvmModuleInfo(module, listOf(librariesModuleInfo))
-            val session = FirSessionFactory.createJavaModuleBasedSession(moduleInfo, provider, scope, project) {
+            val languageVersionSettings = moduleConfiguration.languageVersionSettings
+            val session = createSessionWithDependencies(
+                module,
+                project,
+                languageVersionSettings,
+                sourceScope,
+                librariesScope,
+                environment::createPackagePartProvider
+            ) {
                 if (extendedAnalysisMode) {
                     registerExtendedCommonCheckers()
                 }
             }
 
-            val firAnalyzerFacade = FirAnalyzerFacade(session, moduleConfiguration.languageVersionSettings, ktFiles)
+            val firAnalyzerFacade = FirAnalyzerFacade(session, languageVersionSettings, ktFiles)
 
             firAnalyzerFacade.runResolution()
             val firDiagnostics = firAnalyzerFacade.runCheckers().values.flatten()
@@ -353,8 +352,8 @@ object KotlinToJVMBytecodeCompiler {
             performanceManager?.notifyGenerationStarted()
 
             performanceManager?.notifyIRTranslationStarted()
-            val extensions = JvmGeneratorExtensions()
-            val (moduleFragment, symbolTable, sourceManager, components) = firAnalyzerFacade.convertToIr(extensions)
+            val extensions = JvmGeneratorExtensionsImpl()
+            val (moduleFragment, symbolTable, components) = firAnalyzerFacade.convertToIr(extensions)
 
             performanceManager?.notifyIRTranslationFinished()
 
@@ -390,12 +389,11 @@ object KotlinToJVMBytecodeCompiler {
             performanceManager?.notifyIRLoweringStarted()
             generationState.beforeCompile()
             codegenFactory.generateModuleInFrontendIRMode(
-                generationState, moduleFragment, symbolTable, sourceManager, extensions, FirJvmBackendExtension(session, components),
-                {
-                    performanceManager?.notifyIRLoweringFinished()
-                    performanceManager?.notifyIRGenerationStarted()
-                }
-            )
+                generationState, moduleFragment, symbolTable, extensions, FirJvmBackendExtension(session, components)
+            ) {
+                performanceManager?.notifyIRLoweringFinished()
+                performanceManager?.notifyIRGenerationStarted()
+            }
             CodegenFactory.doCheckCancelled(generationState)
             generationState.factory.done()
 

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataKlibSerializer.kt

@@ -74,6 +74,7 @@ internal class K2MetadataKlibSerializer(private val metadataVersion: BuiltInsBin
             configuration.languageVersionSettings,
             metadataVersion,
             project,
+            exportKDoc = false,
             skipExpects = false,
             includeOnlyModuleContent = true
         ).serializeModule(module)

compiler/compiler-runner/build.gradle.kts

@@ -1,6 +1,3 @@
-
-import org.gradle.jvm.tasks.Jar
-
 description = "Compiler runner + daemon client"
 
 plugins {

compiler/compiler.version/build.gradle.kts

@@ -25,8 +25,9 @@ tasks.withType<JavaCompile> {
 }
 
 tasks.named<ProcessResources>("processResources") {
-    inputs.property("compilerVersion", kotlinVersion)
+    val kotlinVersionLocal = kotlinVersion
+    inputs.property("compilerVersion", kotlinVersionLocal)
     filesMatching("META-INF/compiler.version") {
-        filter<ReplaceTokens>("tokens" to mapOf("snapshot" to kotlinVersion))
+        filter<ReplaceTokens>("tokens" to mapOf("snapshot" to kotlinVersionLocal))
     }
 }

compiler/daemon/daemon-client-new/src/org/jetbrains/kotlin/daemon/client/experimental/KotlinCompilerClient.kt

@@ -10,6 +10,7 @@ import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.daemon.client.CompileServiceSessionAsync
@@ -44,13 +45,13 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
     val DAEMON_DEFAULT_STARTUP_TIMEOUT_MS = 10000L
     val DAEMON_CONNECT_CYCLE_ATTEMPTS = 3
 
-    val verboseReporting = System.getProperty(COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY) != null
+    val verboseReporting = CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.value != null
 
     private val log = Logger.getLogger("KotlinCompilerClient")
 
     override fun getOrCreateClientFlagFile(daemonOptions: DaemonOptions): File =
     // for jps property is passed from IDEA to JPS in KotlinBuildProcessParametersProvider
-        System.getProperty(COMPILE_DAEMON_CLIENT_ALIVE_PATH_PROPERTY)
+        CompilerSystemProperties.COMPILE_DAEMON_CLIENT_ALIVE_PATH_PROPERTY.value
             ?.let(String::trimQuotes)
             ?.takeUnless(String::isBlank)
             ?.let(::File)
@@ -210,8 +211,6 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
         }
     }
 
-    val COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY: String = "kotlin.daemon.client.options"
-
     data class ClientOptions(
         var stop: Boolean = false
     ) : OptionsGroup {
@@ -220,11 +219,11 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
     }
 
     private fun configureClientOptions(opts: ClientOptions): ClientOptions {
-        System.getProperty(COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY)?.let {
+        CompilerSystemProperties.COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY.value?.let {
             val unrecognized = it.trimQuotes().split(",").filterExtractProps(opts.mappers, "")
             if (unrecognized.any())
                 throw IllegalArgumentException(
-                    "Unrecognized client options passed via property $COMPILE_DAEMON_OPTIONS_PROPERTY: " + unrecognized.joinToString(" ") +
+                    "Unrecognized client options passed via property ${CompilerSystemProperties.COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY.property}: " + unrecognized.joinToString(" ") +
                             "\nSupported options: " + opts.mappers.joinToString(", ", transform = { it.names.first() })
                 )
         }
@@ -456,11 +455,11 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
         reportingTargets: DaemonReportingTargets
     ): Boolean {
         val javaExecutable = File(File(System.getProperty("java.home"), "bin"), "java")
-        val serverHostname = System.getProperty(JAVA_RMI_SERVER_HOSTNAME) ?: error("$JAVA_RMI_SERVER_HOSTNAME is not set!")
+        val serverHostname = CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.value ?: error("${CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.property} is not set!")
         val platformSpecificOptions = listOf(
             // hide daemon window
             "-Djava.awt.headless=true",
-            "-D$JAVA_RMI_SERVER_HOSTNAME=$serverHostname"
+            "-D${CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.property}=$serverHostname"
         )
         val args = listOf(
             javaExecutable.absolutePath, "-cp", compilerId.compilerClasspath.joinToString(File.pathSeparator)
@@ -509,13 +508,13 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
             }
         try {
             // trying to wait for process
-            val daemonStartupTimeout = System.getProperty(COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY)?.let {
+            val daemonStartupTimeout = CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.value?.let {
                 try {
                     it.toLong()
                 } catch (e: Exception) {
                     reportingTargets.report(
                         DaemonReportCategory.INFO,
-                        "unable to interpret $COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY property ('$it'); using default timeout $DAEMON_DEFAULT_STARTUP_TIMEOUT_MS ms"
+                        "unable to interpret ${CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.property} property ('$it'); using default timeout $DAEMON_DEFAULT_STARTUP_TIMEOUT_MS ms"
                     )
                     null
                 }

compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/KotlinCompilerClient.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.daemon.client
 
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.daemon.common.*
@@ -48,11 +49,11 @@ object KotlinCompilerClient {
     val DAEMON_DEFAULT_STARTUP_TIMEOUT_MS = 10000L
     val DAEMON_CONNECT_CYCLE_ATTEMPTS = 3
 
-    val verboseReporting = System.getProperty(COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY) != null
+    val verboseReporting = CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.value != null
 
     fun getOrCreateClientFlagFile(daemonOptions: DaemonOptions): File =
             // for jps property is passed from IDEA to JPS in KotlinBuildProcessParametersProvider
-            System.getProperty(COMPILE_DAEMON_CLIENT_ALIVE_PATH_PROPERTY)
+        CompilerSystemProperties.COMPILE_DAEMON_CLIENT_ALIVE_PATH_PROPERTY.value
                 ?.let(String::trimQuotes)
                 ?.takeUnless(String::isBlank)
                 ?.let(::File)
@@ -211,7 +212,6 @@ object KotlinCompilerClient {
         ).get()
     }
 
-    val COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY: String = "kotlin.daemon.client.options"
     data class ClientOptions(
             var stop: Boolean = false
     ) : OptionsGroup {
@@ -220,11 +220,11 @@ object KotlinCompilerClient {
     }
 
     private fun configureClientOptions(opts: ClientOptions): ClientOptions {
-        System.getProperty(COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY)?.let {
+        CompilerSystemProperties.COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY.value?.let {
             val unrecognized = it.trimQuotes().split(",").filterExtractProps(opts.mappers, "")
             if (unrecognized.any())
                 throw IllegalArgumentException(
-                        "Unrecognized client options passed via property $COMPILE_DAEMON_OPTIONS_PROPERTY: " + unrecognized.joinToString(" ") +
+                        "Unrecognized client options passed via property ${CompilerSystemProperties.COMPILE_DAEMON_CLIENT_OPTIONS_PROPERTY.property}: " + unrecognized.joinToString(" ") +
                         "\nSupported options: " + opts.mappers.joinToString(", ", transform = { it.names.first() }))
         }
         return opts
@@ -369,11 +369,11 @@ object KotlinCompilerClient {
 
     private fun startDaemon(compilerId: CompilerId, daemonJVMOptions: DaemonJVMOptions, daemonOptions: DaemonOptions, reportingTargets: DaemonReportingTargets): Boolean {
         val javaExecutable = File(File(System.getProperty("java.home"), "bin"), "java")
-        val serverHostname = System.getProperty(JAVA_RMI_SERVER_HOSTNAME) ?: error("$JAVA_RMI_SERVER_HOSTNAME is not set!")
+        val serverHostname = CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.value ?: error("${CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.property} is not set!")
         val platformSpecificOptions = listOf(
                 // hide daemon window
                 "-Djava.awt.headless=true",
-                "-D$JAVA_RMI_SERVER_HOSTNAME=$serverHostname")
+                "-D$${CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.property}=$serverHostname")
         val javaVersion = System.getProperty("java.specification.version")?.toIntOrNull()
         val javaIllegalAccessWorkaround =
             if (javaVersion != null && javaVersion >= 16)
@@ -424,12 +424,12 @@ object KotlinCompilerClient {
             }
         try {
             // trying to wait for process
-            val daemonStartupTimeout = System.getProperty(COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY)?.let {
+            val daemonStartupTimeout = CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.value?.let {
                 try {
                     it.toLong()
                 }
                 catch (e: Exception) {
-                    reportingTargets.report(DaemonReportCategory.INFO, "unable to interpret $COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY property ('$it'); using default timeout $DAEMON_DEFAULT_STARTUP_TIMEOUT_MS ms")
+                    reportingTargets.report(DaemonReportCategory.INFO, "unable to interpret ${CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.property} property ('$it'); using default timeout $DAEMON_DEFAULT_STARTUP_TIMEOUT_MS ms")
                     null
                 }
             } ?: DAEMON_DEFAULT_STARTUP_TIMEOUT_MS

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/DaemonParams.kt

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.daemon.common
 
-import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import java.io.File
 import java.io.Serializable
 import java.lang.management.ManagementFactory
@@ -24,53 +24,47 @@ import java.security.MessageDigest
 import java.util.*
 import kotlin.reflect.KMutableProperty1
 
+const val COMPILER_JAR_NAME: String = "kotlin-compiler.jar"
+const val COMPILER_SERVICE_RMI_NAME: String = "KotlinJvmCompilerService"
+const val COMPILER_DAEMON_CLASS_FQN: String = "org.jetbrains.kotlin.daemon.KotlinCompileDaemon"
+const val COMPILE_DAEMON_FIND_PORT_ATTEMPTS: Int = 10
+const val COMPILE_DAEMON_PORTS_RANGE_START: Int = 17001
+const val COMPILE_DAEMON_PORTS_RANGE_END: Int = 18000
+const val COMPILE_DAEMON_CMDLINE_OPTIONS_PREFIX: String = "--daemon-"
+const val COMPILE_DAEMON_DEFAULT_FILES_PREFIX: String = "kotlin-daemon"
+const val COMPILE_DAEMON_TIMEOUT_INFINITE_S: Int = 0
+const val COMPILE_DAEMON_DEFAULT_IDLE_TIMEOUT_S: Int = 7200 // 2 hours
+const val COMPILE_DAEMON_DEFAULT_UNUSED_TIMEOUT_S: Int = 60
+const val COMPILE_DAEMON_DEFAULT_SHUTDOWN_DELAY_MS: Long = 1000L // 1 sec
+const val COMPILE_DAEMON_MEMORY_THRESHOLD_INFINITE: Long = 0L
+const val COMPILE_DAEMON_FORCE_SHUTDOWN_DEFAULT_TIMEOUT_MS: Long = 10000L // 10 secs
+const val COMPILE_DAEMON_TIMEOUT_INFINITE_MS: Long = 0L
+const val COMPILE_DAEMON_IS_READY_MESSAGE = "Kotlin compile daemon is ready"
 
-val COMPILER_JAR_NAME: String = "kotlin-compiler.jar"
-val COMPILER_SERVICE_RMI_NAME: String = "KotlinJvmCompilerService"
-val COMPILER_DAEMON_CLASS_FQN: String = "org.jetbrains.kotlin.daemon.KotlinCompileDaemon"
-val COMPILE_DAEMON_FIND_PORT_ATTEMPTS: Int = 10
-val COMPILE_DAEMON_PORTS_RANGE_START: Int = 17001
-val COMPILE_DAEMON_PORTS_RANGE_END: Int = 18000
-val COMPILE_DAEMON_ENABLED_PROPERTY: String = "kotlin.daemon.enabled"
-val COMPILE_DAEMON_JVM_OPTIONS_PROPERTY: String = "kotlin.daemon.jvm.options"
-val COMPILE_DAEMON_OPTIONS_PROPERTY: String = "kotlin.daemon.options"
-val COMPILE_DAEMON_CLIENT_ALIVE_PATH_PROPERTY: String = "kotlin.daemon.client.alive.path"
-val COMPILE_DAEMON_LOG_PATH_PROPERTY: String = "kotlin.daemon.log.path"
-val COMPILE_DAEMON_REPORT_PERF_PROPERTY: String = "kotlin.daemon.perf"
-val COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY: String = "kotlin.daemon.verbose"
-val COMPILE_DAEMON_CMDLINE_OPTIONS_PREFIX: String = "--daemon-"
-val COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY: String = "kotlin.daemon.startup.timeout"
-val COMPILE_DAEMON_DEFAULT_FILES_PREFIX: String = "kotlin-daemon"
-val COMPILE_DAEMON_TIMEOUT_INFINITE_S: Int = 0
-val COMPILE_DAEMON_DEFAULT_IDLE_TIMEOUT_S: Int = 7200 // 2 hours
-val COMPILE_DAEMON_DEFAULT_UNUSED_TIMEOUT_S: Int = 60
-val COMPILE_DAEMON_DEFAULT_SHUTDOWN_DELAY_MS: Long = 1000L // 1 sec
-val COMPILE_DAEMON_MEMORY_THRESHOLD_INFINITE: Long = 0L
-val COMPILE_DAEMON_FORCE_SHUTDOWN_DEFAULT_TIMEOUT_MS: Long = 10000L // 10 secs
-val COMPILE_DAEMON_TIMEOUT_INFINITE_MS: Long = 0L
-val COMPILE_DAEMON_IS_READY_MESSAGE = "Kotlin compile daemon is ready"
-
-val COMPILE_DAEMON_CUSTOM_RUN_FILES_PATH_FOR_TESTS: String = "kotlin.daemon.custom.run.files.path.for.tests"
-val COMPILE_DAEMON_DEFAULT_RUN_DIR_PATH: String get() =
-    System.getProperty(COMPILE_DAEMON_CUSTOM_RUN_FILES_PATH_FOR_TESTS)
-        ?: FileSystem.getRuntimeStateFilesPath("kotlin", "daemon")
+val COMPILE_DAEMON_DEFAULT_RUN_DIR_PATH: String
+    get() = CompilerSystemProperties.COMPILE_DAEMON_CUSTOM_RUN_FILES_PATH_FOR_TESTS.value ?: FileSystem.getRuntimeStateFilesPath(
+        "kotlin",
+        "daemon"
+    )
 
 val CLASSPATH_ID_DIGEST = "MD5"
 
 
-open class PropMapper<C, V, out P : KMutableProperty1<C, V>>(val dest: C,
-                                                             val prop: P,
-                                                             val names: List<String> = listOf(prop.name),
-                                                             val fromString: (String) -> V,
-                                                             val toString: ((V) -> String?) = { it.toString() },
-                                                             val skipIf: ((V) -> Boolean) = { false },
-                                                             val mergeDelimiter: String? = null) {
+open class PropMapper<C, V, out P : KMutableProperty1<C, V>>(
+    val dest: C,
+    val prop: P,
+    val names: List<String> = listOf(prop.name),
+    val fromString: (String) -> V,
+    val toString: ((V) -> String?) = { it.toString() },
+    val skipIf: ((V) -> Boolean) = { false },
+    val mergeDelimiter: String? = null
+) {
     open fun toArgs(prefix: String = COMPILE_DAEMON_CMDLINE_OPTIONS_PREFIX): List<String> =
-            when {
-                skipIf(prop.get(dest)) -> listOf<String>()
-                mergeDelimiter != null -> listOf(listOfNotNull(prefix + names.first(), toString(prop.get(dest))).joinToString(mergeDelimiter))
-                else -> listOfNotNull(prefix + names.first(), toString(prop.get(dest)))
-            }
+        when {
+            skipIf(prop.get(dest)) -> listOf<String>()
+            mergeDelimiter != null -> listOf(listOfNotNull(prefix + names.first(), toString(prop.get(dest))).joinToString(mergeDelimiter))
+            else -> listOfNotNull(prefix + names.first(), toString(prop.get(dest)))
+        }
 
     open fun apply(s: String) = prop.set(dest, fromString(s))
 }
@@ -255,7 +249,7 @@ data class CompilerId(
 }
 
 
-fun isDaemonEnabled(): Boolean = System.getProperty(COMPILE_DAEMON_ENABLED_PROPERTY) != null
+fun isDaemonEnabled(): Boolean = CompilerSystemProperties.COMPILE_DAEMON_ENABLED_PROPERTY.value != null
 
 fun configureDaemonJVMOptions(opts: DaemonJVMOptions,
                               vararg additionalParams: String,
@@ -289,16 +283,16 @@ fun configureDaemonJVMOptions(opts: DaemonJVMOptions,
 
         if (inheritOtherJvmOptions) {
             opts.jvmParams.addAll(
-                    otherArgs.filterNot {
-                        it.startsWith("agentlib") ||
-                        it.startsWith("D" + COMPILE_DAEMON_LOG_PATH_PROPERTY) ||
-                        it.startsWith("D" + KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY) ||
-                        it.startsWith("D" + COMPILE_DAEMON_JVM_OPTIONS_PROPERTY) ||
-                        it.startsWith("D" + COMPILE_DAEMON_OPTIONS_PROPERTY)
-                    })
+                otherArgs.filterNot {
+                    it.startsWith("agentlib") ||
+                            it.startsWith("D" + CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property) ||
+                            it.startsWith("D" + CompilerSystemProperties.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY.property) ||
+                            it.startsWith("D" + CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property) ||
+                            it.startsWith("D" + CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property)
+                })
         }
     }
-    System.getProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY)?.let {
+    CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.value?.let {
         opts.jvmParams.addAll(
                 it.trimQuotes()
                   .split("(?<!\\\\),".toRegex())  // using independent non-capturing group with negative lookahead zero length assertion to split only on non-escaped commas
@@ -311,8 +305,8 @@ fun configureDaemonJVMOptions(opts: DaemonJVMOptions,
     opts.jvmParams.addAll(additionalParams)
 
     if (inheritAdditionalProperties) {
-        System.getProperty(COMPILE_DAEMON_LOG_PATH_PROPERTY)?.let { opts.jvmParams.add("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"$it\"") }
-        System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY)?.let { opts.jvmParams.add("D$KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY") }
+        CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.value?.let { opts.jvmParams.add("D${CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property}=\"$it\"") }
+        CompilerSystemProperties.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY.value?.let { opts.jvmParams.add("D${CompilerSystemProperties.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY.property}") }
     }
 
     if (opts.jvmParams.none { it.matches(jvmAssertArgsRegex) }) {
@@ -338,15 +332,15 @@ fun configureDaemonJVMOptions(
     )
 
 fun configureDaemonOptions(opts: DaemonOptions): DaemonOptions {
-    System.getProperty(COMPILE_DAEMON_OPTIONS_PROPERTY)?.let {
+    CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.value?.let {
         val unrecognized = it.trimQuotes().split(",").filterExtractProps(opts.mappers, "")
         if (unrecognized.any())
             throw IllegalArgumentException(
-                    "Unrecognized daemon options passed via property $COMPILE_DAEMON_OPTIONS_PROPERTY: " + unrecognized.joinToString(" ") +
+                    "Unrecognized daemon options passed via property ${CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property}: " + unrecognized.joinToString(" ") +
                     "\nSupported options: " + opts.mappers.joinToString(", ", transform = { it.names.first() }))
     }
-    System.getProperty(COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY)?.let { opts.verbose = true }
-    System.getProperty(COMPILE_DAEMON_REPORT_PERF_PROPERTY)?.let { opts.reportPerf = true }
+    CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.value?.let { opts.verbose = true }
+    CompilerSystemProperties.COMPILE_DAEMON_REPORT_PERF_PROPERTY.value?.let { opts.reportPerf = true }
     return opts
 }
 

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/NetworkUtils.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.daemon.common
 
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import java.io.IOException
 import java.io.Serializable
 import java.net.*
@@ -26,12 +27,7 @@ import java.rmi.server.RMIClientSocketFactory
 import java.rmi.server.RMIServerSocketFactory
 import java.util.*
 
-
-const val SOCKET_ANY_FREE_PORT  = 0
-const val JAVA_RMI_SERVER_HOSTNAME = "java.rmi.server.hostname"
-const val DAEMON_RMI_SOCKET_BACKLOG_SIZE_PROPERTY = "kotlin.daemon.socket.backlog.size"
-const val DAEMON_RMI_SOCKET_CONNECT_ATTEMPTS_PROPERTY = "kotlin.daemon.socket.connect.attempts"
-const val DAEMON_RMI_SOCKET_CONNECT_INTERVAL_PROPERTY = "kotlin.daemon.socket.connect.interval"
+const val SOCKET_ANY_FREE_PORT = 0
 const val DEFAULT_SERVER_SOCKET_BACKLOG_SIZE = 50
 const val DEFAULT_SOCKET_CONNECT_ATTEMPTS = 3
 const val DEFAULT_SOCKET_CONNECT_INTERVAL_MS = 10L
@@ -43,9 +39,9 @@ object LoopbackNetworkInterface {
 
     // size of the requests queue for daemon services, so far seems that we don't need any big numbers here
     // but if we'll start getting "connection refused" errors, that could be the first place to try to fix it
-    val SERVER_SOCKET_BACKLOG_SIZE by lazy { System.getProperty(DAEMON_RMI_SOCKET_BACKLOG_SIZE_PROPERTY)?.toIntOrNull() ?: DEFAULT_SERVER_SOCKET_BACKLOG_SIZE }
-    val SOCKET_CONNECT_ATTEMPTS by lazy { System.getProperty(DAEMON_RMI_SOCKET_CONNECT_ATTEMPTS_PROPERTY)?.toIntOrNull() ?: DEFAULT_SOCKET_CONNECT_ATTEMPTS }
-    val SOCKET_CONNECT_INTERVAL_MS by lazy { System.getProperty(DAEMON_RMI_SOCKET_CONNECT_INTERVAL_PROPERTY)?.toLongOrNull() ?: DEFAULT_SOCKET_CONNECT_INTERVAL_MS }
+    val SERVER_SOCKET_BACKLOG_SIZE by lazy { CompilerSystemProperties.DAEMON_RMI_SOCKET_BACKLOG_SIZE_PROPERTY.value?.toIntOrNull() ?: DEFAULT_SERVER_SOCKET_BACKLOG_SIZE }
+    val SOCKET_CONNECT_ATTEMPTS by lazy { CompilerSystemProperties.DAEMON_RMI_SOCKET_CONNECT_ATTEMPTS_PROPERTY.value?.toIntOrNull() ?: DEFAULT_SOCKET_CONNECT_ATTEMPTS }
+    val SOCKET_CONNECT_INTERVAL_MS by lazy { CompilerSystemProperties.DAEMON_RMI_SOCKET_CONNECT_INTERVAL_PROPERTY.value?.toLongOrNull() ?: DEFAULT_SOCKET_CONNECT_INTERVAL_MS }
 
     val serverLoopbackSocketFactory by lazy { ServerLoopbackSocketFactory() }
     val clientLoopbackSocketFactory by lazy { ClientLoopbackSocketFactory() }
@@ -125,7 +121,7 @@ fun findPortAndCreateRegistry(attempts: Int, portRangeStart: Int, portRangeEnd:
  * which may be slow and can cause a timeout when there is a network problem/misconfiguration.
  */
 fun ensureServerHostnameIsSetUp() {
-    if (System.getProperty(JAVA_RMI_SERVER_HOSTNAME) == null) {
-        System.setProperty(JAVA_RMI_SERVER_HOSTNAME, LoopbackNetworkInterface.loopbackInetAddressName)
+    if (CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.value == null) {
+        CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.value = LoopbackNetworkInterface.loopbackInetAddressName
     }
 }

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerApiTest.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.daemon
 
 import com.intellij.openapi.application.ApplicationManager
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
@@ -127,7 +128,7 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
 
             val logFile: Path = createTempFile("kotlin-daemon-test.", ".log")
 
-            val daemonJVMOptions = configureDaemonJVMOptions("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile.loggerCompatiblePath}\"",
+            val daemonJVMOptions = configureDaemonJVMOptions("D${CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property}=\"${logFile.loggerCompatiblePath}\"",
                                                              inheritMemoryLimits = false, inheritOtherJvmOptions = false, inheritAdditionalProperties = false)
             val jar = tmpdir.absolutePath + File.separator + "hello.jar"
 
@@ -167,7 +168,7 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
 
             val logFile: Path = createTempFile("kotlin-daemon-test.", ".log")
 
-            val daemonJVMOptions = configureDaemonJVMOptions("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile.loggerCompatiblePath}\"",
+            val daemonJVMOptions = configureDaemonJVMOptions("D${CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property}=\"${logFile.loggerCompatiblePath}\"",
                                                              inheritMemoryLimits = false, inheritOtherJvmOptions = false, inheritAdditionalProperties = false)
             try {
                 val (code, outputs) = compileOnDaemon(

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt

@@ -20,6 +20,7 @@ import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.util.io.FileUtilRt
 import junit.framework.TestCase
 import org.jetbrains.kotlin.cli.AbstractCliTest
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.cli.common.repl.*
@@ -109,7 +110,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     fun makeTestDaemonJvmOptions(logFile: File? = null, xmx: Int = 384, args: Iterable<String> = listOf()): DaemonJVMOptions {
         val additionalArgs = arrayListOf<String>()
         if (logFile != null) {
-            additionalArgs.add("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile.loggerCompatiblePath}\"")
+            additionalArgs.add("D${CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property}=\"${logFile.loggerCompatiblePath}\"")
         }
         args.forEach { additionalArgs.add(it) }
         val baseOpts = if (xmx > 0) DaemonJVMOptions(maxMemory = "${xmx}m") else DaemonJVMOptions()
@@ -160,16 +161,16 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     }
 
     fun testDaemonJvmOptionsParsing() {
-        val backupJvmOptions = System.getProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY)
+        val backupJvmOptions = System.getProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property)
         try {
-            System.setProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, "-aaa,-bbb\\,ccc,-ddd,-Xmx200m,-XX:MaxMetaspaceSize=10k,-XX:ReservedCodeCacheSize=100,-xxx\\,yyy")
+            System.setProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, "-aaa,-bbb\\,ccc,-ddd,-Xmx200m,-XX:MaxMetaspaceSize=10k,-XX:ReservedCodeCacheSize=100,-xxx\\,yyy")
             val opts = configureDaemonJVMOptions(inheritMemoryLimits = false, inheritAdditionalProperties = false, inheritOtherJvmOptions = false)
             assertEquals("200m", opts.maxMemory)
             assertEquals("10k", opts.maxMetaspaceSize)
             assertEquals("100", opts.reservedCodeCacheSize)
             assertEquals(arrayListOf("aaa", "bbb,ccc", "ddd", "xxx,yyy", "ea"), opts.jvmParams)
 
-            System.setProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, "-Xmx300m,-XX:MaxMetaspaceSize=10k,-XX:ReservedCodeCacheSize=100")
+            System.setProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, "-Xmx300m,-XX:MaxMetaspaceSize=10k,-XX:ReservedCodeCacheSize=100")
             val opts2 = configureDaemonJVMOptions(inheritMemoryLimits = false, inheritAdditionalProperties = false, inheritOtherJvmOptions = false)
             assertEquals("300m", opts2.maxMemory)
             assertEquals( -1, DaemonJVMOptionsMemoryComparator().compare(opts, opts2))
@@ -178,14 +179,14 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             val myXmxParam = ManagementFactory.getRuntimeMXBean().inputArguments.first { it.startsWith("-Xmx") }
             TestCase.assertNotNull(myXmxParam)
             val myXmxVal = myXmxParam.substring(4)
-            System.clearProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY)
+            System.clearProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property)
             val opts3 = configureDaemonJVMOptions(inheritMemoryLimits = true,
                                                   inheritOtherJvmOptions = true,
                                                   inheritAdditionalProperties = false)
             assertEquals(myXmxVal, opts3.maxMemory)
         }
         finally {
-            restoreSystemProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, backupJvmOptions)
+            restoreSystemProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, backupJvmOptions)
         }
     }
 
@@ -215,12 +216,12 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     }
 
     private fun withDaemonJvmOptionsSetTo(newValue: String?, fn: () -> Unit) {
-        val backup = getAndSetSystemProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, newValue)
+        val backup = getAndSetSystemProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, newValue)
 
         try {
             fn()
         } finally {
-            getAndSetSystemProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, backup)
+            getAndSetSystemProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, backup)
         }
     }
 
@@ -237,15 +238,15 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     }
 
     fun testDaemonOptionsParsing() {
-        val backupOptions = System.getProperty(COMPILE_DAEMON_OPTIONS_PROPERTY)
+        val backupOptions = System.getProperty(CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property)
         try {
-            System.setProperty(COMPILE_DAEMON_OPTIONS_PROPERTY, "runFilesPath=abcd,autoshutdownIdleSeconds=1111")
+            System.setProperty(CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property, "runFilesPath=abcd,autoshutdownIdleSeconds=1111")
             val opts = configureDaemonOptions(DaemonOptions(shutdownDelayMilliseconds = 1))
             assertEquals("abcd", opts.runFilesPath)
             assertEquals(1111, opts.autoshutdownIdleSeconds)
         }
         finally {
-            restoreSystemProperty(COMPILE_DAEMON_OPTIONS_PROPERTY, backupOptions)
+            restoreSystemProperty(CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property, backupOptions)
         }
     }
 
@@ -518,12 +519,12 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
         val daemonOptions = makeTestDaemonOptions(getTestName(true))
         val jar = testTempDir.absolutePath + File.separator + "hello.jar"
         val args = listOf(
-                File(File(System.getProperty("java.home"), "bin"), "java").absolutePath,
-                "-Xmx256m",
-                "-D$COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY",
-                "-cp",
-                daemonClientClassPath.joinToString(File.pathSeparator) { it.absolutePath },
-                KotlinCompilerClient::class.qualifiedName!!) +
+            File(File(System.getProperty("java.home"), "bin"), "java").absolutePath,
+            "-Xmx256m",
+            "-D${CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.property}",
+            "-cp",
+            daemonClientClassPath.joinToString(File.pathSeparator) { it.absolutePath },
+            KotlinCompilerClient::class.qualifiedName!!) +
                    daemonOptions.mappers.flatMap { it.toArgs(COMPILE_DAEMON_CMDLINE_OPTIONS_PREFIX) } +
                    compilerId.mappers.flatMap { it.toArgs(COMPILE_DAEMON_CMDLINE_OPTIONS_PREFIX) } +
                    File(getHelloAppBaseDir(), "hello.kt").absolutePath +
@@ -651,16 +652,16 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             }
         }
 
-        System.setProperty(COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY, "true")
-        System.setProperty(COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY, "100000")
+        CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.value = "true"
+        CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.value = "100000"
 
         val succeeded = try {
             (1..ParallelStartParams.threads).forEach { connectThread(it - 1) }
             doneLatch.await(PARALLEL_WAIT_TIMEOUT_S, TimeUnit.SECONDS)
         }
         finally {
-            System.clearProperty(COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY)
-            System.clearProperty(COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY)
+            CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.clear()
+            CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.clear()
         }
 
         Thread.sleep(100) // Wait for processes to finish and close log files

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerApiTest.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.daemon.experimental.integration
 
 import com.intellij.openapi.application.ApplicationManager
 import kotlinx.coroutines.runBlocking
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
@@ -217,7 +218,7 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
 
             log.info("creating daemonJVMOptions")
             val daemonJVMOptions = configureDaemonJVMOptions(
-                "D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${externalLogFile.loggerCompatiblePath}\"",
+                "D${CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property}=\"${externalLogFile.loggerCompatiblePath}\"",
                 inheritMemoryLimits = false,
                 inheritOtherJvmOptions = false,
                 inheritAdditionalProperties = false
@@ -278,7 +279,7 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
                 reportPerf = true
             )
             val daemonJVMOptions = configureDaemonJVMOptions(
-                "D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${externalLogFile.loggerCompatiblePath}\"",
+                "D${CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property}=\"${externalLogFile.loggerCompatiblePath}\"",
                 inheritMemoryLimits = false, inheritOtherJvmOptions = false, inheritAdditionalProperties = false
             )
             try {

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt

@@ -11,6 +11,7 @@ import junit.framework.TestCase
 import kotlinx.coroutines.*
 import org.jetbrains.kotlin.cli.AbstractCliTest
 import org.jetbrains.kotlin.cli.common.CLICompiler
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.cli.common.repl.*
@@ -173,7 +174,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     fun makeTestDaemonJvmOptions(logFile: File? = null, xmx: Int = 384, args: Iterable<String> = listOf()): DaemonJVMOptions {
         val additionalArgs = arrayListOf<String>()
         if (logFile != null) {
-            additionalArgs.add("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile.loggerCompatiblePath}\"")
+            additionalArgs.add("D${CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.property}=\"${logFile.loggerCompatiblePath}\"")
         }
         args.forEach { additionalArgs.add(it) }
         val baseOpts = if (xmx > 0) DaemonJVMOptions(maxMemory = "${xmx}m") else DaemonJVMOptions()
@@ -230,10 +231,10 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     }
 
     fun ignore_testDaemonJvmOptionsParsing() {
-        val backupJvmOptions = System.getProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY)
+        val backupJvmOptions = System.getProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property)
         try {
             System.setProperty(
-                COMPILE_DAEMON_JVM_OPTIONS_PROPERTY,
+                CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property,
                 "-aaa,-bbb\\,ccc,-ddd,-Xmx200m,-XX:MaxMetaspaceSize=10k,-XX:ReservedCodeCacheSize=100,-xxx\\,yyy"
             )
             val opts =
@@ -243,7 +244,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             assertEquals("100", opts.reservedCodeCacheSize)
             assertEquals(arrayListOf("aaa", "bbb,ccc", "ddd", "xxx,yyy", "ea"), opts.jvmParams)
 
-            System.setProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, "-Xmx300m,-XX:MaxMetaspaceSize=10k,-XX:ReservedCodeCacheSize=100")
+            System.setProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, "-Xmx300m,-XX:MaxMetaspaceSize=10k,-XX:ReservedCodeCacheSize=100")
             val opts2 =
                 configureDaemonJVMOptions(inheritMemoryLimits = false, inheritAdditionalProperties = false, inheritOtherJvmOptions = false)
             assertEquals("300m", opts2.maxMemory)
@@ -253,7 +254,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             val myXmxParam = ManagementFactory.getRuntimeMXBean().inputArguments.first { it.startsWith("-Xmx") }
             TestCase.assertNotNull(myXmxParam)
             val myXmxVal = myXmxParam.substring(4)
-            System.clearProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY)
+            System.clearProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property)
             val opts3 = configureDaemonJVMOptions(
                 inheritMemoryLimits = true,
                 inheritOtherJvmOptions = true,
@@ -262,7 +263,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             assertEquals(myXmxVal, opts3.maxMemory)
         } finally {
             restoreSystemProperty(
-                COMPILE_DAEMON_JVM_OPTIONS_PROPERTY,
+                CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property,
                 backupJvmOptions
             )
         }
@@ -294,12 +295,12 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     }
 
     private fun withDaemonJvmOptionsSetTo(newValue: String?, fn: () -> Unit) {
-        val backup = getAndSetSystemProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, newValue)
+        val backup = getAndSetSystemProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, newValue)
 
         try {
             fn()
         } finally {
-            getAndSetSystemProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, backup)
+            getAndSetSystemProperty(CompilerSystemProperties.COMPILE_DAEMON_JVM_OPTIONS_PROPERTY.property, backup)
         }
     }
 
@@ -316,14 +317,14 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
     }
 
     fun ignore_testDaemonOptionsParsing() {
-        val backupOptions = System.getProperty(COMPILE_DAEMON_OPTIONS_PROPERTY)
+        val backupOptions = System.getProperty(CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property)
         try {
-            System.setProperty(COMPILE_DAEMON_OPTIONS_PROPERTY, "runFilesPath=abcd,autoshutdownIdleSeconds=1111")
+            System.setProperty(CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property, "runFilesPath=abcd,autoshutdownIdleSeconds=1111")
             val opts = configureDaemonOptions(DaemonOptions(shutdownDelayMilliseconds = 1))
             assertEquals("abcd", opts.runFilesPath)
             assertEquals(1111, opts.autoshutdownIdleSeconds)
         } finally {
-            restoreSystemProperty(COMPILE_DAEMON_OPTIONS_PROPERTY, backupOptions)
+            restoreSystemProperty(CompilerSystemProperties.COMPILE_DAEMON_OPTIONS_PROPERTY.property, backupOptions)
         }
     }
 
@@ -746,7 +747,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
         val args = listOf(
             File(File(System.getProperty("java.home"), "bin"), "java").absolutePath,
             "-Xmx256m",
-            "-D$COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY",
+            "-D${CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.property}",
             "-cp",
             daemonClientClassPath.joinToString(File.pathSeparator) { it.absolutePath },
             KotlinCompilerClientInstance::class.qualifiedName!!
@@ -946,15 +947,15 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
         }
 
         runBlocking {
-            System.setProperty(COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY, "true")
-            System.setProperty(COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY, "100000")
+            CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.value = "true"
+            CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.value = "100000"
 
             val succeeded = try {
                 (1..ParallelStartParams.threads).forEach { connectThread(it - 1) }
                 doneLatch.await(PARALLEL_WAIT_TIMEOUT_S, TimeUnit.SECONDS)
             } finally {
-                System.clearProperty(COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY)
-                System.clearProperty(COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY)
+                CompilerSystemProperties.COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY.clear()
+                CompilerSystemProperties.COMPILE_DAEMON_VERBOSE_REPORT_PROPERTY.clear()
             }
 
             delay(1000) // Wait for processes to finish and close log files

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.build.report.BuildReporter
 import org.jetbrains.kotlin.build.report.RemoteBuildReporter
 import org.jetbrains.kotlin.build.report.RemoteReporter
 import org.jetbrains.kotlin.cli.common.CLICompiler
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.ExitCode
-import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
 import org.jetbrains.kotlin.cli.common.arguments.*
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -102,7 +102,7 @@ abstract class CompileServiceImplBase(
     protected val log by lazy { Logger.getLogger("compiler") }
 
     init {
-        System.setProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY, "true")
+        CompilerSystemProperties.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY.value = "true"
     }
 
     // wrapped in a class to encapsulate alive check logic

compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinCompileDaemon.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.daemon
 
 import org.jetbrains.kotlin.cli.common.CLICompiler
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.environment.setIdeaIoUseFallback
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
@@ -60,7 +61,7 @@ abstract class KotlinCompileDaemonBase {
     init {
         val logTime: String = SimpleDateFormat("yyyy-MM-dd.HH-mm-ss-SSS").format(Date())
         val (logPath: String, fileIsGiven: Boolean) =
-                System.getProperty(COMPILE_DAEMON_LOG_PATH_PROPERTY)?.trimQuotes()?.let { Pair(it, File(it).isFile) } ?: Pair("%t", false)
+            CompilerSystemProperties.COMPILE_DAEMON_LOG_PATH_PROPERTY.value?.trimQuotes()?.let { Pair(it, File(it).isFile) } ?: Pair("%t", false)
         val cfg: String =
             "handlers = java.util.logging.FileHandler\n" +
                     "java.util.logging.FileHandler.level     = ALL\n" +

compiler/daemon/src/org/jetbrains/kotlin/daemon/experimental/CompileServiceServerSideImpl.kt

@@ -16,7 +16,7 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.actor
 import kotlinx.coroutines.channels.consumeEach
 import org.jetbrains.kotlin.cli.common.CLICompiler
-import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.repl.ReplCheckResult
 import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
 import org.jetbrains.kotlin.cli.common.repl.ReplCompileResult
@@ -402,7 +402,7 @@ class CompileServiceServerSideImpl(
         scheduler = CompileServiceTaskScheduler(log)
 
         // assuming logically synchronized
-        System.setProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY, "true")
+        CompilerSystemProperties.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY.value = "true"
 
         // TODO UNCOMMENT THIS : this.toRMIServer(daemonOptions, compilerId) // also create RMI server in order to support old clients
 //        rmiServer = this.toRMIServer(daemonOptions, compilerId)

compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java

@@ -601,6 +601,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt");
         }
 
+        @TestMetadata("typeMismatchOnExpectedJavaMap.kt")
+        public void testTypeMismatchOnExpectedJavaMap() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/arguments/typeMismatchOnExpectedJavaMap.kt");
+        }
+
         @TestMetadata("untouchedReturnInIf.kt")
         public void testUntouchedReturnInIf() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/arguments/untouchedReturnInIf.kt");
@@ -2394,6 +2399,34 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         }
     }
 
+    @TestMetadata("compiler/fir/analysis-tests/testData/resolve/inlineClasses")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class InlineClasses extends AbstractLazyBodyIsNotTouchedTilContractsPhaseTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInInlineClasses() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inlineClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
+        }
+
+        @TestMetadata("inlineClassConstructor.kt")
+        public void testInlineClassConstructor() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassConstructor.kt");
+        }
+
+        @TestMetadata("inlineClassDeclaration.kt")
+        public void testInlineClassDeclaration() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassDeclaration.kt");
+        }
+
+        @TestMetadata("inlineClassMembers.kt")
+        public void testInlineClassMembers() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassMembers.kt");
+        }
+    }
+
     @TestMetadata("compiler/fir/analysis-tests/testData/resolve/innerClasses")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt

@@ -38,7 +38,7 @@ abstract class AbstractFirLoadCompiledKotlin : AbstractFirLoadBinariesTest() {
         val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 
         prepareProjectExtensions(environment.project)
-        val sessionWithDependency = createSession(environment, GlobalSearchScope.EMPTY_SCOPE)
+        val sessionWithDependency = createSessionForTests(environment, GlobalSearchScope.EMPTY_SCOPE)
 
         val testDataDirectoryPath =
             "compiler/fir/analysis-tests/testData/loadCompiledKotlin/" +

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/BuiltInsDeserializationForFirTestCase.kt

@@ -18,7 +18,7 @@ class BuiltInsDeserializationForFirTestCase : AbstractFirLoadBinariesTest() {
 
     fun testBuiltInPackagesContent() {
         val moduleDescriptor = BuiltinsTestUtils.compileBuiltinsModule(environment)
-        val session = createSession(environment, GlobalSearchScope.allScope(project))
+        val session = createSessionForTests(environment, GlobalSearchScope.allScope(project))
         for (packageFqName in BuiltinsTestUtils.BUILTIN_PACKAGE_NAMES) {
             val path = "compiler/fir/analysis-tests/testData/builtIns/" + packageFqName.asString().replace('.', '-') + ".txt"
             checkPackageContent(session, packageFqName, moduleDescriptor, path)

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.createSession
+import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
@@ -131,7 +131,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
 
         val scope = GlobalSearchScope.filesScope(project, virtualFiles)
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
-        val session = createSession(environment, scope)
+        val session = createSessionForTests(environment, scope)
 
         val topPsiClasses = psiFiles.flatMap { it.getChildrenOfType<PsiClass>().toList() }
 

compiler/fir/analysis-tests/testData/builtIns/kotlin-collections.txt

@@ -1,5 +1,5 @@
 public/*package*/ open class ArraysUtilJVM : R|kotlin/Any| {
-    public/*package*/ open static fun <T : R|ft<@FlexibleNullability kotlin/Any, kotlin/Any?>!|> asList(p0: T[]): java.util.List<T>
+    public/*package*/ open static fun <T : R|ft<kotlin/Any, kotlin/Any?>|> asList(p0: T[]): java.util.List<T>
 
     public/*package*/ constructor(): R|kotlin/collections/ArraysUtilJVM|
 
@@ -304,4 +304,3 @@ public abstract class ShortIterator : R|kotlin/collections/Iterator<kotlin/Short
     public constructor(): R|kotlin/collections/ShortIterator|
 
 }
-

compiler/fir/analysis-tests/testData/enhancement/jsr305/NonNullNever.fir.txt

@@ -3,9 +3,9 @@
 
 }
 public open class NonNullNever : R|kotlin/Any| {
-    @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) public open field field: R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) public open field field: R|@EnhancedNullability kotlin/String?|
 
-    @R|MyNullable|() public open fun foo(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) x: R|@FlexibleNullability kotlin/String?|, @R|MyNullable|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String?|
+    @R|MyNullable|() public open fun foo(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) x: R|@EnhancedNullability kotlin/String?|, @R|MyNullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String?|
 
     public constructor(): R|NonNullNever|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/Simple.fir.txt

@@ -1,7 +1,7 @@
 public open class Simple : R|kotlin/Any| {
-    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@EnhancedNullability kotlin/String?|
 
-    @R|javax/annotation/Nullable|() public open fun foo(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open fun foo(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String?|
 
     @R|javax/annotation/Nonnull|() public open fun bar(): R|@EnhancedNullability kotlin/String|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/Strange.fir.txt

@@ -1,7 +1,7 @@
 public open class Strange : R|kotlin/Any| {
-    @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) public open field field: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) public open field field: R|ft<kotlin/String, kotlin/String?>|
 
-    @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.MAYBE|()) public open fun foo(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.ALWAYS|()) x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.MAYBE|()) public open fun foo(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.ALWAYS|()) x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String?|
 
     @R|javax/annotation/Nonnull|() public open fun bar(): R|@EnhancedNullability kotlin/String|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/FieldsAreNullable.fir.txt

@@ -1,9 +1,9 @@
 @R|FieldsAreNullable|() public open class A : R|kotlin/Any| {
-    public open field field: R|@FlexibleNullability kotlin/String?|
+    public open field field: R|@EnhancedNullability kotlin/String?|
 
     @R|javax/annotation/Nonnull|() public open field nonNullField: R|@EnhancedNullability kotlin/String|
 
-    public open fun foo(q: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open fun foo(q: R|ft<kotlin/String, kotlin/String?>|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
 
     @R|javax/annotation/Nonnull|() public open fun bar(): R|@EnhancedNullability kotlin/String|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/ForceFlexibility.fir.txt

@@ -1,7 +1,7 @@
 @R|spr/NonNullApi|() public open class A : R|kotlin/Any| {
-    public open fun foo(x: R|@FlexibleNullability kotlin/String|, @R|spr/Nullable|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String|
+    public open fun foo(x: R|@EnhancedNullability kotlin/String|, @R|spr/Nullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String|
 
-    @R|spr/ForceFlexibility|() public open fun bar(x: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|, @R|javax/annotation/Nonnull|() y: R|@EnhancedNullability kotlin/CharSequence|): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    @R|spr/ForceFlexibility|() public open fun bar(x: R|ft<kotlin/String, kotlin/String?>|, @R|javax/annotation/Nonnull|() y: R|@EnhancedNullability kotlin/CharSequence|): R|ft<kotlin/String, kotlin/String?>|
 
     public constructor(): R|A|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/ForceFlexibleOverOverrides.fir.txt

@@ -1,11 +1,11 @@
 @R|spr/NonNullApi|() public open class A : R|kotlin/Any|, R|B| {
-    @R|spr/ForceFlexibility|() public open fun foo(x: R|@FlexibleNullability kotlin/String|): R|kotlin/Unit|
+    @R|spr/ForceFlexibility|() public open fun foo(x: R|@EnhancedNullability kotlin/String|): R|kotlin/Unit|
 
-    public open fun bar(@R|spr/ForceFlexibility|() x: R|@FlexibleNullability kotlin/String|): R|kotlin/Unit|
+    public open fun bar(@R|spr/ForceFlexibility|() x: R|@EnhancedNullability kotlin/String|): R|kotlin/Unit|
 
-    public open fun baz(@R|spr/UnknownNullability|() x: R|@FlexibleNullability kotlin/String|): R|kotlin/Unit|
+    public open fun baz(@R|spr/UnknownNullability|() x: R|@EnhancedNullability kotlin/String|): R|kotlin/Unit|
 
-    public open fun foobar(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) x: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|): R|kotlin/Unit|
+    public open fun foobar(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) x: R|ft<kotlin/String, kotlin/String?>|): R|kotlin/Unit|
 
     public constructor(): R|A|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/NullabilityFromOverridden.fir.txt

@@ -1,55 +1,55 @@
 @R|NonNullApi|() public open class A : R|kotlin/Any| {
-    public open fun foo1(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun foo1(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
-    public open fun foo2(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun foo2(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
-    public open fun foo3(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun foo3(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
-    @R|javax/annotation/Nullable|() public open fun bar1(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open fun bar1(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
 
-    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
 
-    public open fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
     public constructor(): R|A|
 
 }
 @R|NonNullApi|() public abstract interface AInt : R|kotlin/Any| {
-    public abstract fun foo1(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/CharSequence|
+    public abstract fun foo1(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/CharSequence|
 
-    public abstract fun foo2(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/CharSequence|
+    public abstract fun foo2(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/CharSequence|
 
-    public abstract fun foo3(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/CharSequence|
+    public abstract fun foo3(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/CharSequence|
 
-    @R|javax/annotation/Nullable|() public abstract fun bar1(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/CharSequence?|
+    @R|javax/annotation/Nullable|() public abstract fun bar1(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/CharSequence?|
 
-    @R|javax/annotation/Nullable|() public abstract fun bar2(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/CharSequence?|
+    @R|javax/annotation/Nullable|() public abstract fun bar2(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/CharSequence?|
 
-    public abstract fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@FlexibleNullability kotlin/CharSequence|
+    public abstract fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/CharSequence|
 
 }
 @R|NullableApi|() public open class B : R|A|, R|AInt| {
-    public open fun foo1(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun foo1(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
     @R|javax/annotation/Nonnull|() public open fun foo2(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
-    public open fun bar1(x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
+    public open fun bar1(x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
 
-    public open fun baz(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun baz(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
     public constructor(): R|B|
 
 }
 @R|NonNullApi|() public open class C : R|A|, R|AInt| {
-    public open fun foo1(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun foo1(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
-    public open fun foo2(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun foo2(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
-    public open fun bar1(x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
+    public open fun bar1(x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
 
-    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
 
-    public open fun baz(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
+    public open fun baz(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
 
     public constructor(): R|C|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/OverridingDefaultQualifier.fir.txt

@@ -1,13 +1,13 @@
 @R|NonNullApi|() public open class A : R|kotlin/Any| {
-    public open field field: R|@FlexibleNullability kotlin/String|
+    public open field field: R|@EnhancedNullability kotlin/String|
 
-    public open fun foo(x: R|@FlexibleNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String|
+    public open fun foo(x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String|
 
-    @R|NullableApi|() public open fun foobar(x: R|@FlexibleNullability kotlin/String?|, @R|NonNullApi|() y: R|@FlexibleNullability kotlin/CharSequence|): R|@FlexibleNullability kotlin/String?|
+    @R|NullableApi|() public open fun foobar(x: R|@EnhancedNullability kotlin/String?|, @R|NonNullApi|() y: R|@EnhancedNullability kotlin/CharSequence|): R|@EnhancedNullability kotlin/String?|
 
-    public open fun bar(): R|@FlexibleNullability kotlin/String|
+    public open fun bar(): R|@EnhancedNullability kotlin/String|
 
-    @R|javax/annotation/Nullable|() public open fun baz(): R|ft<@FlexibleNullability kotlin/collections/MutableList<ft<@FlexibleNullability kotlin/String, kotlin/String?>!>?, kotlin/collections/List<ft<@FlexibleNullability kotlin/String, kotlin/String?>!>?>?|
+    @R|javax/annotation/Nullable|() public open fun baz(): R|ft<@EnhancedNullability kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, @EnhancedNullability kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>|
 
     public constructor(): R|A|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/ParametersAreNonnullByDefault.fir.txt

@@ -1,7 +1,7 @@
 @R|javax/annotation/ParametersAreNonnullByDefault|() public open class A : R|kotlin/Any| {
-    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@EnhancedNullability kotlin/String?|
 
-    public open fun foo(q: R|@FlexibleNullability kotlin/String|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open fun foo(q: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
 
     @R|javax/annotation/Nonnull|() public open fun bar(): R|@EnhancedNullability kotlin/String|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/ParametersAreNonnullByDefaultPackage.fir.txt

@@ -1,7 +1,7 @@
 public open class A : R|kotlin/Any| {
-    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@EnhancedNullability kotlin/String?|
 
-    public open fun foo(q: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open fun foo(q: R|ft<kotlin/String, kotlin/String?>|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
 
     @R|javax/annotation/Nonnull|() public open fun bar(): R|@EnhancedNullability kotlin/String|
 
@@ -9,9 +9,9 @@ public open class A : R|kotlin/Any| {
 
 }
 public open class A2 : R|kotlin/Any| {
-    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@EnhancedNullability kotlin/String?|
 
-    public open fun foo(q: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open fun foo(q: R|ft<kotlin/String, kotlin/String?>|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
 
     @R|javax/annotation/Nonnull|() public open fun bar(): R|@EnhancedNullability kotlin/String|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/SpringNullable.fir.txt

@@ -1,11 +1,11 @@
 @R|spr/NonNullApi|() public open class A : R|kotlin/Any| {
-    public open field field: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open field field: R|ft<kotlin/String, kotlin/String?>|
 
-    public open fun foo(x: R|@FlexibleNullability kotlin/String|, @R|spr/Nullable|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String|
+    public open fun foo(x: R|@EnhancedNullability kotlin/String|, @R|spr/Nullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String|
 
-    public open fun bar(): R|@FlexibleNullability kotlin/String|
+    public open fun bar(): R|@EnhancedNullability kotlin/String|
 
-    @R|spr/Nullable|() public open fun baz(): R|ft<@FlexibleNullability kotlin/collections/MutableList<ft<@FlexibleNullability kotlin/String, kotlin/String?>!>?, kotlin/collections/List<ft<@FlexibleNullability kotlin/String, kotlin/String?>!>?>?|
+    @R|spr/Nullable|() public open fun baz(): R|ft<@EnhancedNullability kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, @EnhancedNullability kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>|
 
     public constructor(): R|A|
 

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/SpringNullablePackage.fir.txt

@@ -1,11 +1,11 @@
 public open class A : R|kotlin/Any| {
-    public open field field: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open field field: R|ft<kotlin/String, kotlin/String?>|
 
-    public open fun foo(x: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|, @R|spr/Nullable|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open fun foo(x: R|ft<kotlin/String, kotlin/String?>|, @R|spr/Nullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
 
-    public open fun bar(): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
+    public open fun bar(): R|ft<kotlin/String, kotlin/String?>|
 
-    @R|spr/Nullable|() public open fun baz(): R|ft<@FlexibleNullability kotlin/collections/MutableList<ft<@FlexibleNullability kotlin/String, kotlin/String?>!>?, kotlin/collections/List<ft<@FlexibleNullability kotlin/String, kotlin/String?>!>?>?|
+    @R|spr/Nullable|() public open fun baz(): R|ft<@EnhancedNullability kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, @EnhancedNullability kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>|
 
     public constructor(): R|test/A|
 

compiler/fir/analysis-tests/testData/enhancement/mapping/AbstractMap.fir.txt

@@ -1,4 +1,4 @@
-public abstract class AbstractMap : R|kotlin/Any|, R|kotlin/collections/MutableMap<ft<@FlexibleNullability kotlin/String, kotlin/String?>!, ft<@FlexibleNullability kotlin/String, kotlin/String?>!>| {
+public abstract class AbstractMap : R|kotlin/Any|, R|kotlin/collections/MutableMap<ft<kotlin/String, kotlin/String?>, ft<kotlin/String, kotlin/String?>>| {
     public constructor(): R|AbstractMap|
 
 }

compiler/fir/analysis-tests/testData/loadCompiledKotlin/type/Platform.txt

@@ -1,6 +1,5 @@
-public final fun array(a: R|kotlin/Array<kotlin/Int>|): R|ft<kotlin/Array<ft<kotlin/Int, kotlin/Int?>!>, kotlin/Array<out ft<kotlin/Int, kotlin/Int?>!>?>!|
+public final fun array(a: R|kotlin/Array<kotlin/Int>|): R|ft<kotlin/Array<ft<kotlin/Int, kotlin/Int?>>, kotlin/Array<out ft<kotlin/Int, kotlin/Int?>>?>|
 
-public final fun list(): R|ft<kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>!>, kotlin/collections/List<ft<kotlin/String, kotlin/String?>!>?>!|
-
-public final fun printStream(): R|ft<java/io/PrintStream, java/io/PrintStream?>!|
+public final fun list(): R|ft<kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>, kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>|
 
+public final fun printStream(): R|ft<java/io/PrintStream, java/io/PrintStream?>|

compiler/fir/analysis-tests/testData/resolve/arguments/kt41940.fir.txt

@@ -1,4 +1,4 @@
 FILE: main.kt
     public final fun test(list: R|kotlin/collections/List<kotlin/String>|, string: R|kotlin/String|): R|kotlin/Unit| {
-        R|/Matchers.assertThat|<R|ft<kotlin/collections/List<kotlin/String>, kotlin/collections/List<kotlin/String>?>!|>(R|<local>/list|, R|/Matchers.hasItem|<R|ft<kotlin/String, kotlin/String?>!|>(R|<local>/string|))
+        R|/Matchers.assertThat|<R|ft<kotlin/collections/List<kotlin/String>, kotlin/collections/List<kotlin/String>?>|>(R|<local>/list|, R|/Matchers.hasItem|<R|ft<kotlin/String, kotlin/String?>|>(R|<local>/string|))
     }

compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.fir.txt

@@ -7,7 +7,7 @@ FILE: main.kt
     public abstract interface PsiClass : R|kotlin/Any| {
     }
     public final fun test(): R|kotlin/Unit| {
-        lval processor: R|AdapterProcessor<ft<PsiMethod, PsiMethod?>!, ft<PsiClass, PsiClass?>!>| = R|/AdapterProcessor.AdapterProcessor|<R|ft<PsiMethod, PsiMethod?>!|, R|ft<PsiClass, PsiClass?>!|>(R|/Function|<R|ft<PsiMethod, PsiMethod?>!|, R|PsiClass?|>(<L> = Function@fun <anonymous>(method: R|PsiMethod?|): R|PsiClass?| {
+        lval processor: R|AdapterProcessor<ft<PsiMethod, PsiMethod?>, ft<PsiClass, PsiClass?>>| = R|/AdapterProcessor.AdapterProcessor|<R|ft<PsiMethod, PsiMethod?>|, R|ft<PsiClass, PsiClass?>|>(R|/Function|<R|ft<PsiMethod, PsiMethod?>|, R|PsiClass?|>(<L> = Function@fun <anonymous>(method: R|PsiMethod?|): R|PsiClass?| {
             ^ R|<local>/method|?.{ $subj$.R|/PsiMethod.containingClass| }
         }
         ))

compiler/fir/analysis-tests/testData/resolve/arguments/typeMismatchOnExpectedJavaMap.fir.txt

@@ -0,0 +1,4 @@
+FILE: main.kt
+    public final fun <T> test(executor: R|BuildActionExecuter<T>|, modelType: R|java/lang/Class<T>|, env: R|kotlin/collections/Map<kotlin/String, kotlin/String>|): R|kotlin/Unit| {
+        lval model: R|ft<BuildActionExecuter<ft<T, T?>>, BuildActionExecuter<ft<T, T?>>?>| = R|<local>/executor|.R|SubstitutionOverride</BuildActionExecuter.setEnvironmentVariables: R|ft<BuildActionExecuter<ft<T, T?>>, BuildActionExecuter<ft<T, T?>>?>|>|(R|<local>/env|)
+    }

compiler/fir/analysis-tests/testData/resolve/arguments/typeMismatchOnExpectedJavaMap.kt

@@ -0,0 +1,26 @@
+// FULL_JDK
+
+// FILE: LongRunningOperation.java
+import java.util.Map;
+import org.jetbrains.annotations.Nullable;
+
+public interface LongRunningOperation {
+    LongRunningOperation setEnvironmentVariables(@Nullable Map<String, String> envVariables);
+}
+
+// FILE: ConfigurableLauncher.java
+import java.util.Map;
+
+public interface ConfigurableLauncher<T extends ConfigurableLauncher<T>> extends LongRunningOperation {
+    @Override
+    T setEnvironmentVariables(Map<String, String> envVariables);
+}
+
+// FILE: BuildActionExecuter.java
+public interface BuildActionExecuter<T> extends ConfigurableLauncher<BuildActionExecuter<T>> {}
+
+// FILE: main.kt
+
+fun <T> test(executor: BuildActionExecuter<T>, modelType: Class<T>, env: Map<String, String>) {
+    val model = executor.setEnvironmentVariables(env)
+}

compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.dot

@@ -84,7 +84,7 @@ digraph initBlock_kt {
     20 -> {21};
     21 -> {22};
     22 -> {23};
-    23 -> {28};
+    23 -> {28}    [label=onUncaughtException];
     23 -> {24} [style=dotted];
     24 -> {25} [style=dotted];
     25 -> {26} [style=dotted];

compiler/fir/analysis-tests/testData/resolve/cfg/jumps.dot

@@ -72,7 +72,7 @@ digraph jumps_kt {
     15 -> {16};
     16 -> {17};
     17 -> {18};
-    18 -> {29};
+    18 -> {29}    [label=onUncaughtException];
     18 -> {19} [style=dotted];
     19 -> {20} [style=dotted];
     20 -> {21} [style=dotted];

compiler/fir/analysis-tests/testData/resolve/cfg/lambdaReturningObject.dot

@@ -63,7 +63,7 @@ digraph lambdaReturningObject_kt {
     }
     13 -> {14};
     14 -> {15};
-    15 -> {20};
+    15 -> {20}    [label=onUncaughtException];
     15 -> {16} [style=dotted];
     16 -> {17} [style=dotted];
     17 -> {20 18} [style=dotted];

compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.dot

@@ -107,7 +107,7 @@ digraph propertiesAndInitBlocks_kt {
     41 -> {42};
     42 -> {43};
     43 -> {44};
-    44 -> {47};
+    44 -> {47}    [label=onUncaughtException];
     44 -> {45} [style=dotted];
     45 -> {46} [style=dotted];
     46 -> {47} [style=dotted];
@@ -138,7 +138,7 @@ digraph propertiesAndInitBlocks_kt {
     51 -> {52};
     52 -> {53};
     53 -> {54};
-    54 -> {58};
+    54 -> {58}    [label=onUncaughtException];
     54 -> {55} [style=dotted];
     55 -> {56} [style=dotted];
     56 -> {57} [style=dotted];
@@ -199,7 +199,7 @@ digraph propertiesAndInitBlocks_kt {
     70 -> {71};
     71 -> {72};
     72 -> {73};
-    73 -> {76};
+    73 -> {76}    [label=onUncaughtException];
     73 -> {74} [style=dotted];
     74 -> {75} [style=dotted];
     75 -> {76} [style=dotted];
@@ -246,7 +246,7 @@ digraph propertiesAndInitBlocks_kt {
     28 -> {48 34} [color=green];
     28 -> {48 34} [style=dashed];
     29 -> {30};
-    30 -> {81};
+    30 -> {81}    [label=onUncaughtException];
     30 -> {31} [style=dotted];
     31 -> {32} [style=dotted];
     32 -> {33} [style=dotted];

compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.dot

@@ -204,7 +204,8 @@ digraph returnValuesFromLambda_kt {
     57 -> {65} [style=dashed];
     58 -> {60} [style=dotted];
     59 -> {60} [style=dotted];
-    60 -> {64 61} [style=dotted];
+    60 -> {61} [style=dotted];
+    60 -> {64} [style=dotted]    [label=onUncaughtException];
     61 -> {62} [style=dotted];
     62 -> {63} [style=dotted];
     63 -> {64} [style=dotted];

compiler/fir/analysis-tests/testData/resolve/defaultJavaImportHiding.fir.txt

@@ -20,13 +20,13 @@ FILE: main.kt
 
     }
     public final fun test_1(): R|kotlin/Unit| {
-        lval map: R|util/HashMap<ft<kotlin/Int, kotlin/Int?>!, ft<kotlin/Int, kotlin/Int?>!>| = R|util/HashMap.HashMap|<R|ft<kotlin/Int, kotlin/Int?>!|, R|ft<kotlin/Int, kotlin/Int?>!|>()
+        lval map: R|util/HashMap<ft<kotlin/Int, kotlin/Int?>, ft<kotlin/Int, kotlin/Int?>>| = R|util/HashMap.HashMap|<R|ft<kotlin/Int, kotlin/Int?>|, R|ft<kotlin/Int, kotlin/Int?>|>()
     }
     public final fun test_2(): R|kotlin/Unit| {
         lval set: R|util/HashSet<kotlin/Int>| = R|util/HashSet.HashSet|<R|kotlin/Int|>()
     }
     public final fun test_3(): R|kotlin/Unit| {
-        lval list: R|foo/ArrayList<ft<kotlin/Int, kotlin/Int?>!>| = R|foo/ArrayList.ArrayList|<R|ft<kotlin/Int, kotlin/Int?>!|>()
+        lval list: R|foo/ArrayList<ft<kotlin/Int, kotlin/Int?>>| = R|foo/ArrayList.ArrayList|<R|ft<kotlin/Int, kotlin/Int?>|>()
     }
     public final fun test_4(): R|kotlin/Unit| {
         lval list: R|foo/LinkedList<kotlin/Int>| = R|foo/LinkedList.LinkedList|<R|kotlin/Int|>()

compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt

@@ -1,9 +1,9 @@
-data class A {}
+data <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>class A<!> {}
 
-<!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>data class B {
+data <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>class B<!> {
     constructor()
-}<!>
+}
 
-<!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>data class C {
+data <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>class C<!> {
     constructor(x: Int)
-}<!>
+}

compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.fir.txt

@@ -5,7 +5,7 @@ FILE: KotlinImporterComponent.kt
         }
 
         public final class State : R|kotlin/Any| {
-            public constructor(directories: R|kotlin/collections/List<kotlin/String>| = R|java/util/ArrayList.ArrayList|<R|ft<kotlin/String, kotlin/String?>!|>()): R|simulation/KotlinImporterComponent.State| {
+            public constructor(directories: R|kotlin/collections/List<kotlin/String>| = R|java/util/ArrayList.ArrayList|<R|ft<kotlin/String, kotlin/String?>|>()): R|simulation/KotlinImporterComponent.State| {
                 super<R|kotlin/Any|>()
             }
 

compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveWhenAndFlexibleType.fir.txt

@@ -15,7 +15,7 @@ FILE: main.kt
 
     }
     public final fun test_1(): R|kotlin/Unit| {
-        lval e: R|ft<@FlexibleNullability E, E?>!| = Q|Utils|.R|/Utils.getEnum|()
+        lval e: R|ft<E, E?>| = Q|Utils|.R|/Utils.getEnum|()
         lval s: R|kotlin/String| = when (R|<local>/e|) {
             ==($subj$, Null(null)) ->  {
                 ^test_1 Unit
@@ -34,7 +34,7 @@ FILE: main.kt
         R|<local>/s|.R|kotlin/String.length|
     }
     public final fun test_2(): R|kotlin/Unit| {
-        lval e: R|ft<@FlexibleNullability E, E?>!| = Q|Utils|.R|/Utils.getEnum|()
+        lval e: R|ft<E, E?>| = Q|Utils|.R|/Utils.getEnum|()
         lval s: R|kotlin/String| = when (R|<local>/e|) {
             ==($subj$, Q|E|.R|/E.A|) ->  {
                 String()