fixup! step 2: keep iterators in public, but deprecated with error

Drop unsignedLiteralsOn1_2 because apiversion 1.2 is no longer supported
Drop experimental unsigned literals diagnostic test

.gitignore

@@ -32,6 +32,8 @@ build/
 .idea/modules
 .idea/runConfigurations/JPS_*.xml
 .idea/runConfigurations/PILL_*.xml
+.idea/runConfigurations/_FP_*.xml
+.idea/runConfigurations/_MT_*.xml
 .idea/libraries
 .idea/modules.xml
 .idea/gradle.xml
@@ -54,6 +56,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 +66,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/dictionaries/sebastiansellmair.xml

@@ -0,0 +1,8 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="sebastiansellmair">
+    <words>
+      <w>cinterops</w>
+      <w>interops</w>
+    </words>
+  </dictionary>
+</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_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>

ReadMe.md

@@ -106,6 +106,8 @@ To reproduce TeamCity build use `-Pteamcity=true` flag. Local builds don't run p
 **OPTIONAL:** Some artifacts, mainly Maven plugin ones, are built separately with Maven.
 Refer to [libraries/ReadMe.md](libraries/ReadMe.md) for details.
 
+To build Kotlin/Native, see
+[kotlin-native/README.md](kotlin-native/README.md#building-from-source).
 
 ### Building for different versions of IntelliJ IDEA and Android Studio
 
@@ -145,28 +147,6 @@ From this root project there are Run/Debug Configurations for running `IDEA` or
 * Run the `IDEA` run configuration in the project
 * A child IntelliJ IDEA with the Kotlin plugin will then startup
 
-### Including into composite build
-
-To include kotlin compiler into [composite build](https://docs.gradle.org/current/userguide/composite_builds.html) you need to define `dependencySubstitution` for `kotlin-compiler` module in `settings.gradle.kts`
-
-```Kotlin
-includeBuild("/path/to/kotlin") {
-    dependencySubstitution {
-        substitute(module("org.jetbrains.kotlin:kotlin-compiler"))
-            .with(project(":include:kotlin-compiler"))
-    }
-}
-```
-
-or in `settings.gradle`
-
-```Groovy
-includeBuild('/path/to/kotlin') {
-    dependencySubstitution {
-        substitute module('org.jetbrains.kotlin:kotlin-compiler') with project(':include:kotlin-compiler')
-    }
-}
-```
 
 # License
 Kotlin is distributed under the terms of the Apache License (Version 2.0). See [license folder](license/README.md) for details.

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/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

@@ -27,7 +27,7 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.25")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath(kotlin("serialization", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
@@ -159,6 +159,7 @@ rootProject.apply {
     from(rootProject.file("gradle/checkArtifacts.gradle.kts"))
     from(rootProject.file("gradle/checkCacheability.gradle.kts"))
     from(rootProject.file("gradle/retryPublishing.gradle.kts"))
+    from(rootProject.file("gradle/modularizedTestConfigurations.gradle.kts"))
 }
 
 IdeVersionConfigurator.setCurrentIde(project)
@@ -182,7 +183,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
@@ -565,10 +566,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 {
@@ -578,6 +582,7 @@ gradle.buildFinished {
                         }
                     }
                 }
+        }
     }
 }
 
@@ -621,17 +626,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 ->
@@ -730,10 +730,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")
@@ -741,6 +743,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")
@@ -892,17 +895,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")
@@ -1209,7 +1206,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

@@ -11,10 +11,8 @@ buildscript {
 
     repositories {
         if (cacheRedirectorEnabled) {
-            maven("https://cache-redirector.jetbrains.com/jcenter.bintray.com")
             maven("https://cache-redirector.jetbrains.com/maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies")
         } else {
-            jcenter()
             maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies")
         }
 
@@ -24,7 +22,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.25")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -84,10 +82,9 @@ extra["versions.androidDxSources"] = "5.0.0_r2"
 extra["customDepsOrg"] = "kotlin.build"
 
 repositories {
-    jcenter()
+    mavenCentral()
     maven("https://jetbrains.bintray.com/intellij-third-party-dependencies/")
     maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies")
-    maven("https://kotlin.bintray.com/kotlinx")
     gradlePluginPortal()
 
     extra["bootstrapKotlinRepo"]?.let {
@@ -147,8 +144,8 @@ java {
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.25")
-    implementation("com.gradle.publish:plugin-publish-plugin:0.12.0")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
+    implementation("com.gradle.publish:plugin-publish-plugin:0.13.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
     implementation("net.rubygrapefruit:native-platform-windows-amd64:${property("versions.native-platform")}")
@@ -161,7 +158,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 +196,7 @@ java {
 }
 
 tasks.withType<KotlinCompile>().configureEach {
+    kotlinOptions.allWarningsAsErrors = true
     kotlinOptions.freeCompilerArgs += listOf(
         "-Xopt-in=kotlin.RequiresOptIn",
         "-Xskip-runtime-version-check",
@@ -262,4 +260,4 @@ gradlePlugin {
             implementationClass = "org.jetbrains.kotlin.NativeInteropPlugin"
         }
     }
-}
+}

buildSrc/settings.gradle

@@ -20,7 +20,7 @@ buildscript {
         }
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.25")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
     }
 }
 

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/pill/PillExtension.kt

@@ -10,31 +10,16 @@ import java.io.File
 import org.gradle.api.Project
 
 open class PillExtension {
+    /*
+     * Here's how you can specify a custom variant:
+     * `./gradlew pill -Dpill.variant=<NAME>`
+     */
     enum class Variant {
-        // Default variant (./gradlew pill)
-        BASE() {
-            override val includes = setOf(BASE)
-        },
-
-        // Full variant (./gradlew pill -Dpill.variant=full)
-        FULL() {
-            override val includes = setOf(BASE, FULL)
-        },
-
-        // Do not import the project to JPS model, but set some options for it
-        NONE() {
-            override val includes = emptySet<Variant>()
-        },
-
-        // 'BASE' if the "jps-compatible" plugin is applied, 'NONE' otherwise
-        DEFAULT() {
-            override val includes = emptySet<Variant>()
-        };
-
-        abstract val includes: Set<Variant>
+        BASE, // Includes compiler and IDE (default)
+        FULL, // Includes compiler, IDE and Gradle plugin
     }
 
-    open var variant: Variant = Variant.DEFAULT
+    open var variant: Variant? = null
 
     open var excludedDirs: List<File> = emptyList()
 
@@ -45,7 +30,7 @@ open class PillExtension {
 
     @Suppress("unused")
     fun serialize() = mapOf<String, Any?>(
-        "variant" to variant.name,
+        "variant" to variant?.name,
         "excludedDirs" to excludedDirs
     )
 }

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
@@ -43,6 +46,7 @@ val kotlinGradlePluginAndItsRequired = arrayOf(
     ":kotlin-gradle-subplugin-example",
     ":kotlin-stdlib-common",
     ":kotlin-stdlib",
+    ":kotlin-stdlib-jdk7",
     ":kotlin-stdlib-jdk8",
     ":kotlin-stdlib-js",
     ":examples:annotation-processor-example",
@@ -80,129 +84,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 +245,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/ClassFileFactory.java

@@ -52,13 +52,14 @@ import org.jetbrains.org.objectweb.asm.Type;
 import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.getMappingFileName;
 
 public class ClassFileFactory implements OutputFileCollection {
     private final GenerationState state;
     private final ClassBuilderFactory builderFactory;
-    private final Map<String, OutAndSourceFileList> generators = new LinkedHashMap<>();
+    private final Map<String, OutAndSourceFileList> generators = Collections.synchronizedMap(new LinkedHashMap<>());
 
     private boolean isDone = false;
 
@@ -346,7 +347,9 @@ public class ClassFileFactory implements OutputFileCollection {
 
         @Override
         public byte[] asBytes(ClassBuilderFactory factory) {
-            return factory.asBytes(classBuilder);
+            synchronized(this) {
+                return factory.asBytes(classBuilder);
+            }
         }
 
         @Override

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/inline/GlobalInlineContext.kt

@@ -9,15 +9,16 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.utils.threadLocal
 import java.util.*
 
 class GlobalInlineContext(private val diagnostics: DiagnosticSink) {
     // Ordered set of declarations and inline calls being generated right now.
     // No call in it should point to a declaration that's before it in the stack.
-    private val inlineCallsAndDeclarations = LinkedList<Any? /* CallableDescriptor | PsiElement? */>()
-    private val inlineDeclarationSet = mutableSetOf<CallableDescriptor>()
+    private val inlineCallsAndDeclarations by threadLocal { LinkedList<Any? /* CallableDescriptor | PsiElement? */>() }
+    private val inlineDeclarationSet by threadLocal { mutableSetOf<CallableDescriptor>() }
 
-    private val typesUsedInInlineFunctions = LinkedList<MutableSet<String>>()
+    private val typesUsedInInlineFunctions by threadLocal { LinkedList<MutableSet<String>>() }
 
     fun enterDeclaration(descriptor: CallableDescriptor) {
         assert(descriptor.original !in inlineDeclarationSet) { "entered inlining cycle on $descriptor" }

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

@@ -28,12 +28,14 @@ class InlineCache {
 }
 
 inline fun <K, V : Any> SLRUMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V {
-    val value = get(key)
-    return if (value == null) {
-        val answer = defaultValue()
-        put(key, answer)
-        answer
-    } else {
-        value
+    synchronized(this) {
+        val value = get(key)
+        return if (value == null) {
+            val answer = defaultValue()
+            put(key, answer)
+            answer
+        } else {
+            value
+        }
     }
 }

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import com.intellij.psi.PsiElement
-import com.intellij.util.ArrayUtil
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive
@@ -108,11 +107,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) {
@@ -601,14 +598,6 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
             return (directMember as? ImportedFromObjectCallableDescriptor<*>)?.callableFromObject ?: directMember
         }
 
-        private fun cloneMethodNode(methodNode: MethodNode): MethodNode {
-            methodNode.instructions.resetLabels()
-            return MethodNode(
-                Opcodes.API_VERSION, methodNode.access, methodNode.name, methodNode.desc, methodNode.signature,
-                ArrayUtil.toStringArray(methodNode.exceptions)
-            ).also(methodNode::accept)
-        }
-
         private fun doCreateMethodNodeFromCompiled(
             callableDescriptor: CallableMemberDescriptor,
             state: GenerationState,

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/inline/inlineCodegenUtils.kt

@@ -625,3 +625,13 @@ fun MethodNode.preprocessSuspendMarkers(forInline: Boolean, keepFakeContinuation
         }
     }
 }
+
+fun cloneMethodNode(methodNode: MethodNode): MethodNode {
+    synchronized(methodNode) {
+        methodNode.instructions.resetLabels()
+        return MethodNode(
+            Opcodes.API_VERSION, methodNode.access, methodNode.name, methodNode.desc, methodNode.signature,
+            methodNode.exceptions.toTypedArray()
+        ).also(methodNode::accept)
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/CapturedVarsOptimizationMethodTransformer.kt

@@ -57,6 +57,8 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
         override fun onUseAsTainted() {
             hazard = true
         }
+
+        fun canRewrite() = !hazard && initCallInsn != null
     }
 
     private class Transformer(private val internalClassName: String, private val methodNode: MethodNode) {
@@ -72,7 +74,7 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
             assignLocalVars(frames)
 
             for (refValue in refValues) {
-                if (!refValue.hazard) {
+                if (refValue.canRewrite()) {
                     rewriteRefValue(refValue)
                 }
             }

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/BuilderFactoryForDuplicateClassNameDiagnostics.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+import java.util.concurrent.ConcurrentHashMap
 
 
 class BuilderFactoryForDuplicateClassNameDiagnostics(
@@ -29,7 +30,7 @@ class BuilderFactoryForDuplicateClassNameDiagnostics(
         private val diagnostics: DiagnosticSink
 ) : ClassNameCollectionClassBuilderFactory(builderFactory) {
 
-    private val className = hashMapOf<String, JvmDeclarationOrigin> ()
+    private val className = ConcurrentHashMap<String, JvmDeclarationOrigin>()
 
     override fun handleClashingNames(internalName: String, origin: JvmDeclarationOrigin) {
         val another = className.getOrPut(internalName, { origin })

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/build.gradle.kts

@@ -49,7 +49,6 @@ dependencies {
     testCompile(projectTests(":compiler:fir:raw-fir:light-tree2fir"))
     testCompile(projectTests(":compiler:fir:fir2ir"))
     testCompile(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
-    testCompile(projectTests(":compiler:visualizer"))
     testCompile(projectTests(":generators:test-generator"))
     testCompile(project(":compiler:ir.ir2cfg"))
     testCompile(project(":compiler:ir.tree")) // used for deepCopyWithSymbols call that is removed by proguard from the compiler TODO: make it more straightforward
@@ -103,8 +102,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/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/run.kt

@@ -42,6 +42,8 @@ found top-level declarations to <destination dir> (*.kotlin_builtins files)"""
     assert(missing.isEmpty()) { "These source directories are missing: $missing" }
 
     BuiltInsSerializer(dependOnOldBuiltIns = false).serialize(destDir, srcDirs, listOf()) { totalSize, totalFiles ->
-        println("Total bytes written: $totalSize to $totalFiles files")
+        if (System.getProperty("kotlin.builtins.serializer.log") == "true") {
+            println("Total bytes written: $totalSize to $totalFiles files")
+        }
     }
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt

@@ -74,7 +74,7 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     @Argument(
         value = "-jvm-target",
         valueDescription = "<version>",
-        description = "Target version of the generated JVM bytecode (1.6 (DEPRECATED), 1.8, 9, 10, 11, 12, 13, 14 or 15), default is 1.8"
+        description = "Target version of the generated JVM bytecode (1.6 (DEPRECATED), 1.8, 9, 10, 11, 12, 13, 14, 15 or 16), default is 1.8"
     )
     var jvmTarget: String? by NullableStringFreezableVar(JvmTarget.DEFAULT.description)
 
@@ -84,8 +84,12 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
 
     // Advanced options
 
+    @DeprecatedOption(removeAfter = "1.5", level = DeprecationLevel.WARNING)
     @GradleOption(DefaultValues.BooleanFalseDefault::class)
-    @Argument(value = "-Xuse-ir", description = "Use the IR backend")
+    @Argument(
+        value = "-Xuse-ir",
+        description = "Use the IR backend. This option has no effect unless the language version less than 1.5 is used"
+    )
     var useIR: Boolean by FreezableVar(false)
 
     @GradleOption(DefaultValues.BooleanFalseDefault::class)
@@ -489,6 +493,7 @@ default: `indy-with-constants` for JVM target 9 or greater, `inline` otherwise""
         result[JvmAnalysisFlags.enableJvmPreview] = enableJvmPreview
         result[AnalysisFlags.allowUnstableDependencies] = allowUnstableDependencies || useFir
         result[JvmAnalysisFlags.disableUltraLightClasses] = disableUltraLightClasses
+        result[JvmAnalysisFlags.useIR] = useIR
         return result
     }
 

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

@@ -13,6 +13,7 @@ import com.intellij.psi.search.PsiSearchScopeUtil
 import com.intellij.util.SmartList
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.classes.*
+import org.jetbrains.kotlin.config.JvmAnalysisFlags
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.load.java.components.FilesByFacadeFqNameIndexer
@@ -109,7 +110,7 @@ class CliKotlinAsJavaSupport(
     }
 
     override fun getLightClass(classOrObject: KtClassOrObject): KtLightClass? =
-        KtLightClassForSourceDeclaration.create(classOrObject)
+        KtLightClassForSourceDeclaration.create(classOrObject, traceHolder.languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode))
 
     override fun getLightClassForScript(script: KtScript): KtLightClassForScript? =
         KtLightClassForScript.create(script)

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

@@ -283,7 +283,7 @@ class KotlinCoreEnvironment private constructor(
 
     fun addKotlinSourceRoots(rootDirs: List<File>) {
         val roots = rootDirs.map { KotlinSourceRoot(it.absolutePath, isCommon = false) }
-        sourceFiles += createSourceFilesFromSourceRoots(configuration, project, roots)
+        sourceFiles += createSourceFilesFromSourceRoots(configuration, project, roots).toSet() - sourceFiles
     }
 
     fun createPackagePartProvider(scope: GlobalSearchScope): JvmPackagePartProvider {

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

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

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/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt

@@ -33,6 +33,9 @@ object JvmAnalysisFlags {
     @JvmStatic
     val enableJvmPreview by AnalysisFlag.Delegates.Boolean
 
+    @JvmStatic
+    val useIR by AnalysisFlag.Delegates.Boolean
+
     private object Delegates {
         object JavaTypeEnhancementStateWarnByDefault {
             operator fun provideDelegate(instance: Any?, property: KProperty<*>): AnalysisFlag.Delegate<JavaTypeEnhancementState> =

compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmTarget.kt

@@ -32,6 +32,7 @@ enum class JvmTarget(
     JVM_13("13", Opcodes.V12 + 1),
     JVM_14("14", Opcodes.V12 + 2),
     JVM_15("15", Opcodes.V12 + 3),
+    JVM_16("16", Opcodes.V12 + 4),
     ;
 
     companion object {

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");
@@ -745,6 +750,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/syntheticPropertiesWrongImplicitReceiver.kt");
         }
 
+        @TestMetadata("twoLocalLambdasWithSameName.kt")
+        public void testTwoLocalLambdasWithSameName() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/twoLocalLambdasWithSameName.kt");
+        }
+
         @TestMetadata("typeAliasWithNotNullBound.kt")
         public void testTypeAliasWithNotNullBound() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/typeAliasWithNotNullBound.kt");

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|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|kotlin/String?|, @R|MyNullable|() y: R|kotlin/CharSequence?|): R|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|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|kotlin/CharSequence?|): R|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|kotlin/CharSequence?|): R|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|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|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|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|kotlin/String?|): R|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|kotlin/String?|): R|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|kotlin/String?|): R|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|kotlin/String?|): R|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|kotlin/String?|): R|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|kotlin/String?|): R|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|kotlin/String?|): R|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|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|kotlin/String?|, @R|NonNullApi|() y: R|@EnhancedNullability kotlin/CharSequence|): R|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<kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, 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|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|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|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|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|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|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|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<kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, 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|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<kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, 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/callResolution/twoLocalLambdasWithSameName.fir.txt

@@ -0,0 +1,19 @@
+FILE: twoLocalLambdasWithSameName.kt
+    public abstract interface R : R|kotlin/Any| {
+    }
+    public final fun takeInt(x: R|kotlin/Int|): R|kotlin/Unit| {
+    }
+    public final fun test(fn: R|R.() -> kotlin/String|): R|kotlin/Unit| {
+        lval renderer: R|<anonymous>| = object : R|R| {
+            private constructor(): R|<anonymous>| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final fun render(fn: R|R.() -> kotlin/Int|): R|kotlin/Unit| {
+                lval result: R|kotlin/Int| = R|<local>/fn|.R|SubstitutionOverride<kotlin/Function1.invoke: R|kotlin/Int|>|(this@R|/<anonymous>|)
+                R|/takeInt|(R|<local>/result|)
+            }
+
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/callResolution/twoLocalLambdasWithSameName.kt

@@ -0,0 +1,13 @@
+// ISSUE: KT-45316
+interface R
+
+fun takeInt(x: Int) {}
+
+fun test(fn: R.() -> String) { // (1)
+    val renderer = object : R {
+        fun render(fn: R.() -> Int) { // (2)
+            val result = fn()
+            takeInt(result)
+        }
+    }
+}

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/annotationArgumentKClassLiteralTypeError.fir.txt

@@ -9,7 +9,7 @@ FILE: annotationArgumentKClassLiteralTypeError.kt
 
     }
     public final val <reified T> R|T|.test: R|kotlin/Any|
-        public get(): R|<anonymous><T>| {
+        public inline get(): R|<anonymous><T>| {
             ^ @R|Ann|(<implicitArrayOf>(<getClass>(R|T|), <getClass>(Q|kotlin/Array|))) object : R|kotlin/Any| {
                 private constructor(): R|<anonymous><T>| {
                     super<R|kotlin/Any|>()

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()

compiler/fir/analysis-tests/testData/resolve/expresssions/genericDiagnostic.fir.txt

@@ -13,10 +13,10 @@ FILE: test.kt
         lval element: R|DE| = R|<local>/d|.R|/Diagnostic.element|
         R|/Fix.Fix|(R|<local>/element|)
     }
-    private final val DERIVED_FACTORY: R|DiagnosticFactory0<ft<DerivedElement, DerivedElement?>!>| = R|/DiagnosticFactory0.DiagnosticFactory0|<R|ft<DerivedElement, DerivedElement?>!|>()
-        private get(): R|DiagnosticFactory0<ft<DerivedElement, DerivedElement?>!>|
+    private final val DERIVED_FACTORY: R|DiagnosticFactory0<ft<DerivedElement, DerivedElement?>>| = R|/DiagnosticFactory0.DiagnosticFactory0|<R|ft<DerivedElement, DerivedElement?>|>()
+        private get(): R|DiagnosticFactory0<ft<DerivedElement, DerivedElement?>>|
     public final fun createViaFactory(d: R|EmptyDiagnostic|): R|kotlin/Unit| {
-        lval casted: R|@FlexibleNullability Diagnostic<ft<DerivedElement, DerivedElement?>!>| = R|/DERIVED_FACTORY|.R|SubstitutionOverride</DiagnosticFactory0.cast: R|@FlexibleNullability Diagnostic<ft<DerivedElement, DerivedElement?>!>|>|(R|<local>/d|)
+        lval casted: R|Diagnostic<ft<DerivedElement, DerivedElement?>>| = R|/DERIVED_FACTORY|.R|SubstitutionOverride</DiagnosticFactory0.cast: R|Diagnostic<ft<DerivedElement, DerivedElement?>>|>|(R|<local>/d|)
         lval element: R|DerivedElement| = R|<local>/casted|.R|/Diagnostic.element|
         R|/Fix.Fix|(R|<local>/element|)
     }

compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.fir.txt

@@ -1,5 +1,5 @@
 FILE: test.kt
     public final fun test(): R|kotlin/Unit| {
-        lval staticReference: R|kotlin/reflect/KMutableProperty0<ft<@FlexibleNullability kotlin/String, kotlin/String?>!>| = Q|JavaClass|::R|/JavaClass.staticField|
-        lval nonStaticReference: R|kotlin/reflect/KMutableProperty1<JavaClass, ft<@FlexibleNullability kotlin/String, kotlin/String?>!>| = Q|JavaClass|::R|/JavaClass.nonStaticField|
+        lval staticReference: R|kotlin/reflect/KMutableProperty0<ft<kotlin/String, kotlin/String?>>| = Q|JavaClass|::R|/JavaClass.staticField|
+        lval nonStaticReference: R|kotlin/reflect/KMutableProperty1<JavaClass, ft<kotlin/String, kotlin/String?>>| = Q|JavaClass|::R|/JavaClass.nonStaticField|
     }

compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.fir.txt

@@ -37,7 +37,7 @@ FILE: O.kt
                         }
 
                         public final fun local(): R|kotlin/Unit| {
-                            lval y: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!| = this@R|/O.Derived|.R|/Base.foo|()
+                            lval y: R|ft<kotlin/String, kotlin/String?>| = this@R|/O.Derived|.R|/Base.foo|()
                         }
 
                         public final val oo: R|<anonymous>| = object : R|kotlin/Any| {
@@ -66,7 +66,7 @@ FILE: O.kt
                     }
 
                     public final fun local(): R|kotlin/Unit| {
-                        lval y: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!| = this@R|/O.Derived|.R|/Base.foo|()
+                        lval y: R|ft<kotlin/String, kotlin/String?>| = this@R|/O.Derived|.R|/Base.foo|()
                     }
 
                 }

compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticSmartCast.fir.txt

@@ -20,7 +20,7 @@ FILE: test.kt
         R|<local>/x|.R|/AnotherClass.bar|
     }
     public final fun test2(x: R|SomeClass?|): R|kotlin/Unit| {
-        lval bar: R|@FlexibleNullability kotlin/CharSequence| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| } ?: ^test2 Unit
+        lval bar: R|kotlin/CharSequence| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| } ?: ^test2 Unit
         R|<local>/x|.R|/SomeClass.bar|
     }
     public final fun test3(x: R|AnotherClass?|): R|kotlin/Unit| {
@@ -33,7 +33,7 @@ FILE: test.kt
 
     }
     public final fun test4(x: R|SomeClass?|): R|kotlin/Unit| {
-        lval bar: R|@FlexibleNullability kotlin/CharSequence?| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| }
+        lval bar: R|kotlin/CharSequence?| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| }
         when () {
             !=(R|<local>/bar|, Null(null)) ->  {
                 R|<local>/x|.R|/SomeClass.bar|.<Inapplicable(INAPPLICABLE_WRONG_RECEIVER): kotlin/CharSequence.length>#

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/flexibleTypeBug.fir.txt

@@ -1,6 +1,6 @@
 FILE: flexibleTypeBug.kt
     public final fun foo(): R|kotlin/Unit| {
-        lvar list1: R|ft<@FlexibleNullability kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>!>, kotlin/collections/List<ft<kotlin/String, kotlin/String?>!>?>!| = Q|java/util/Collections|.R|java/util/Collections.emptyList|<R|ft<kotlin/String, kotlin/String?>!|>()
+        lvar list1: R|ft<kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>, kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>| = Q|java/util/Collections|.R|java/util/Collections.emptyList|<R|ft<kotlin/String, kotlin/String?>|>()
         lval list2: R|kotlin/collections/List<kotlin/String>| = R|kotlin/collections/listOf|<R|kotlin/String|>(String(b))
-        R|<local>/list1| = R|<local>/list1|.R|kotlin/collections/plus|<R|ft<kotlin/String, kotlin/String?>!|>(R|<local>/list2|)
+        R|<local>/list1| = R|<local>/list1|.R|kotlin/collections/plus|<R|ft<kotlin/String, kotlin/String?>|>(R|<local>/list2|)
     }