Update coverage sample documentation.

We need to invoke `llvm-profdata` tool from
the same toolchain as Clang (on macOS we use the one from Xcode).

(cherry picked from commit 91665b36af68b7fb3a56c0e7ed7ebb7d819adfb2)

.gitignore

@@ -54,7 +54,6 @@ 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/
@@ -64,4 +63,4 @@ buildSrcTmp/
 distTmp/
 outTmp/
 /test.output
-/kotlin-native/dist
+/kotlin-native/dist

.idea/artifacts/kotlinx_cli_jvm_1_5_255_SNAPSHOT.xml

@@ -1,6 +1,8 @@
 <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" />
+    <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>
   </artifact>
 </component>

.idea/runConfigurations/Generate_All_Tests.xml

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

.idea/runConfigurations/Generate_Compiler_Tests.xml

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

.idea/runConfigurations/Generate_FIR_Checker_Components_and_FIR_IDE_Diagnostics.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Generate FIR Checker Components and FIR/IDE Diagnostics" type="GradleRunConfiguration" factoryName="Gradle" folderName="Generators">
+  <configuration default="false" name="Generate FIR Checker Components and FIR/IDE Diagnostics" type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="Stdlib">
+  <configuration default="false" name="Generate standard library sources" type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="IDEA">
+  <configuration default="false" name="IDEA" type="GradleRunConfiguration" factoryName="Gradle" singleton="true">
     <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" folderName="IDEA">
+  <configuration default="false" name="IDEA Ultimate" type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="IDEA">
+  <configuration default="false" name="IDEA Ultimate (No ProcessCanceledException) " type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="IDEA">
+  <configuration default="false" name="IDEA (No ProcessCanceledException)" type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="IDEA">
+  <configuration default="false" name="IDEA (Not Internal)" type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="Tests">
+  <configuration default="false" name="Test: KMM" type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="Stdlib">
+  <configuration default="false" name="Test: public API binary compatibility validator, overwrite results" type="GradleRunConfiguration" factoryName="Gradle">
     <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" folderName="Stdlib">
+  <configuration default="false" name="Test: stdlib-js public kotlin api test, overwrite results" type="GradleRunConfiguration" factoryName="Gradle">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -19,4 +19,4 @@
     <GradleScriptDebugEnabled>false</GradleScriptDebugEnabled>
     <method v="2" />
   </configuration>
-</component>
+</component>

benchmarks/build.gradle.kts

@@ -92,16 +92,18 @@ benchmark {
     }
 }
 
-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.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.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.createSessionForTests
+import org.jetbrains.kotlin.fir.createSession
 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 = createSessionForTests(env, scope)
+        val session = createSession(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
 

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

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

build.gradle.kts

@@ -182,7 +182,7 @@ extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
 extra["versions.completion-ranking-kotlin"] = "0.1.3"
-extra["versions.r8"] = "2.1.75"
+extra["versions.r8"] = "2.0.88"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -565,13 +565,10 @@ allprojects {
     }
 }
 
-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
+gradle.buildFinished {
+    val taskGraph = gradle?.taskGraph
+    if (taskGraph != null) {
+        taskGraph.allTasks
                 .filterIsInstance<SourceTask>()
                 .filter { it.didWork }
                 .forEach {
@@ -581,7 +578,6 @@ if ((gradle.startParameter as? org.gradle.api.internal.StartParameterInternal)?.
                         }
                     }
                 }
-        }
     }
 }
 
@@ -625,12 +621,17 @@ val ideaPlugin by task<Task> {
 }
 
 tasks {
-    named<Delete>("clean") {
-        delete += setOf("$buildDir/repo", distDir)
+    named("clean") {
+        doLast {
+            delete("$buildDir/repo")
+            delete(distDir)
+        }
     }
 
-    register<Delete>("cleanupArtifacts") {
-        delete = setOf(artifactsDir)
+    register("cleanupArtifacts") {
+        doLast {
+            delete(artifactsDir)
+        }
     }
 
     listOf("clean", "assemble", "install").forEach { taskName ->
@@ -729,12 +730,10 @@ tasks {
     register("scriptingTest") {
         dependsOn("dist")
         dependsOn(":kotlin-script-util:test")
-        dependsOn(":kotlin-scripting-compiler:test")
-        dependsOn(":kotlin-scripting-compiler:testWithIr")
+        dependsOn(":kotlin-scripting-compiler-embeddable:test")
         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")
@@ -742,7 +741,6 @@ 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")
@@ -894,11 +892,17 @@ tasks {
         if (Ide.IJ()) {
             dependsOn(
                 ":libraries:tools:new-project-wizard:test",
-                ":libraries:tools:new-project-wizard:new-project-wizard-cli: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
             )
         }
     }
 
+    register("ideaIntegrationsTests") {
+        if (Ide.IJ()) {
+            dependsOn(":idea:idea-new-project-wizard:test")
+        }
+    }
 
     register("kaptIdeTest") {
         dependsOn(":kotlin-annotation-processing:test")
@@ -1205,8 +1209,7 @@ val Jar.outputFile: File
 val Project.sourceSetsOrNull: SourceSetContainer?
     get() = convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets
 
-val disableVerificationTasks = providers.systemProperty("disable.verification.tasks")
-    .forUseAtConfigurationTime().orNull?.toBoolean() ?: false
+val disableVerificationTasks = System.getProperty("disable.verification.tasks") == "true"
 if (disableVerificationTasks) {
     gradle.taskGraph.whenReady {
         allTasks.forEach {

buildSrc/build.gradle.kts

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

buildSrc/src/main/kotlin/InstrumentJava.kt

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

buildSrc/src/main/kotlin/embeddable.kt

@@ -128,6 +128,7 @@ fun Project.rewriteDepsToShadedJar(
         archiveClassifier.set("original")
     }
 
+    val compilerDummyJarFile by lazy { configurations.getAt("compilerDummyJar").singleFile }
 
     shadowJarTask.configure {
         dependsOn(originalJarTask)
@@ -135,8 +136,7 @@ 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:
-        val compilerDummyJarFile = project.provider { configurations.getByName("compilerDummyJar").singleFile }
-        exclude { it.file == compilerDummyJarFile.get() }
+        exclude { it.file == compilerDummyJarFile }
 
         archiveClassifier.set("original")
         body()

buildSrc/src/main/kotlin/instrument.kt

@@ -21,18 +21,15 @@ 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") }.configureEach {
+    plugins.matching { it::class.java.canonicalName.startsWith("org.jetbrains.kotlin.gradle.plugin") }.all {
         // 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:
@@ -45,36 +42,31 @@ 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.
-        if (!tasks.names.contains("compileTestKotlin")) return@configureEach
+        val testCompile = tasks.findByName("compileTestKotlin") as AbstractCompile?
+        testCompile?.doFirst {
+            val originalClassesDirs = files((mainSourceSet as ExtensionAware).extra.get("classesDirsCopy"))
 
-        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)
+            testCompile.classpath = (testCompile.classpath
+                    - mainSourceSet.output.classesDirs
+                    + originalClassesDirs)
 
-                classpath = (classpath
-                        - classesDirs
-                        + originalClassesDirs)
+            // 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)
 
-                // 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 getFreeCompilerArgs = kotlinOptions::class.java.getMethod("getFreeCompilerArgs")
+                val freeCompilerArgs = getFreeCompilerArgs(kotlinOptions) as List<*>
 
-                    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 })
+                val setFreeCompilerArgs = kotlinOptions::class.java.getMethod("setFreeCompilerArgs", List::class.java)
+                setFreeCompilerArgs(kotlinOptions, freeCompilerArgs + args)
             }
+            addFreeCompilerArgs(testCompile, "-Xfriend-paths=" + originalClassesDirs.joinToString(",")  { it.absolutePath })
         }
+
     }
 
     val instrumentationClasspathCfg = configurations.create("instrumentationClasspath")
@@ -84,7 +76,7 @@ fun Project.configureFormInstrumentation() {
     }
 
     afterEvaluate {
-        sourceSets.forEach { sourceSetParam ->
+        sourceSets.all { sourceSetParam ->
             // This copy will ignore filters, but they are unlikely to be used.
             val classesDirs = (sourceSetParam.output.classesDirs as ConfigurableFileCollection).from as Collection<Any>
 
@@ -96,82 +88,66 @@ 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)
-                    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)
+                    dependsOn(sourceSetParam.classesTaskName).onlyIf { !classesDirsCopy.isEmpty }
+                    sourceSet = sourceSetParam
+                    instrumentationClasspath = instrumentationClasspathCfg
+                    originalClassesDirs = classesDirsCopy
+                    output = instrumentedClassesDir
+                    outputs.dir(instrumentedClassesDir)
                 }
 
             // Ensure that our task is invoked when the source set is built
             sourceSetParam.compiledBy(instrumentTask)
+            @Suppress("UNUSED_EXPRESSION")
+            true
         }
     }
 }
 
 @CacheableTask
-abstract class IntelliJInstrumentCodeTask : ConventionTask() {
+open class IntelliJInstrumentCodeTask : ConventionTask() {
     companion object {
         private const val FILTER_ANNOTATION_REGEXP_CLASS = "com.intellij.ant.ClassFilterAnnotationRegexp"
         private const val LOADER_REF = "java2.loader"
     }
 
-    @Transient
-    @Internal
-    lateinit var instrumentationClasspathConfiguration: Configuration
+    @Classpath
+    var instrumentationClasspath: Configuration? = null
 
-    @get:Classpath
-    val instrumentationClasspath: String by lazy {
-        instrumentationClasspathConfiguration.asPath
-    }
-
-    @get:InputFiles
-    @get:PathSensitive(PathSensitivity.RELATIVE)
-    @get:SkipWhenEmpty
-    abstract val originalClassesDirs: ConfigurableFileCollection
+    @InputFiles
+    @PathSensitive(PathSensitivity.RELATIVE)
+    var originalClassesDirs: FileCollection? = null
 
     @get:Input
     var instrumentNotNull: Boolean = false
 
-    @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 }
-    }
+    @Internal
+    var sourceSet: SourceSet? = null
 
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract val sourceDirs: ConfigurableFileCollection
+    val sourceDirs: FileCollection
+        get() = project.files(sourceSet!!.allSource.srcDirs.filter { !sourceSet!!.resources.contains(it) && it.exists() })
 
     @get:OutputDirectory
-    abstract val output: RegularFileProperty
-
-    @get:Inject
-    abstract val fs: FileSystemOperations
+    lateinit var output: File
 
     @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.asFile.get().deleteRecursively()
+        output.deleteRecursively()
         copyOriginalClasses()
 
-        val classpath = instrumentationClasspath
+        val classpath = instrumentationClasspath!!
 
         ant.withGroovyBuilder {
             "taskdef"(
                 "name" to "instrumentIdeaExtensions",
-                "classpath" to classpath,
+                "classpath" to classpath.asPath,
                 "loaderref" to LOADER_REF,
                 "classname" to "com.intellij.ant.InstrumentIdeaExtensions"
             )
@@ -179,14 +155,14 @@ abstract class IntelliJInstrumentCodeTask : ConventionTask() {
 
         logger.info("Compiling forms and instrumenting code with nullability preconditions")
         if (instrumentNotNull) {
-            prepareNotNullInstrumenting(classpath)
+            prepareNotNullInstrumenting(classpath.asPath)
         }
 
         instrumentCode(sourceDirs, instrumentNotNull)
     }
 
     private fun copyOriginalClasses() {
-        fs.copy {
+        project.copy {
             from(originalClassesDirs)
             into(output)
         }
@@ -205,10 +181,12 @@ abstract 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(compileClasspath as FileCollection) { acc, v -> acc + v }.asPath.also {
+            depSourceDirectorySets.fold(sourceSet!!.compileClasspath) { acc, v -> acc + v }.asPath.also {
                 logger.info("Using following dependency source dirs: $it")
             }
 

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -64,9 +64,6 @@ 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 {
@@ -75,11 +72,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 = cGroupId
+            groupId.textContent = coordinates.groupId
             val artifactId = dependency.appendChild(document.createElement("artifactId"))
-            artifactId.textContent = cArtifactId
+            artifactId.textContent = coordinates.artifactId
             val version = dependency.appendChild(document.createElement("version"))
-            version.textContent = cVersion
+            version.textContent = coordinates.version
         }
 
         pom.name.set(declaration.displayName)

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

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

buildSrc/src/main/kotlin/tasks.kt

@@ -9,14 +9,11 @@
 
 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
@@ -83,141 +80,129 @@ fun Project.projectTest(
     shortenTempRootName: Boolean = false,
     jUnit5Enabled: Boolean = false,
     body: Test.() -> Unit = {}
-): TaskProvider<Test> {
-    val shouldInstrument = project.providers.gradleProperty("kotlin.test.instrumentation.disable")
-        .forUseAtConfigurationTime().orNull?.toBoolean() != true
-    if (shouldInstrument) {
-        evaluationDependsOn(":test-instrumenter")
-    }
-    return getOrCreateTask<Test>(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('.')
+): 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 {
-                    isClassPattern = true
-                    pattern
+                    filter.includePatterns.add(innerClassPattern)
                 }
+            }
 
-                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()
 
-                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)
+            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 {
-                        if (jUnit5Enabled) {
-                            path == classFileName || (path.endsWith(".class") && parentNames.any { path.startsWith(it) })
-                        } else {
-                            path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
-                        }
+                        path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
                     }
                 }
             }
         }
+    }
 
-        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<*, *>
+    if (project.findProperty("kotlin.test.instrumentation.disable")?.toString()?.toBoolean() != true) {
         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 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")
+    }
+
+    jvmArgs(
+        "-ea",
+        "-XX:+HeapDumpOnOutOfMemoryError",
+        "-XX:+UseCodeCacheFlushing",
+        "-XX:ReservedCodeCacheSize=256m",
+        "-Djna.nosys=true"
+    )
+
+    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")
+
+    if (Platform[202].orHigher()) {
+        systemProperty("idea.ignore.disabled.plugins", "true")
+    }
+
+    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())
+        }
+    }
+
+    doLast {
+        subProjectTempRoot?.let {
+            try {
+                delete(it)
+            } catch (e: Exception) {
+                project.logger.warn("Can't delete test temp root folder $it", e.printStackTrace())
             }
         }
+    }
 
-        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) }
+    if (parallel && !jUnit5Enabled) {
+        maxParallelForks =
+            project.findProperty("kotlin.test.maxParallelForks")?.toString()?.toInt()
+                ?: (Runtime.getRuntime().availableProcessors() / if (kotlinBuildProperties.isTeamcityBuild) 2 else 4).coerceAtLeast(1)
+    }
+    body()
 }
 
 private inline fun String.isFirstChar(f: (Char) -> Boolean) = isNotEmpty() && f(first())
@@ -244,25 +229,18 @@ private fun Task.useAndroidConfiguration(systemPropertyName: String, configName:
     val configuration = with(project) {
         configurations.getOrCreate(configName)
             .also {
-                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)
-                    )
-                }
+                dependencies.add(
+                    configName,
+                    dependencies.project(":dependencies:android-sdk", configuration = configName)
+                )
             }
     }
 
     dependsOn(configuration)
 
     if (this is Test) {
-        val androidFilePath = configuration.singleFile.canonicalPath
         doFirst {
-            systemProperty(systemPropertyName, androidFilePath)
+            systemProperty(systemPropertyName, configuration.singleFile.canonicalPath)
         }
     }
 }

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(true)
+        enabled.set(testDistributionEnabled)
         maxRemoteExecutors.set(20)
         if (isTeamcityBuild) {
             requirements.set(setOf("os=${OperatingSystem.current().familyName}"))

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

@@ -116,12 +116,6 @@ 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,6 +51,7 @@ interface BaseExpressionCodegen {
 
     fun consumeReifiedOperationMarker(typeParameter: TypeParameterMarker)
 
+    @JvmDefault
     fun putReifiedOperationMarkerIfTypeIsReifiedParameter(type: KotlinTypeMarker, operationKind: OperationKind) {
         with(typeSystem) {
             val (typeParameter, second) = extractReificationArgument(type) ?: return

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

@@ -88,7 +88,6 @@ 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;
@@ -5533,11 +5532,4 @@ 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,10 +1152,8 @@ 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 =
-                (!isInterface(functionDescriptor.getContainingDeclaration()) || kind == OwnerKind.DEFAULT_IMPLS) &&
-                (DescriptorVisibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor))
+                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 &&
@@ -1691,7 +1689,7 @@ public class FunctionCodegen {
             return (kind != OwnerKind.DEFAULT_IMPLS && !isSyntheticInCompatibilityOrJvmDefault) ||
                    (kind == OwnerKind.DEFAULT_IMPLS &&
                     (isSyntheticInCompatibilityOrJvmDefault ||
-                     (mode.isCompatibility() && !JvmAnnotationUtilKt.hasJvmDefaultNoCompatibilityAnnotation(containingDeclaration))) && !DescriptorVisibilities.isPrivate(memberDescriptor.getVisibility()));
+                     (mode.isCompatibility() && !JvmAnnotationUtilKt.hasJvmDefaultNoCompatibilityAnnotation(containingDeclaration))));
         } else {
             switch (kind) {
                 case DEFAULT_IMPLS: return true;

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

@@ -34,13 +34,9 @@ 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
@@ -129,19 +125,8 @@ 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, attributes,
+                singleSourceFile, state.classFileVersion, FACADE_CLASS_ATTRIBUTES,
                 facadeClassType.internalName, null, superClassForFacade, emptyArray()
             )
             if (singleSourceFile != null) {
@@ -161,13 +146,6 @@ 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,16 +36,14 @@ class SamWrapperClasses(private val state: GenerationState) {
         expressionCodegen: ExpressionCodegen,
         contextDescriptor: CallableMemberDescriptor
     ): Type {
-        val parentContext = expressionCodegen.context
-        val isInsideInline = InlineUtil.isInlineOrContainingInline(parentContext.contextDescriptor) ||
-                isInsideInlineLambdaContext(parentContext, state)
+        val isInsideInline = InlineUtil.isInlineOrContainingInline(expressionCodegen.context.contextDescriptor) ||
+                isInsideInlineLambdaContext(expressionCodegen.context, state)
         return samInterfaceToWrapperClass.getOrPut(WrapperKey(samType, file, isInsideInline)) {
-            SamWrapperCodegen(state, samType, expressionCodegen.parentCodegen, parentContext, isInsideInline)
-                .genWrapper(file, contextDescriptor)
+            SamWrapperCodegen(state, samType, expressionCodegen.parentCodegen, 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,6 +21,7 @@ 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;
@@ -63,7 +64,6 @@ 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,7 +72,6 @@ public class SamWrapperCodegen {
             @NotNull GenerationState state,
             @NotNull SamType samType,
             @NotNull MemberCodegen<?> parentCodegen,
-            @NotNull CodegenContext<?> parentContext,
             boolean isInsideInline
     ) {
         this.state = state;
@@ -80,7 +79,6 @@ 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;
@@ -172,6 +170,7 @@ 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/InlineCodegen.kt

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

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

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

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

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

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

@@ -17,7 +17,6 @@
 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.*;
 
@@ -32,7 +31,7 @@ public abstract class MethodTransformer {
             return analyzer.analyze(internalClassName, node);
         }
         catch (AnalyzerException e) {
-            throw ExceptionUtilsKt.rethrow(e);
+            throw new RuntimeException(e);
         }
     }
 

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

@@ -213,13 +213,13 @@ class GenerationState private constructor(
         val fromConfig = configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS)
         if (fromConfig != null && target >= fromConfig.minJvmTarget)
             fromConfig
-        else if (
-            target >= JvmClosureGenerationScheme.INDY.minJvmTarget &&
-            languageVersionSettings.supportsFeature(LanguageFeature.SamWrapperClassesAreSynthetic)
-        )
-            JvmClosureGenerationScheme.INDY
-        else
+        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
             JvmClosureGenerationScheme.CLASS
+        }
     }
 
     val lambdasScheme = run {

compiler/build.gradle.kts

@@ -103,11 +103,8 @@ 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", antLauncherJarPathProvider.get())
+        systemProperty("kotlin.ant.classpath", antLauncherJar.asPath)
         systemProperty("kotlin.ant.launcher.class", "org.apache.tools.ant.Main")
     }
 }

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

@@ -57,7 +57,9 @@ 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.createSessionWithDependencies
+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.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
@@ -316,26 +318,25 @@ object KotlinToJVMBytecodeCompiler {
             if (!checkKotlinPackageUsage(environment, ktFiles)) return false
             val moduleConfiguration = projectConfiguration.applyModuleProperties(module, buildFile)
 
-            val sourceScope = GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile })
+            val scope = 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 languageVersionSettings = moduleConfiguration.languageVersionSettings
-            val session = createSessionWithDependencies(
-                module,
-                project,
-                languageVersionSettings,
-                sourceScope,
-                librariesScope,
-                environment::createPackagePartProvider
-            ) {
+            val moduleInfo = FirJvmModuleInfo(module, listOf(librariesModuleInfo))
+            val session = FirSessionFactory.createJavaModuleBasedSession(moduleInfo, provider, scope, project) {
                 if (extendedAnalysisMode) {
                     registerExtendedCommonCheckers()
                 }
             }
 
-            val firAnalyzerFacade = FirAnalyzerFacade(session, languageVersionSettings, ktFiles)
+            val firAnalyzerFacade = FirAnalyzerFacade(session, moduleConfiguration.languageVersionSettings, ktFiles)
 
             firAnalyzerFacade.runResolution()
             val firDiagnostics = firAnalyzerFacade.runCheckers().values.flatten()

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

@@ -74,7 +74,6 @@ 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,3 +1,6 @@
+
+import org.gradle.jvm.tasks.Jar
+
 description = "Compiler runner + daemon client"
 
 plugins {

compiler/compiler.version/build.gradle.kts

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

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

@@ -601,11 +601,6 @@ 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");

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 = createSessionForTests(environment, GlobalSearchScope.EMPTY_SCOPE)
+        val sessionWithDependency = createSession(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 = createSessionForTests(environment, GlobalSearchScope.allScope(project))
+        val session = createSession(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.createSessionForTests
+import org.jetbrains.kotlin.fir.createSession
 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 = createSessionForTests(environment, scope)
+        val session = createSession(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<kotlin/Any, kotlin/Any?>|> asList(p0: T[]): java.util.List<T>
+    public/*package*/ open static fun <T : R|ft<@FlexibleNullability kotlin/Any, kotlin/Any?>!|> asList(p0: T[]): java.util.List<T>
 
     public/*package*/ constructor(): R|kotlin/collections/ArraysUtilJVM|
 
@@ -304,3 +304,4 @@ 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|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) public open field field: R|@FlexibleNullability kotlin/String?|
 
-    @R|MyNullable|() public open fun foo(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) x: R|@EnhancedNullability kotlin/String?|, @R|MyNullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String?|
+    @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?|
 
     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|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
 
-    @R|javax/annotation/Nullable|() public open fun foo(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/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/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<kotlin/String, kotlin/String?>|
+    @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.MAYBE|()) public open fun foo(@R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.ALWAYS|()) x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nonnull|(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|() 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|@EnhancedNullability kotlin/String?|
+    public open field field: R|@FlexibleNullability kotlin/String?|
 
     @R|javax/annotation/Nonnull|() public open field nonNullField: R|@EnhancedNullability kotlin/String|
 
-    public open fun foo(q: R|ft<kotlin/String, kotlin/String?>|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
+    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?>!|
 
     @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|@EnhancedNullability kotlin/String|, @R|spr/Nullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String|
+    public open fun foo(x: R|@FlexibleNullability kotlin/String|, @R|spr/Nullable|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability 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?>|
+    @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?>!|
 
     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|@EnhancedNullability kotlin/String|): R|kotlin/Unit|
+    @R|spr/ForceFlexibility|() public open fun foo(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 bar(@R|spr/ForceFlexibility|() 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 baz(@R|spr/UnknownNullability|() x: R|@FlexibleNullability 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 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 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|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
+    public open fun foo1(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 foo2(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
 
-    public open fun foo3(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
+    public open fun foo3(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
 
-    @R|javax/annotation/Nullable|() public open fun bar1(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open fun bar1(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
 
-    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
 
-    public open fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
+    public open fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
 
     public constructor(): R|A|
 
 }
 @R|NonNullApi|() public abstract interface AInt : R|kotlin/Any| {
-    public abstract fun foo1(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/CharSequence|
+    public abstract fun foo1(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 foo2(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/CharSequence|
 
-    public abstract fun foo3(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/CharSequence|
+    public abstract fun foo3(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/CharSequence|
 
-    @R|javax/annotation/Nullable|() public abstract fun bar1(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/CharSequence?|
+    @R|javax/annotation/Nullable|() public abstract fun bar1(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/CharSequence?|
 
-    @R|javax/annotation/Nullable|() public abstract fun bar2(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/CharSequence?|
+    @R|javax/annotation/Nullable|() public abstract fun bar2(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/CharSequence?|
 
-    public abstract fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/CharSequence|
+    public abstract fun baz(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@FlexibleNullability kotlin/CharSequence|
 
 }
 @R|NullableApi|() public open class B : R|A|, R|AInt| {
-    public open fun foo1(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
+    public open fun foo1(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability 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|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
+    public open fun bar1(x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
 
-    public open fun baz(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
+    public open fun baz(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
 
     public constructor(): R|B|
 
 }
 @R|NonNullApi|() public open class C : R|A|, R|AInt| {
-    public open fun foo1(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
+    public open fun foo1(x: R|@FlexibleNullability 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 foo2(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|@FlexibleNullability kotlin/String|
 
-    public open fun bar1(x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
+    public open fun bar1(x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
 
-    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@EnhancedNullability kotlin/String?|): R|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open fun bar2(@R|javax/annotation/Nullable|() x: R|@FlexibleNullability kotlin/String?|): R|@FlexibleNullability kotlin/String?|
 
-    public open fun baz(x: R|@EnhancedNullability kotlin/String|): R|@EnhancedNullability kotlin/String|
+    public open fun baz(x: R|@FlexibleNullability kotlin/String|): R|@FlexibleNullability 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|@EnhancedNullability kotlin/String|
+    public open field field: R|@FlexibleNullability kotlin/String|
 
-    public open fun foo(x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String|
+    public open fun foo(x: R|@FlexibleNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String|
 
-    @R|NullableApi|() public open fun foobar(x: R|@EnhancedNullability kotlin/String?|, @R|NonNullApi|() y: R|@EnhancedNullability kotlin/CharSequence|): R|@EnhancedNullability kotlin/String?|
+    @R|NullableApi|() public open fun foobar(x: R|@FlexibleNullability kotlin/String?|, @R|NonNullApi|() y: R|@FlexibleNullability kotlin/CharSequence|): R|@FlexibleNullability kotlin/String?|
 
-    public open fun bar(): R|@EnhancedNullability kotlin/String|
+    public open fun bar(): R|@FlexibleNullability kotlin/String|
 
-    @R|javax/annotation/Nullable|() public open fun baz(): R|ft<@EnhancedNullability kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, @EnhancedNullability kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>|
+    @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?>!>?>?|
 
     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|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
 
-    public open fun foo(q: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
+    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?>!|
 
     @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|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
 
-    public open fun foo(q: R|ft<kotlin/String, kotlin/String?>|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
+    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?>!|
 
     @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|@EnhancedNullability kotlin/String?|
+    @R|javax/annotation/Nullable|() public open field field: R|@FlexibleNullability kotlin/String?|
 
-    public open fun foo(q: R|ft<kotlin/String, kotlin/String?>|, @R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|, @R|javax/annotation/CheckForNull|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
+    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?>!|
 
     @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<kotlin/String, kotlin/String?>|
+    public open field field: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
 
-    public open fun foo(x: R|@EnhancedNullability kotlin/String|, @R|spr/Nullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|@EnhancedNullability kotlin/String|
+    public open fun foo(x: R|@FlexibleNullability kotlin/String|, @R|spr/Nullable|() y: R|@FlexibleNullability kotlin/CharSequence?|): R|@FlexibleNullability kotlin/String|
 
-    public open fun bar(): R|@EnhancedNullability kotlin/String|
+    public open fun bar(): R|@FlexibleNullability kotlin/String|
 
-    @R|spr/Nullable|() public open fun baz(): R|ft<@EnhancedNullability kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, @EnhancedNullability kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>|
+    @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?>!>?>?|
 
     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<kotlin/String, kotlin/String?>|
+    public open field field: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
 
-    public open fun foo(x: R|ft<kotlin/String, kotlin/String?>|, @R|spr/Nullable|() y: R|@EnhancedNullability kotlin/CharSequence?|): R|ft<kotlin/String, kotlin/String?>|
+    public open fun 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 bar(): R|ft<kotlin/String, kotlin/String?>|
+    public open fun bar(): R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!|
 
-    @R|spr/Nullable|() public open fun baz(): R|ft<@EnhancedNullability kotlin/collections/MutableList<ft<kotlin/String, kotlin/String?>>?, @EnhancedNullability kotlin/collections/List<ft<kotlin/String, kotlin/String?>>?>|
+    @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?>!>?>?|
 
     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<kotlin/String, kotlin/String?>, ft<kotlin/String, kotlin/String?>>| {
+public abstract class AbstractMap : R|kotlin/Any|, R|kotlin/collections/MutableMap<ft<@FlexibleNullability kotlin/String, kotlin/String?>!, ft<@FlexibleNullability kotlin/String, kotlin/String?>!>| {
     public constructor(): R|AbstractMap|
 
 }

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

@@ -1,5 +1,6 @@
-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 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 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

@@ -1,4 +0,0 @@
-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

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

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

@@ -84,7 +84,7 @@ digraph initBlock_kt {
     20 -> {21};
     21 -> {22};
     22 -> {23};
-    23 -> {28}    [label=onUncaughtException];
+    23 -> {28};
     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}    [label=onUncaughtException];
+    18 -> {29};
     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}    [label=onUncaughtException];
+    15 -> {20};
     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}    [label=onUncaughtException];
+    44 -> {47};
     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}    [label=onUncaughtException];
+    54 -> {58};
     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}    [label=onUncaughtException];
+    73 -> {76};
     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}    [label=onUncaughtException];
+    30 -> {81};
     30 -> {31} [style=dotted];
     31 -> {32} [style=dotted];
     32 -> {33} [style=dotted];

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

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

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

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

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

@@ -1,9 +1,9 @@
-data <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>class A<!> {}
+data class A {}
 
-data <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>class B<!> {
+<!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>data class B {
     constructor()
-}
+}<!>
 
-data <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>class C<!> {
+<!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>data 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<E, E?>| = Q|Utils|.R|/Utils.getEnum|()
+        lval e: R|ft<@FlexibleNullability 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<E, E?>| = Q|Utils|.R|/Utils.getEnum|()
+        lval e: R|ft<@FlexibleNullability 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|Diagnostic<ft<DerivedElement, DerivedElement?>>| = R|/DERIVED_FACTORY|.R|SubstitutionOverride</DiagnosticFactory0.cast: R|Diagnostic<ft<DerivedElement, DerivedElement?>>|>|(R|<local>/d|)
+        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 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<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|
+        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|
     }

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<kotlin/String, kotlin/String?>| = this@R|/O.Derived|.R|/Base.foo|()
+                            lval y: R|ft<@FlexibleNullability 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<kotlin/String, kotlin/String?>| = this@R|/O.Derived|.R|/Base.foo|()
+                        lval y: R|ft<@FlexibleNullability 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|kotlin/CharSequence| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| } ?: ^test2 Unit
+        lval bar: R|@FlexibleNullability 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|kotlin/CharSequence?| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| }
+        lval bar: R|@FlexibleNullability 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<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<@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?>!|>()
         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|)
     }

compiler/fir/analysis-tests/testData/resolve/incorrectDataClass.kt

@@ -1,5 +1,5 @@
 // ISSUE: KT-44554
 
-data class Foo(<!DATA_CLASS_NOT_PROPERTY_PARAMETER!>a: Int<!>, val b: Int) {
+data class Foo(a: Int, val b: Int) {
     val c = 4
 }

compiler/fir/analysis-tests/testData/resolve/inference/capturedTypeForJavaTypeParameter.fir.txt

@@ -4,5 +4,5 @@ FILE: main.kt
     public final fun <D : R|A|> foo(b: R|B<D>|): R|kotlin/Unit| {
     }
     public final fun main(b: R|B<*>|): R|kotlin/Unit| {
-        R|/foo|<R|ft<A, A?>|>(R|<local>/b|)
+        R|/foo|<R|ft<@FlexibleNullability A, A?>!|>(R|<local>/b|)
     }

compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.fir.txt

@@ -7,5 +7,5 @@ FILE: main.kt
     }
     public final fun main(): R|kotlin/Unit| {
         R|/K.K|<R|kotlin/Int|>(Int(0))
-        R|/JavaClass.JavaClass|<R|ft<kotlin/Int, kotlin/Int?>|>(Int(0))
+        R|/JavaClass.JavaClass|<R|ft<kotlin/Int, kotlin/Int?>!|>(Int(0))
     }

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

@@ -1,5 +1,5 @@
 FILE: main.kt
     public final fun test(a: R|A|): R|kotlin/Unit| {
         lval int: R|kotlin/Int| = R|<local>/a|.R|/A.x|
-        lval string: R|ft<kotlin/String, kotlin/String?>| = R|<local>/a|.R|/A.getX|()
+        lval string: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!| = R|<local>/a|.R|/A.getX|()
     }

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

@@ -1,4 +1,4 @@
 FILE: main.kt
     public final fun main(): R|kotlin/Unit| {
-        lval b: R|ft<B, B?>| = Q|B|.R|/B.VALUE|
+        lval b: R|ft<@FlexibleNullability B, B?>!| = Q|B|.R|/B.VALUE|
     }

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

@@ -24,7 +24,7 @@ FILE: main.kt
 
     }
     public final fun callJava(derived: R|Test.Derived|, derivedRaw: R|Test.DerivedRaw|, v: R|Test.I123|): R|kotlin/Unit| {
-        R|<local>/derived|.R|/Test.Derived.foo|<R|ft<Test.I123, Test.I123?>|>(R|<local>/v|)
+        R|<local>/derived|.R|/Test.Derived.foo|<R|ft<Test.I123, Test.I123?>!|>(R|<local>/v|)
         R|<local>/derivedRaw|.R|/Test.DerivedRaw.foo|(R|<local>/v|)
     }
     public final fun callKotlin(derived: R|KDerived|): R|kotlin/Unit| {

compiler/fir/analysis-tests/testData/resolve/problems/flexibleTypeVarAgainstNull.fir.txt

@@ -1,4 +1,4 @@
 FILE: main.kt
     public final fun main(): R|kotlin/Unit| {
-        R|/JavaClass.JavaClass|<R|ft<kotlin/String, kotlin/String?>|>(Null(null)).R|SubstitutionOverride</JavaClass.foo: R|ft<kotlin/String, kotlin/String?>|>|().R|kotlin/String.length|
+        R|/JavaClass.JavaClass|<R|ft<kotlin/String, kotlin/String?>!|>(Null(null)).R|SubstitutionOverride</JavaClass.foo: R|ft<kotlin/String, kotlin/String?>!|>|().R|kotlin/String.length|
     }

compiler/fir/analysis-tests/testData/resolve/properties/javaAccessorConversion.fir.txt

@@ -1,10 +1,10 @@
 FILE: main.kt
     public final fun test_1(x: R|A|): R|kotlin/Unit| {
-        lval str1: R|ft<kotlin/String, kotlin/String?>| = R|<local>/x|.R|/A.vmParameters|
+        lval str1: R|ft<@FlexibleNullability kotlin/String, kotlin/String?>!| = R|<local>/x|.R|/A.vmParameters|
         lval str2: R|ERROR CLASS: Unresolved name: vMParameters| = R|<local>/x|.<Unresolved name: vMParameters>#
     }
     public final fun test_2(x: R|B|): R|kotlin/Unit| {
-        lval int: R|ft<kotlin/Int, kotlin/Int?>| = R|<local>/x|.R|/B.vmParameters|
+        lval int: R|ft<@FlexibleNullability kotlin/Int, kotlin/Int?>!| = R|<local>/x|.R|/B.vmParameters|
         lval error: R|ERROR CLASS: Unresolved name: vMParameters| = R|<local>/x|.<Unresolved name: vMParameters>#
     }
     public final fun test_3(x: R|C|): R|kotlin/Unit| {

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

@@ -1,6 +1,6 @@
 FILE: main.kt
     public final fun foo(): R|kotlin/Unit| {
-        Q|RawType|.R|/RawType.bar|(<L> = bar@fun <anonymous>(it: R|ft<kotlin/CharSequence, kotlin/CharSequence?>|): R|kotlin/Boolean| {
+        Q|RawType|.R|/RawType.bar|(<L> = bar@fun <anonymous>(it: R|ft<@FlexibleNullability kotlin/CharSequence, @FlexibleNullability kotlin/CharSequence?>!|): R|kotlin/Boolean| {
             ^ CMP(>, R|<local>/it|.R|kotlin/CharSequence.length|.R|kotlin/Int.compareTo|(Int(0)))
         }
         )

compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSam.fir.txt

@@ -1,14 +1,14 @@
 FILE: main.kt
     public final fun main(): R|kotlin/Unit| {
-        R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>|): R|ft<kotlin/String, kotlin/String?>| {
+        R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>!|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>!|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Int.toInt|().R|kotlin/Any.toString|()
         }
         )
-        R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>| {
+        R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>!|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Any.toString|()
         }
         )
-        R|/MyFunction|<R|kotlin/Nothing|, R|kotlin/Any?|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Nothing, kotlin/Nothing?>|): R|kotlin/Any?| {
+        R|/MyFunction|<R|kotlin/Nothing|, R|kotlin/Any?|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Nothing, kotlin/Nothing?>!|): R|kotlin/Any?| {
             ^ String()
         }
         )

compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.fir.txt

@@ -6,23 +6,23 @@ FILE: main.kt
     public final fun <X, Y> foo3(f: R|MyFunction<X, Y>|, x: R|X|): R|kotlin/Unit| {
     }
     public final fun main(): R|kotlin/Unit| {
-        R|/foo1|(R|/MyFunction|<R|kotlin/Int|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>|): R|ft<kotlin/String, kotlin/String?>| {
+        R|/foo1|(R|/MyFunction|<R|kotlin/Int|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>!|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Int.toInt|().R|kotlin/Any.toString|()
         }
         ))
-        R|/foo2|(R|/MyFunction|<R|kotlin/Number|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Number, kotlin/Number?>|): R|ft<kotlin/String, kotlin/String?>| {
+        R|/foo2|(R|/MyFunction|<R|kotlin/Number|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Number, kotlin/Number?>!|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         ))
-        <Inapplicable(INAPPLICABLE): /foo2>#(R|/MyFunction|<R|kotlin/Number|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>| {
+        <Inapplicable(INAPPLICABLE): /foo2>#(R|/MyFunction|<R|kotlin/Number|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Any.toString|()
         }
         ))
-        R|/foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>|>(R|/MyFunction|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>|): R|ft<kotlin/String, kotlin/String?>| {
+        R|/foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(R|/MyFunction|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>!|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Int.plus|(Int(1)).R|kotlin/Any.toString|()
         }
         ), Int(1))
-        R|/foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>|>(R|/MyFunction|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Number|): R|ft<kotlin/String, kotlin/String?>| {
+        R|/foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(R|/MyFunction|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Number|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         ), Int(2))

compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.fir.txt

@@ -1,22 +1,22 @@
 FILE: main.kt
     public final fun main(): R|kotlin/Unit| {
-        Q|JavaUsage|.R|/JavaUsage.foo1|(<L> = foo1@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>|): R|ft<kotlin/String, kotlin/String?>| {
+        Q|JavaUsage|.R|/JavaUsage.foo1|(<L> = foo1@fun <anonymous>(x: R|ft<@FlexibleNullability kotlin/Int, @FlexibleNullability kotlin/Int?>!|): R|ft<@FlexibleNullability kotlin/String, @FlexibleNullability kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Int.toInt|().R|kotlin/Any.toString|()
         }
         )
-        Q|JavaUsage|.R|/JavaUsage.foo2|(<L> = foo2@fun <anonymous>(x: R|ft<kotlin/Number, kotlin/Number?>|): R|ft<kotlin/CharSequence, kotlin/CharSequence?>| {
+        Q|JavaUsage|.R|/JavaUsage.foo2|(<L> = foo2@fun <anonymous>(x: R|ft<@FlexibleNullability kotlin/Number, @FlexibleNullability kotlin/Number?>!|): R|ft<@FlexibleNullability kotlin/CharSequence, @FlexibleNullability kotlin/CharSequence?>!| {
             ^ R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         )
-        Q|JavaUsage|.<Inapplicable(INAPPLICABLE): /JavaUsage.foo2>#(<L> = foo2@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/CharSequence, kotlin/CharSequence?>| {
+        Q|JavaUsage|.<Inapplicable(INAPPLICABLE): /JavaUsage.foo2>#(<L> = foo2@fun <anonymous>(x: R|kotlin/Int|): R|ft<@FlexibleNullability kotlin/CharSequence, @FlexibleNullability kotlin/CharSequence?>!| {
             ^ R|<local>/x|.R|kotlin/Any.toString|()
         }
         )
-        Q|JavaUsage|.R|/JavaUsage.foo3|<R|ft<kotlin/Int, kotlin/Int?>|, R|ft<kotlin/String, kotlin/String?>|>(foo3@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>|): R|ft<kotlin/String, kotlin/String?>| {
+        Q|JavaUsage|.R|/JavaUsage.foo3|<R|ft<kotlin/Int, kotlin/Int?>!|, R|ft<kotlin/String, kotlin/String?>!|>(foo3@fun <anonymous>(x: R|ft<kotlin/Int, kotlin/Int?>!|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Int.plus|(Int(1)).R|kotlin/Any.toString|()
         }
         , Int(1))
-        Q|JavaUsage|.R|/JavaUsage.foo3|<R|ft<kotlin/Int, kotlin/Int?>|, R|ft<kotlin/String, kotlin/String?>|>(foo3@fun <anonymous>(x: R|kotlin/Number|): R|ft<kotlin/String, kotlin/String?>| {
+        Q|JavaUsage|.R|/JavaUsage.foo3|<R|ft<kotlin/Int, kotlin/Int?>!|, R|ft<kotlin/String, kotlin/String?>!|>(foo3@fun <anonymous>(x: R|kotlin/Number|): R|ft<kotlin/String, kotlin/String?>!| {
             ^ R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         , Int(2))

compiler/fir/analysis-tests/testData/resolve/samConversions/samSupertypeWithOverride.fir.txt

@@ -2,11 +2,11 @@ FILE: main.kt
     public final fun foo(m: R|MyRunnable|): R|kotlin/Unit| {
     }
     public final fun main(): R|kotlin/Unit| {
-        Q|JavaUsage|.R|/JavaUsage.foo|(<L> = foo@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/Boolean, kotlin/Boolean?>| {
+        Q|JavaUsage|.R|/JavaUsage.foo|(<L> = foo@fun <anonymous>(x: R|kotlin/Int|): R|ft<@FlexibleNullability kotlin/Boolean, kotlin/Boolean?>!| {
             ^ CMP(>, R|<local>/x|.R|kotlin/Int.compareTo|(Int(1)))
         }
         )
-        Q|JavaUsage|.R|/JavaUsage.foo|(foo@fun <anonymous>(it: R|kotlin/Int|): R|ft<kotlin/Boolean, kotlin/Boolean?>| {
+        Q|JavaUsage|.R|/JavaUsage.foo|(foo@fun <anonymous>(it: R|kotlin/Int|): R|ft<@FlexibleNullability kotlin/Boolean, kotlin/Boolean?>!| {
             ^ CMP(>, R|<local>/it|.R|kotlin/Int.compareTo|(Int(1)))
         }
         )

compiler/fir/analysis-tests/testData/resolve/samConversions/samWithEquals.fir.txt

@@ -5,7 +5,7 @@ FILE: main.kt
 
     }
     public final fun main(): R|kotlin/Unit| {
-        Q|OverridingUtil|.R|/OverridingUtil.createWithEqualityAxioms|(<L> = l1@fun <anonymous>(c1: R|ft<TypeConstructor, TypeConstructor?>|, c2: R|ft<TypeConstructor, TypeConstructor?>|): R|kotlin/Boolean| {
+        Q|OverridingUtil|.R|/OverridingUtil.createWithEqualityAxioms|(<L> = l1@fun <anonymous>(c1: R|ft<@FlexibleNullability TypeConstructor, TypeConstructor?>!|, c2: R|ft<@FlexibleNullability TypeConstructor, TypeConstructor?>!|): R|kotlin/Boolean| {
             when () {
                 ==(R|<local>/c1|.R|/TypeConstructor.x|, R|<local>/c2|.R|/TypeConstructor.x|) ->  {
                     ^@l1 Boolean(true)

compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.dot

@@ -51,7 +51,7 @@ digraph jumpFromRhsOfOperator_kt {
     10 -> {15 11};
     11 -> {12};
     12 -> {13};
-    13 -> {19}    [label=onUncaughtException];
+    13 -> {19};
     13 -> {14} [style=dotted];
     14 -> {15} [style=dotted];
     15 -> {16};
@@ -93,7 +93,7 @@ digraph jumpFromRhsOfOperator_kt {
     26 -> {31 27};
     27 -> {28};
     28 -> {29};
-    29 -> {35}    [label=onUncaughtException];
+    29 -> {35};
     29 -> {30} [style=dotted];
     30 -> {31} [style=dotted];
     31 -> {32};
@@ -157,7 +157,7 @@ digraph jumpFromRhsOfOperator_kt {
     44 -> {49 45};
     45 -> {46};
     46 -> {47};
-    47 -> {62}    [label=onUncaughtException];
+    47 -> {62};
     47 -> {48} [style=dotted];
     48 -> {49} [style=dotted];
     49 -> {50};
@@ -230,7 +230,7 @@ digraph jumpFromRhsOfOperator_kt {
     71 -> {76 72};
     72 -> {73};
     73 -> {74};
-    74 -> {89}    [label=onUncaughtException];
+    74 -> {89};
     74 -> {75} [style=dotted];
     75 -> {76} [style=dotted];
     76 -> {77};
@@ -281,7 +281,7 @@ digraph jumpFromRhsOfOperator_kt {
     96 -> {101 97};
     97 -> {98};
     98 -> {99};
-    99 -> {105}    [label=onUncaughtException];
+    99 -> {105};
     99 -> {100} [style=dotted];
     100 -> {101} [style=dotted];
     101 -> {102};
@@ -323,7 +323,7 @@ digraph jumpFromRhsOfOperator_kt {
     112 -> {117 113};
     113 -> {114};
     114 -> {115};
-    115 -> {121}    [label=onUncaughtException];
+    115 -> {121};
     115 -> {116} [style=dotted];
     116 -> {117} [style=dotted];
     117 -> {118};
@@ -387,7 +387,7 @@ digraph jumpFromRhsOfOperator_kt {
     130 -> {135 131};
     131 -> {132};
     132 -> {133};
-    133 -> {148}    [label=onUncaughtException];
+    133 -> {148};
     133 -> {134} [style=dotted];
     134 -> {135} [style=dotted];
     135 -> {136};
@@ -460,7 +460,7 @@ digraph jumpFromRhsOfOperator_kt {
     157 -> {162 158};
     158 -> {159};
     159 -> {160};
-    160 -> {175}    [label=onUncaughtException];
+    160 -> {175};
     160 -> {161} [style=dotted];
     161 -> {162} [style=dotted];
     162 -> {163};

compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt

@@ -4,7 +4,7 @@
 private sealed class Sealed
 
 private data class SubClass1(val t: String) : Sealed()
-private data <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>class SubClass2<!> : Sealed()
+private data class SubClass2 : Sealed()
 
 private fun foo(p: Sealed) {
     when (p) {

compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.dot

@@ -286,8 +286,7 @@ digraph safeCalls_kt {
     92 -> {107} [style=dashed];
     93 -> {95} [style=dotted];
     94 -> {95} [style=dotted];
-    95 -> {96} [style=dotted];
-    95 -> {106} [style=dotted]    [label=onUncaughtException];
+    95 -> {106 96} [style=dotted];
     96 -> {97} [style=dotted];
     97 -> {98 102};
     98 -> {99};

compiler/fir/analysis-tests/testData/resolve/smartcasts/smartCastInInit.dot

@@ -40,7 +40,7 @@ digraph smartCastInInit_kt {
     }
     6 -> {7};
     7 -> {8};
-    8 -> {13}    [label=onUncaughtException];
+    8 -> {13};
     8 -> {9} [style=dotted];
     9 -> {10} [style=dotted];
     10 -> {13 11} [style=dotted];