Move 1.4.x changelog to a separate file

And marked it as '@Deprecated'.

^KT-47317 Fixed

.idea/codeStyles/Project.xml

@@ -63,27 +63,6 @@
       <option name="FOR_BRACE_FORCE" value="1" />
       <option name="FIELD_ANNOTATION_WRAP" value="0" />
     </codeStyleSettings>
-    <codeStyleSettings language="JavaScript">
-      <option name="ELSE_ON_NEW_LINE" value="true" />
-      <option name="WHILE_ON_NEW_LINE" value="true" />
-      <option name="CATCH_ON_NEW_LINE" value="true" />
-      <option name="FINALLY_ON_NEW_LINE" value="true" />
-      <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
-      <option name="ALIGN_MULTILINE_BINARY_OPERATION" value="true" />
-      <option name="ALIGN_MULTILINE_TERNARY_OPERATION" value="true" />
-      <option name="CALL_PARAMETERS_WRAP" value="1" />
-      <option name="METHOD_PARAMETERS_WRAP" value="5" />
-      <option name="BINARY_OPERATION_WRAP" value="5" />
-      <option name="TERNARY_OPERATION_WRAP" value="5" />
-      <option name="TERNARY_OPERATION_SIGNS_ON_NEXT_LINE" value="true" />
-      <option name="FOR_STATEMENT_WRAP" value="5" />
-      <option name="ARRAY_INITIALIZER_WRAP" value="1" />
-      <option name="ASSIGNMENT_WRAP" value="1" />
-      <option name="IF_BRACE_FORCE" value="1" />
-      <option name="DOWHILE_BRACE_FORCE" value="1" />
-      <option name="WHILE_BRACE_FORCE" value="1" />
-      <option name="FOR_BRACE_FORCE" value="1" />
-    </codeStyleSettings>
     <codeStyleSettings language="PROTO">
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
@@ -101,4 +80,4 @@
       <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
     </codeStyleSettings>
   </code_scheme>
-</component>
+</component>

.idea/dictionaries/sebastiansellmair.xml

@@ -3,6 +3,7 @@
     <words>
       <w>cinterops</w>
       <w>interops</w>
+      <w>klibrary</w>
     </words>
   </dictionary>
-</component>
+</component>

.idea/runConfigurations/Test__Commonizer.xml

@@ -0,0 +1,25 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Test: Commonizer" type="GradleRunConfiguration" factoryName="Gradle" folderName="Tests">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.gradle.CommonizerHierarchicalIT&quot; --tests &quot;org.jetbrains.kotlin.gradle.CommonizerIT&quot; --tests &quot;org.jetbrains.kotlin.commonizer.**&quot;" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value=":native:kotlin-klib-commonizer-api:test" />
+          <option value=":native:kotlin-klib-commonizer:test" />
+          <option value=":kotlin-gradle-plugin-integration-tests:test" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <method v="2" />
+  </configuration>
+</component>

build.gradle.kts

@@ -14,8 +14,11 @@ buildscript {
 
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/plugins.gradle.org/m2")
+            maven("https://cache-redirector.jetbrains.com/repo.maven.apache.org/maven2")
+
         } else {
             maven("https://plugins.gradle.org/m2")
+            mavenCentral()
         }
     }
 
@@ -27,7 +30,7 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.28")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath(kotlin("serialization", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
@@ -192,7 +195,7 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.5.20-dev-3553"
+    extra["versions.kotlin-native"] = "1.5.20-dev-5613"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -368,7 +371,8 @@ val gradlePluginProjects = listOf(
     ":kotlin-annotation-processing-gradle",
     ":kotlin-noarg",
     ":kotlin-sam-with-receiver",
-    ":kotlin-parcelize-compiler"
+    ":kotlin-parcelize-compiler",
+    ":kotlin-lombok"
 )
 
 apply {
@@ -577,26 +581,6 @@ 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
-                .filterIsInstance<SourceTask>()
-                .filter { it.didWork }
-                .forEach {
-                    it.source.visit {
-                        if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
-                            logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
-                        }
-                    }
-                }
-        }
-    }
-}
-
 gradle.taskGraph.whenReady {
     fun Boolean.toOnOff(): String = if (this) "on" else "off"
     val profile = if (isTeamcityBuild) "CI" else "Local"
@@ -975,12 +959,14 @@ tasks {
                 ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlin-compiler-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-compiler-cli-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
                 ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:lombok-compiler-plugin-for-ide:publish",
                 ":kotlin-script-runtime:publish",
                 ":kotlin-script-util:publish",
                 ":kotlin-scripting-common:publish",

buildSrc/build.gradle.kts

@@ -22,7 +22,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.28")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -92,7 +92,27 @@ repositories {
     }
 }
 
-val generateCompilerVersion by tasks.registering(VersionGenerator::class) {
+/*
+ A special case for the build.number that doesn't have a number in it.
+ This means that this is a final release artifacts
+ */
+open class VersionGeneratorNullableBuild : VersionGenerator() {
+    override val buildNumber: String?
+        @Optional
+        @Input
+        get() {
+            val number = project.findProperty("build.number")?.toString()
+            val buildNumberSplit = number
+                ?.split("-".toRegex())
+                ?.toTypedArray()
+            if (buildNumberSplit?.get(buildNumberSplit.size - 1)?.toIntOrNull() == null) {
+                return null
+            }
+            return number
+        }
+}
+
+val generateCompilerVersion by tasks.registering(VersionGeneratorNullableBuild::class) {
     kotlinNativeVersionInResources=true
     defaultVersionFileLocation()
 }
@@ -144,7 +164,7 @@ java {
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.28")
     implementation("com.gradle.publish:plugin-publish-plugin:0.14.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")

buildSrc/settings.gradle

@@ -18,9 +18,10 @@ buildscript {
         } else {
             maven { url "https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies" }
         }
+        mavenCentral()
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.28")
     }
 }
 

buildSrc/src/main/kotlin/dependencies.kt

@@ -118,7 +118,8 @@ fun DependencyHandler.projectArchives(name: String): ProjectDependency = project
 fun Project.testApiJUnit5(
     vintageEngine: Boolean = false,
     runner: Boolean = false,
-    suiteApi: Boolean = false
+    suiteApi: Boolean = false,
+    jupiterParams: Boolean = false
 ) {
     with(dependencies) {
         val platformVersion = commonVer("org.junit", "junit-bom")
@@ -127,6 +128,11 @@ fun Project.testApiJUnit5(
         if (vintageEngine) {
             testApi("org.junit.vintage:junit-vintage-engine:$platformVersion")
         }
+
+        if (jupiterParams) {
+            testApi("org.junit.jupiter:junit-jupiter-params:$platformVersion")
+        }
+
         val componentsVersion = commonVer("org.junit.platform", "")
 
         val components = mutableListOf(

buildSrc/src/main/kotlin/gradle-plugin-common-configuration.gradle.kts

@@ -0,0 +1,51 @@
+/*
+ * 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.
+ */
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("jvm")
+}
+
+publish()
+standardPublicJars()
+
+extensions.extraProperties["kotlin.stdlib.default.dependency"] = "false"
+
+dependencies {
+    compileOnly(kotlinStdlib())
+    compileOnly(gradleApi())
+}
+
+// These dependencies will be provided by Gradle and we should prevent version conflict
+fun Configuration.excludeGradleCommonDependencies() {
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-jdk7")
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-jdk8")
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-common")
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-reflect")
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-script-runtime")
+}
+configurations {
+    "implementation" {
+        excludeGradleCommonDependencies()
+    }
+    "api" {
+        excludeGradleCommonDependencies()
+    }
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions.languageVersion = "1.3"
+    kotlinOptions.apiVersion = "1.3"
+    kotlinOptions.freeCompilerArgs += listOf(
+        "-Xskip-prerelease-check",
+        "-Xskip-runtime-version-check",
+        "-Xsuppress-version-warnings"
+    )
+}
+
+tasks.named<Jar>("jar") {
+    callGroovy("manifestAttributes", manifest, project)
+}

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

@@ -5,6 +5,7 @@
 
 package plugins
 
+import PublishToMavenLocalSerializable
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.attributes.Usage
@@ -13,10 +14,10 @@ import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.publish.maven.plugins.MavenPublishPlugin
+import org.gradle.api.publish.maven.tasks.PublishToMavenLocal
 import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.*
-import org.gradle.plugins.signing.Sign
 import org.gradle.plugins.signing.SigningExtension
 import org.gradle.plugins.signing.SigningPlugin
 import java.util.*
@@ -27,7 +28,6 @@ class KotlinBuildPublishingPlugin @Inject constructor(
 ) : Plugin<Project> {
     override fun apply(target: Project): Unit = with(target) {
         apply<MavenPublishPlugin>()
-        apply<SigningPlugin>()
 
         val publishedRuntime = configurations.maybeCreate(RUNTIME_CONFIGURATION).apply {
             isCanBeConsumed = false
@@ -132,32 +132,40 @@ fun Project.configureDefaultPublishing() {
         }
     }
 
-    configureSigning()
+    val signingRequired = project.providers.gradleProperty("signingRequired").forUseAtConfigurationTime().orNull?.toBoolean()
+        ?: project.providers.gradleProperty("isSonatypeRelease").forUseAtConfigurationTime().orNull?.toBoolean() ?: false
+
+    if (signingRequired) {
+        apply<SigningPlugin>()
+        configureSigning()
+    }
 
     tasks.register("install") {
         dependsOn(tasks.named("publishToMavenLocal"))
     }
 
+    // workaround for Gradle configuration cache
+    // TODO: remove it when https://github.com/gradle/gradle/pull/16945 merged into used in build Gradle version
+    tasks.withType(PublishToMavenLocal::class.java) {
+        val originalTask = this
+        val serializablePublishTask =
+            tasks.register(originalTask.name + "Serializable", PublishToMavenLocalSerializable::class.java) {
+                publication = originalTask.publication
+            }
+        originalTask.onlyIf { false }
+        originalTask.dependsOn(serializablePublishTask)
+    }
+
     tasks.withType<PublishToMavenRepository>()
         .matching { it.name.endsWith("PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository") }
         .all { configureRepository() }
 }
 
 private fun Project.configureSigning() {
-    val signingRequired = provider {
-        project.findProperty("signingRequired")?.toString()?.toBoolean()
-            ?: project.property("isSonatypeRelease") as Boolean
-    }
-
     configure<SigningExtension> {
-        setRequired(signingRequired)
         sign(extensions.getByType<PublishingExtension>().publications) // all publications
         useGpgCmd()
     }
-
-    tasks.withType<Sign>().configureEach {
-        setOnlyIf { signingRequired.get() }
-    }
 }
 
 fun TaskProvider<PublishToMavenRepository>.configureRepository() =
@@ -181,4 +189,4 @@ private fun PublishToMavenRepository.configureRepository() {
             }
         }
     }
-}
+}

buildSrc/src/main/kotlin/tasks.kt

@@ -7,13 +7,22 @@
 // usages in build scripts are not tracked properly
 @file:Suppress("unused")
 
+import org.gradle.api.InvalidUserDataException
 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.publish.internal.PublishOperation
+import org.gradle.api.publish.maven.internal.publication.MavenPublicationInternal
+import org.gradle.api.publish.maven.internal.publisher.MavenNormalizedPublication
+import org.gradle.api.publish.maven.internal.publisher.MavenPublisher
+import org.gradle.api.publish.maven.internal.publisher.ValidatingMavenPublisher
+import org.gradle.api.publish.maven.tasks.AbstractPublishToMaven
+import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.testing.Test
+import org.gradle.internal.serialization.Cached
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import org.gradle.kotlin.dsl.support.serviceOf
@@ -38,6 +47,7 @@ val kotlinGradlePluginAndItsRequired = arrayOf(
     ":kotlin-compiler-runner",
     ":kotlin-daemon-embeddable",
     ":kotlin-daemon-client",
+    ":kotlin-project-model",
     ":kotlin-gradle-plugin-api",
     ":kotlin-gradle-plugin",
     ":kotlin-gradle-plugin-model",
@@ -279,3 +289,30 @@ fun Task.useAndroidSdk() {
 fun Task.useAndroidJar() {
     TaskUtils.useAndroidJar(this)
 }
+
+// Workaround to make PublishToMavenLocal compatible with Gradle configuration cache
+// TODO: remove it when https://github.com/gradle/gradle/pull/16945 merged into used in build Gradle version
+abstract class PublishToMavenLocalSerializable : AbstractPublishToMaven() {
+    private val normalizedPublication = Cached.of { this.computeNormalizedPublication() }
+
+    private fun computeNormalizedPublication(): MavenNormalizedPublication {
+        val publicationInternal: MavenPublicationInternal = publicationInternal
+            ?: throw InvalidUserDataException("The 'publication' property is required")
+        duplicatePublicationTracker.checkCanPublishToMavenLocal(publicationInternal)
+        return publicationInternal.asNormalisedPublication()
+    }
+
+    @TaskAction
+    open fun publish() {
+        val normalizedPublication = normalizedPublication.get()
+        object : PublishOperation(normalizedPublication.name, "mavenLocal") {
+            override fun publish() {
+                val localPublisher = mavenPublishers.getLocalPublisher(
+                    temporaryDirFactory
+                )
+                val validatingPublisher: MavenPublisher = ValidatingMavenPublisher(localPublisher)
+                validatingPublisher.publish(normalizedPublication, null)
+            }
+        }.run()
+    }
+}

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/SamType.kt

@@ -87,4 +87,4 @@ open class SamTypeFactory {
     companion object {
         val INSTANCE = SamTypeFactory()
     }
-}
+}

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

@@ -18,6 +18,7 @@ interface TypeMappingContext<Writer : JvmDescriptorTypeWriter<Type>> {
     val typeContext: TypeSystemCommonBackendContextForTypeMapping
 
     fun getClassInternalName(typeConstructor: TypeConstructorMarker): String
+    fun getScriptInternalName(typeConstructor: TypeConstructorMarker): String
     fun Writer.writeGenericType(type: SimpleTypeMarker, asmType: Type, mode: TypeMappingMode)
 }
 
@@ -117,9 +118,7 @@ object AbstractTypeMapper {
             }
 
             typeConstructor.isScript() -> {
-                val asmType = AsmTypes.JAVA_CLASS_TYPE
-                with(context) { sw?.writeGenericType(type, asmType, mode) }
-                return asmType
+                return Type.getObjectType(context.getScriptInternalName(typeConstructor))
             }
 
             typeConstructor.isTypeParameter() -> {

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

@@ -158,7 +158,14 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         for (int i = 0; i < superInterfaceTypes.size(); i++) {
             KotlinType superInterfaceType = superInterfaceTypes.get(i);
             sw.writeInterface();
-            superInterfaceAsmTypes[i] = typeMapper.mapSupertype(superInterfaceType, sw).getInternalName();
+            Type superInterfaceAsmType;
+            if (samType != null && superInterfaceType.getConstructor() == samType.getType().getConstructor()) {
+                superInterfaceAsmType = typeMapper.mapSupertype(superInterfaceType, null);
+                sw.writeAsmType(superInterfaceAsmType);
+            } else {
+                superInterfaceAsmType = typeMapper.mapSupertype(superInterfaceType, sw);
+            }
+            superInterfaceAsmTypes[i] = superInterfaceAsmType.getInternalName();
             sw.writeInterfaceEnd();
         }
 

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

@@ -265,13 +265,23 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         );
     }
 
-    private static void addReifiedParametersFromSignature(@NotNull MemberCodegen member, @NotNull ClassDescriptor descriptor) {
+    private static void addReifiedParametersFromSignature(@NotNull MemberCodegen<?> member, @NotNull ClassDescriptor descriptor) {
         for (KotlinType type : descriptor.getTypeConstructor().getSupertypes()) {
-            for (TypeProjection supertypeArgument : type.getArguments()) {
-                TypeParameterDescriptor parameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(supertypeArgument.getType());
-                if (parameterDescriptor != null && parameterDescriptor.isReified()) {
+            processTypeArguments(member, type);
+        }
+    }
+
+    private static void processTypeArguments(@NotNull MemberCodegen<?> member, KotlinType type) {
+        for (TypeProjection supertypeArgument : type.getArguments()) {
+            if (supertypeArgument.isStarProjection()) continue;
+
+            TypeParameterDescriptor parameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(supertypeArgument.getType());
+            if (parameterDescriptor != null) {
+                if (parameterDescriptor.isReified()) {
                     member.getReifiedTypeParametersUsages().addUsedReifiedParameter(parameterDescriptor.getName().asString());
                 }
+            } else {
+                processTypeArguments(member, supertypeArgument.getType());
             }
         }
     }
@@ -3009,7 +3019,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     @NotNull
     private KotlinType approximateCapturedType(@NotNull KotlinType type) {
         if (state.getLanguageVersionSettings().supportsFeature(LanguageFeature.NewInference)) {
-            TypeApproximator approximator = new TypeApproximator(state.getModule().getBuiltIns());
+            TypeApproximator approximator = new TypeApproximator(state.getModule().getBuiltIns(), state.getLanguageVersionSettings());
 
             KotlinType approximatedType =
                     TypeUtils.contains(type, (containedType) -> CapturedTypeConstructorKt.isCaptured(containedType)) ?

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

@@ -188,6 +188,12 @@ class JvmRuntimeTypes(
             else -> if (isMutable) mutablePropertyReferences else propertyReferences
         }
 
-        return classes[arity].defaultType
+        return if (arity >= 0) {
+            classes[arity].defaultType
+        } else {
+            //in case of ErrorUtils.ERROR_PROPERTY there would be no dispatchReceiverParameter and arity becomes negative
+            //so we just take zero argument reference class (because it is incorrect anyway)
+            classes[0].defaultType
+        }
     }
 }

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

@@ -999,7 +999,7 @@ class CoroutineTransformerMethodVisitor(
                 else -> next = next.next
             }
         }
-        return next
+        return null
     }
 
     // It's necessary to preserve some sensible invariants like there should be no jump in the middle of try-catch-block
@@ -1329,7 +1329,7 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
                     variable.desc,
                     variable.signature,
                     variable.start,
-                    nextSuspensionPointStartLabel(variable.start),
+                    min(variable.end, nextSuspensionPointStartLabel(variable.start)),
                     variable.index
                 )
             )

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

@@ -320,8 +320,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
 
                 val splitBy = SimpleInterval(start.info as LabelNode, extension.finallyIntervalEnd)
                 processor.tryBlocksMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true)
-
-                //processor.getLocalVarsMetaInfo().splitAndRemoveIntervalsFromCurrents(splitBy);
+                processor.localVarsMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true);
 
                 mark.dropTo()
             }
@@ -330,8 +329,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         }
 
         processor.substituteTryBlockNodes(intoNode)
-
-        //processor.substituteLocalVarTable(intoNode);
+        processor.substituteLocalVarTable(intoNode);
     }
 
     protected abstract fun generateAssertFieldIfNeeded(info: RootInliningContext)

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

@@ -5,32 +5,14 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.codegen.AsmUtil
-import org.jetbrains.kotlin.codegen.DescriptorAsmUtil
-import org.jetbrains.kotlin.codegen.PropertyReferenceCodegen
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.codegen.binding.CalculatedClosure
-import org.jetbrains.kotlin.codegen.binding.CodegenBinding.*
-import org.jetbrains.kotlin.codegen.binding.MutableClosure
 import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor
-import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
-import org.jetbrains.kotlin.codegen.coroutines.isCapturedSuspendLambda
-import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.isReleaseCoroutines
-import org.jetbrains.kotlin.coroutines.isSuspendLambda
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.psi.KtLambdaExpression
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.util.OperatorNameConventions
-import org.jetbrains.org.objectweb.asm.*
+import org.jetbrains.org.objectweb.asm.ClassReader
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
 import kotlin.properties.Delegates
@@ -47,7 +29,9 @@ abstract class LambdaInfo(@JvmField val isCrossInline: Boolean) : FunctionalArgu
 
     abstract val invokeMethod: Method
 
-    abstract val invokeMethodDescriptor: FunctionDescriptor
+    abstract val invokeMethodParameters: List<KotlinType?>
+
+    abstract val invokeMethodReturnType: KotlinType?
 
     abstract val capturedVars: List<CapturedParamDesc>
 
@@ -56,6 +40,8 @@ abstract class LambdaInfo(@JvmField val isCrossInline: Boolean) : FunctionalArgu
 
     lateinit var node: SMAPAndMethodNode
 
+    val reifiedTypeParametersUsages = ReifiedTypeParametersUsages()
+
     abstract fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>)
 
     open val hasDispatchReceiver = true
@@ -90,31 +76,21 @@ abstract class LambdaInfo(@JvmField val isCrossInline: Boolean) : FunctionalArgu
 object NonInlineableArgumentForInlineableParameterCalledInSuspend : FunctionalArgument
 object NonInlineableArgumentForInlineableSuspendParameter : FunctionalArgument
 
-
-class PsiDefaultLambda(
-    lambdaClassType: Type,
-    capturedArgs: Array<Type>,
-    parameterDescriptor: ValueParameterDescriptor,
-    offset: Int,
-    needReification: Boolean
-) : DefaultLambda(lambdaClassType, capturedArgs, parameterDescriptor, offset, needReification) {
-    override fun mapAsmSignature(sourceCompiler: SourceCompilerForInline): Method {
-        return sourceCompiler.state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor).asmMethod
+abstract class ExpressionLambda(isCrossInline: Boolean) : LambdaInfo(isCrossInline) {
+    override fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>) {
+        node = sourceCompiler.generateLambdaBody(this, reifiedTypeParametersUsages)
+        node.node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
     }
 
-    override fun findInvokeMethodDescriptor(): FunctionDescriptor =
-        parameterDescriptor.type.memberScope
-            .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
-            .single()
+    abstract fun isCapturedSuspend(desc: CapturedParamDesc): Boolean
 }
 
 abstract class DefaultLambda(
-    override val lambdaClassType: Type,
     private val capturedArgs: Array<Type>,
-    val parameterDescriptor: ValueParameterDescriptor,
+    isCrossinline: Boolean,
     val offset: Int,
     val needReification: Boolean
-) : LambdaInfo(parameterDescriptor.isCrossinline) {
+) : LambdaInfo(isCrossinline) {
 
     final override var isBoundCallableReference by Delegates.notNull<Boolean>()
         private set
@@ -124,80 +100,52 @@ abstract class DefaultLambda(
     final override lateinit var invokeMethod: Method
         private set
 
-    override lateinit var invokeMethodDescriptor: FunctionDescriptor
-
     final override lateinit var capturedVars: List<CapturedParamDesc>
         private set
 
     var originalBoundReceiverType: Type? = null
         private set
 
-    override val isSuspend = parameterDescriptor.isSuspendLambda
+    override val isSuspend = false // TODO: it should probably be true sometimes, but it never was
 
     override fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>) {
         val classBytes = loadClassBytesByInternalName(sourceCompiler.state, lambdaClassType.internalName)
-        val classReader = ClassReader(classBytes)
-        var isPropertyReference = false
-        var isFunctionReference = false
-        classReader.accept(object : ClassVisitor(Opcodes.API_VERSION) {
-            override fun visit(
-                version: Int,
-                access: Int,
-                name: String,
-                signature: String?,
-                superName: String?,
-                interfaces: Array<out String>?
-            ) {
-                isPropertyReference = superName in PROPERTY_REFERENCE_SUPER_CLASSES
-                isFunctionReference = superName == FUNCTION_REFERENCE.internalName || superName == FUNCTION_REFERENCE_IMPL.internalName
-
-                super.visit(version, access, name, signature, superName, interfaces)
-            }
-        }, ClassReader.SKIP_CODE or ClassReader.SKIP_FRAMES or ClassReader.SKIP_DEBUG)
-
-        invokeMethodDescriptor = findInvokeMethodDescriptor().let {
-            //property reference generates erased 'get' method
-            if (isPropertyReference) it.original else it
-        }
-
-        val descriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
-        val constructor = getMethodNode(classBytes, "<init>", descriptor, lambdaClassType)?.node
+        val superName = ClassReader(classBytes).superName
+        val isPropertyReference = superName in PROPERTY_REFERENCE_SUPER_CLASSES
+        val isFunctionReference = superName == FUNCTION_REFERENCE.internalName || superName == FUNCTION_REFERENCE_IMPL.internalName
 
+        val constructorDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
+        val constructor = getMethodNode(classBytes, "<init>", constructorDescriptor, lambdaClassType)?.node
         assert(constructor != null || capturedArgs.isEmpty()) {
-            "Can't find non-default constructor <init>$descriptor for default lambda $lambdaClassType"
+            "Can't find non-default constructor <init>$constructorDescriptor for default lambda $lambdaClassType"
         }
-
         capturedVars =
             if (isFunctionReference || isPropertyReference)
                 constructor?.desc?.let { Type.getArgumentTypes(it) }?.singleOrNull()?.let {
                     originalBoundReceiverType = it
-                    listOf(capturedParamDesc(AsmUtil.RECEIVER_PARAMETER_NAME, it.boxReceiverForBoundReference()))
+                    listOf(capturedParamDesc(AsmUtil.RECEIVER_PARAMETER_NAME, AsmUtil.boxType(it)))
                 } ?: emptyList()
             else
                 constructor?.findCapturedFieldAssignmentInstructions()?.map { fieldNode ->
                     capturedParamDesc(fieldNode.name, Type.getType(fieldNode.desc))
                 }?.toList() ?: emptyList()
-
         isBoundCallableReference = (isFunctionReference || isPropertyReference) && capturedVars.isNotEmpty()
 
-        val methodName = (if (isPropertyReference) OperatorNameConventions.GET else OperatorNameConventions.INVOKE).asString()
-
-        val signature = mapAsmSignature(sourceCompiler)
-
-        node = getMethodNode(classBytes, methodName, signature.descriptor, lambdaClassType, signatureAmbiguity = true)
-            ?: error("Can't find method '$methodName$signature' in '${classReader.className}'")
-
-        invokeMethod = Method(node.node.name, node.node.desc)
-
+        val invokeNameFallback = (if (isPropertyReference) OperatorNameConventions.GET else OperatorNameConventions.INVOKE).asString()
+        val invokeMethod = mapAsmMethod(sourceCompiler, isPropertyReference)
+        // TODO: `signatureAmbiguity = true` ignores the argument types from `invokeDescriptor` and only looks at the count.
+        //   This effectively masks incorrect results from `mapAsmDescriptor`, which hopefully won't manifest in another way.
+        node = getMethodNode(classBytes, invokeMethod.name, invokeMethod.descriptor, lambdaClassType, signatureAmbiguity = true)
+            ?: getMethodNode(classBytes, invokeNameFallback, invokeMethod.descriptor, lambdaClassType, signatureAmbiguity = true)
+                    ?: error("Can't find method '$invokeMethod' in '${lambdaClassType.internalName}'")
+        this.invokeMethod = Method(node.node.name, node.node.desc)
         if (needReification) {
             //nested classes could also require reification
-            reifiedTypeInliner.reifyInstructions(node.node)
+            reifiedTypeParametersUsages.mergeAll(reifiedTypeInliner.reifyInstructions(node.node))
         }
     }
 
-    protected abstract fun mapAsmSignature(sourceCompiler: SourceCompilerForInline): Method
-
-    protected abstract fun findInvokeMethodDescriptor(): FunctionDescriptor
+    protected abstract fun mapAsmMethod(sourceCompiler: SourceCompilerForInline, isPropertyReference: Boolean): Method
 
     private companion object {
         val PROPERTY_REFERENCE_SUPER_CLASSES =
@@ -208,131 +156,3 @@ abstract class DefaultLambda(
                 .mapTo(HashSet(), Type::getInternalName)
     }
 }
-
-internal fun Type.boxReceiverForBoundReference() =
-    AsmUtil.boxType(this)
-
-internal fun Type.boxReceiverForBoundReference(kotlinType: KotlinType, typeMapper: KotlinTypeMapper) =
-    DescriptorAsmUtil.boxType(this, kotlinType, typeMapper)
-
-abstract class ExpressionLambda(isCrossInline: Boolean) : LambdaInfo(isCrossInline) {
-    override fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>) {
-        node = sourceCompiler.generateLambdaBody(this)
-        node.node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
-    }
-
-    abstract fun getInlineSuspendLambdaViewDescriptor(): FunctionDescriptor
-    abstract fun isCapturedSuspend(desc: CapturedParamDesc): Boolean
-}
-
-class PsiExpressionLambda(
-    expression: KtExpression,
-    private val typeMapper: KotlinTypeMapper,
-    private val languageVersionSettings: LanguageVersionSettings,
-    isCrossInline: Boolean,
-    override val isBoundCallableReference: Boolean
-) : ExpressionLambda(isCrossInline) {
-
-    override val lambdaClassType: Type
-
-    override val invokeMethod: Method
-
-    override val invokeMethodDescriptor: FunctionDescriptor
-
-    val classDescriptor: ClassDescriptor
-
-    val propertyReferenceInfo: PropertyReferenceInfo?
-
-    val functionWithBodyOrCallableReference: KtExpression = (expression as? KtLambdaExpression)?.functionLiteral ?: expression
-
-    override val returnLabels: Map<String, Label?>
-
-    override val isSuspend: Boolean
-
-    var closure: CalculatedClosure
-        private set
-
-    init {
-        val bindingContext = typeMapper.bindingContext
-        val function =
-            bindingContext.get<PsiElement, SimpleFunctionDescriptor>(BindingContext.FUNCTION, functionWithBodyOrCallableReference)
-        if (function == null && expression is KtCallableReferenceExpression) {
-            val variableDescriptor =
-                bindingContext.get(BindingContext.VARIABLE, functionWithBodyOrCallableReference) as? VariableDescriptorWithAccessors
-                    ?: throw AssertionError("Reference expression not resolved to variable descriptor with accessors: ${expression.getText()}")
-            classDescriptor = bindingContext.get(CLASS_FOR_CALLABLE, variableDescriptor)
-                ?: throw IllegalStateException("Class for callable not found: $variableDescriptor\n${expression.text}")
-            lambdaClassType = typeMapper.mapClass(classDescriptor)
-            val getFunction = PropertyReferenceCodegen.findGetFunction(variableDescriptor)
-            invokeMethodDescriptor = PropertyReferenceCodegen.createFakeOpenDescriptor(getFunction, classDescriptor)
-            val resolvedCall = expression.callableReference.getResolvedCallWithAssert(bindingContext)
-            propertyReferenceInfo = PropertyReferenceInfo(
-                resolvedCall.resultingDescriptor as VariableDescriptor, getFunction
-            )
-        } else {
-            propertyReferenceInfo = null
-            invokeMethodDescriptor = function ?: throw AssertionError("Function is not resolved to descriptor: " + expression.text)
-            classDescriptor = bindingContext.get(CLASS_FOR_CALLABLE, invokeMethodDescriptor)
-                ?: throw IllegalStateException("Class for invoke method not found: $invokeMethodDescriptor\n${expression.text}")
-            lambdaClassType = asmTypeForAnonymousClass(bindingContext, invokeMethodDescriptor)
-        }
-
-        bindingContext.get<ClassDescriptor, MutableClosure>(CLOSURE, classDescriptor).let {
-            assert(it != null) { "Closure for lambda should be not null " + expression.text }
-            closure = it!!
-        }
-
-        returnLabels = InlineCodegen.getDeclarationLabels(expression, invokeMethodDescriptor).associateWith { null }
-        invokeMethod = typeMapper.mapAsmMethod(invokeMethodDescriptor)
-        isSuspend = invokeMethodDescriptor.isSuspend
-    }
-
-    override val capturedVars: List<CapturedParamDesc> by lazy {
-        arrayListOf<CapturedParamDesc>().apply {
-            val captureThis = closure.capturedOuterClassDescriptor
-            if (captureThis != null) {
-                val kotlinType = captureThis.defaultType
-                val type = typeMapper.mapType(kotlinType)
-                val descriptor = EnclosedValueDescriptor(
-                    AsmUtil.CAPTURED_THIS_FIELD, null,
-                    StackValue.field(type, lambdaClassType, AsmUtil.CAPTURED_THIS_FIELD, false, StackValue.LOCAL_0),
-                    type, kotlinType
-                )
-                add(getCapturedParamInfo(descriptor))
-            }
-
-            val capturedReceiver = closure.capturedReceiverFromOuterContext
-            if (capturedReceiver != null) {
-                val type = typeMapper.mapType(capturedReceiver).let {
-                    if (isBoundCallableReference) it.boxReceiverForBoundReference() else it
-                }
-
-                val fieldName = closure.getCapturedReceiverFieldName(typeMapper.bindingContext, languageVersionSettings)
-                val descriptor = EnclosedValueDescriptor(
-                    fieldName, null,
-                    StackValue.field(type, capturedReceiver, lambdaClassType, fieldName, false, StackValue.LOCAL_0),
-                    type, capturedReceiver
-                )
-                add(getCapturedParamInfo(descriptor))
-            }
-
-            closure.captureVariables.values.forEach { descriptor ->
-                add(getCapturedParamInfo(descriptor))
-            }
-        }
-    }
-
-    val isPropertyReference: Boolean
-        get() = propertyReferenceInfo != null
-
-    override fun getInlineSuspendLambdaViewDescriptor(): FunctionDescriptor {
-        return getOrCreateJvmSuspendFunctionView(
-            invokeMethodDescriptor,
-            languageVersionSettings.isReleaseCoroutines(),
-            typeMapper.bindingContext
-        )
-    }
-
-    override fun isCapturedSuspend(desc: CapturedParamDesc): Boolean =
-        isCapturedSuspendLambda(closure, desc.fieldName, typeMapper.bindingContext)
-}

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

@@ -23,13 +23,10 @@ import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.ParameterDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
-import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.kotlin.utils.SmartSet
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -233,52 +230,34 @@ class MethodInliner(
                         return
                     }
 
-                    // in case of inlining suspend lambda reference as ordinary parameter of inline function:
-                    //   suspend fun foo (...) ...
-                    //   inline fun inlineMe(c: (...) -> ...) ...
-                    //   builder {
-                    //     inlineMe(::foo)
-                    //   }
-                    // we should create additional parameter for continuation.
-                    var coroutineDesc = desc
-                    val actualInvokeDescriptor: FunctionDescriptor
-                    if (info.isSuspend) {
-                        actualInvokeDescriptor = (info as ExpressionLambda).getInlineSuspendLambdaViewDescriptor()
-                        val parametersSize = actualInvokeDescriptor.valueParameters.size +
-                                (if (actualInvokeDescriptor.extensionReceiverParameter != null) 1 else 0)
-                        // And here we expect invoke(...Ljava/lang/Object;) be replaced with invoke(...Lkotlin/coroutines/Continuation;)
-                        // if this does not happen, insert fake continuation, since we could not have one yet.
-                        val argumentTypes = Type.getArgumentTypes(desc)
-                        if (argumentTypes.size != parametersSize &&
-                            // But do not add it in IR. In IR we already have lowered lambdas with additional parameter, while in Old BE we don't.
-                            !inliningContext.root.state.isIrBackend
-                        ) {
+                    val nullableAnyType = inliningContext.root.sourceCompilerForInline.compilationContextDescriptor.builtIns.nullableAnyType
+                    val expectedParameters = info.invokeMethod.argumentTypes
+                    val expectedKotlinParameters = info.invokeMethodParameters
+                    val argumentCount = Type.getArgumentTypes(desc).size.let {
+                        if (!inliningContext.root.state.isIrBackend && info.isSuspend && it < expectedParameters.size) {
+                            // Inlining suspend lambda into a function that takes a non-suspend lambda.
+                            // In the IR backend, this cannot happen as inline lambdas are not lowered.
                             addFakeContinuationMarker(this)
-                            coroutineDesc = Type.getMethodDescriptor(Type.getReturnType(desc), *argumentTypes, AsmTypes.OBJECT_TYPE)
-                        }
-                    } else {
-                        actualInvokeDescriptor = info.invokeMethodDescriptor
+                            it + 1
+                        } else it
+                    }
+                    assert(argumentCount == expectedParameters.size && argumentCount == expectedKotlinParameters.size) {
+                        "inconsistent lambda arguments: $argumentCount on stack, ${expectedParameters.size} expected, " +
+                                "${expectedKotlinParameters.size} Kotlin types"
                     }
 
-                    val valueParameters =
-                        listOfNotNull(actualInvokeDescriptor.extensionReceiverParameter) + actualInvokeDescriptor.valueParameters
-
-                    val erasedInvokeFunction = ClosureCodegen.getErasedInvokeFunction(actualInvokeDescriptor)
-                    val invokeParameters = erasedInvokeFunction.valueParameters
-
-                    val valueParamShift = max(nextLocalIndex, markerShift)//NB: don't inline cause it changes
-                    val parameterTypesFromDesc = info.invokeMethod.argumentTypes
-                    putStackValuesIntoLocalsForLambdaOnInvoke(
-                        listOf(*parameterTypesFromDesc), valueParameters, invokeParameters, valueParamShift, this, coroutineDesc
-                    )
-
-                    if (parameterTypesFromDesc.isEmpty()) {
-                        // There won't be no parameters processing and line call can be left without actual instructions.
-                        // Note: if function is called on the line with other instructions like 1 + foo(), 'nop' will still be generated.
-                        visitInsn(Opcodes.NOP)
+                    var valueParamShift = max(nextLocalIndex, markerShift) + expectedParameters.sumOf { it.size }
+                    for (index in argumentCount - 1 downTo 0) {
+                        val type = expectedParameters[index]
+                        StackValue.coerce(AsmTypes.OBJECT_TYPE, nullableAnyType, type, expectedKotlinParameters[index], this)
+                        valueParamShift -= type.size
+                        store(valueParamShift, type)
+                    }
+                    if (expectedParameters.isEmpty()) {
+                        nop() // add something for a line number to bind onto
                     }
 
-                    inlineOnlySmapSkipper?.onInlineLambdaStart(remappingMethodAdapter, info, sourceMapper.parent)
+                    inlineOnlySmapSkipper?.onInlineLambdaStart(remappingMethodAdapter, info.node.node, sourceMapper.parent)
                     addInlineMarker(this, true)
                     val lambdaParameters = info.addAllParameters(nodeRemapper)
 
@@ -303,10 +282,9 @@ class MethodInliner(
                     val lambdaResult = inliner.doInline(localVariablesSorter, varRemapper, true, info.returnLabels, invokeCall.finallyDepthShift)
                     result.mergeWithNotChangeInfo(lambdaResult)
                     result.reifiedTypeParametersUsages.mergeAll(lambdaResult.reifiedTypeParametersUsages)
+                    result.reifiedTypeParametersUsages.mergeAll(info.reifiedTypeParametersUsages)
 
-                    StackValue
-                        .onStack(info.invokeMethod.returnType, info.invokeMethodDescriptor.returnType)
-                        .put(OBJECT_TYPE, erasedInvokeFunction.returnType, this)
+                    StackValue.coerce(info.invokeMethod.returnType, info.invokeMethodReturnType, OBJECT_TYPE, nullableAnyType, this)
                     setLambdaInlining(false)
                     addInlineMarker(this, false)
                     inlineOnlySmapSkipper?.onInlineLambdaEnd(remappingMethodAdapter)
@@ -1073,46 +1051,6 @@ class MethodInliner(
             }
         }
 
-        private fun putStackValuesIntoLocalsForLambdaOnInvoke(
-            directOrder: List<Type>,
-            directOrderOfArguments: List<ParameterDescriptor>,
-            directOrderOfInvokeParameters: List<ValueParameterDescriptor>,
-            shift: Int,
-            iv: InstructionAdapter,
-            descriptor: String
-        ) {
-            val actualParams = Type.getArgumentTypes(descriptor)
-            assert(actualParams.size == directOrder.size) {
-                "Number of expected and actual parameters should be equal, but ${actualParams.size} != ${directOrder.size}!"
-            }
-
-            var currentShift = shift + directOrder.sumOf { it.size }
-
-            val safeToUseArgumentKotlinType =
-                directOrder.size == directOrderOfArguments.size && directOrderOfArguments.size == directOrderOfInvokeParameters.size
-
-            for (index in directOrder.lastIndex downTo 0) {
-                val type = directOrder[index]
-                currentShift -= type.size
-                val typeOnStack = actualParams[index]
-
-                val argumentKotlinType: KotlinType?
-                val invokeParameterKotlinType: KotlinType?
-                if (safeToUseArgumentKotlinType) {
-                    argumentKotlinType = directOrderOfArguments[index].type
-                    invokeParameterKotlinType = directOrderOfInvokeParameters[index].type
-                } else {
-                    argumentKotlinType = null
-                    invokeParameterKotlinType = null
-                }
-
-                if (typeOnStack != type || invokeParameterKotlinType != argumentKotlinType) {
-                    StackValue.onStack(typeOnStack, invokeParameterKotlinType).put(type, argumentKotlinType, iv)
-                }
-                iv.store(currentShift, type)
-            }
-        }
-
         //process local and global returns (local substituted with goto end-label global kept unchanged)
         @JvmStatic
         fun processReturns(

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

@@ -5,20 +5,25 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
+import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getMethodAsmFlags
+import org.jetbrains.kotlin.codegen.binding.CalculatedClosure
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
+import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor
+import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
+import org.jetbrains.kotlin.codegen.coroutines.isCapturedSuspendLambda
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.psi.KtIfExpression
-import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.isReleaseCoroutines
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
+import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
@@ -28,8 +33,11 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.util.OperatorNameConventions
+import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 class PsiInlineCodegen(
@@ -140,9 +148,9 @@ class PsiInlineCodegen(
                 val receiverKotlinType = receiver.kotlinType
                 val boxedReceiver =
                     if (receiverKotlinType != null)
-                        receiver.type.boxReceiverForBoundReference(receiverKotlinType, state.typeMapper)
+                        DescriptorAsmUtil.boxType(receiver.type, receiverKotlinType, state.typeMapper)
                     else
-                        receiver.type.boxReceiverForBoundReference()
+                        AsmUtil.boxType(receiver.type)
 
                 putClosureParametersOnStack(
                     lambdaInfo,
@@ -214,3 +222,154 @@ class PsiInlineCodegen(
     override fun descriptorIsDeserialized(memberDescriptor: CallableMemberDescriptor): Boolean =
         memberDescriptor is DescriptorWithContainerSource
 }
+
+private val FunctionDescriptor.explicitParameters
+    get() = listOfNotNull(extensionReceiverParameter) + valueParameters
+
+class PsiExpressionLambda(
+    expression: KtExpression,
+    private val typeMapper: KotlinTypeMapper,
+    private val languageVersionSettings: LanguageVersionSettings,
+    isCrossInline: Boolean,
+    override val isBoundCallableReference: Boolean
+) : ExpressionLambda(isCrossInline) {
+
+    override val lambdaClassType: Type
+
+    override val invokeMethod: Method
+
+    val invokeMethodDescriptor: FunctionDescriptor
+
+    override val invokeMethodParameters: List<KotlinType?>
+        get() {
+            val actualInvokeDescriptor = if (isSuspend)
+                getOrCreateJvmSuspendFunctionView(
+                    invokeMethodDescriptor, languageVersionSettings.isReleaseCoroutines(), typeMapper.bindingContext
+                )
+            else
+                invokeMethodDescriptor
+            return actualInvokeDescriptor.explicitParameters.map { it.returnType }
+        }
+
+    override val invokeMethodReturnType: KotlinType?
+        get() = invokeMethodDescriptor.returnType
+
+    val classDescriptor: ClassDescriptor
+
+    val propertyReferenceInfo: PropertyReferenceInfo?
+
+    val functionWithBodyOrCallableReference: KtExpression = (expression as? KtLambdaExpression)?.functionLiteral ?: expression
+
+    override val returnLabels: Map<String, Label?>
+
+    override val isSuspend: Boolean
+
+    val closure: CalculatedClosure
+
+    init {
+        val bindingContext = typeMapper.bindingContext
+        val function = bindingContext.get(BindingContext.FUNCTION, functionWithBodyOrCallableReference)
+        if (function == null && expression is KtCallableReferenceExpression) {
+            val variableDescriptor =
+                bindingContext.get(BindingContext.VARIABLE, functionWithBodyOrCallableReference) as? VariableDescriptorWithAccessors
+                    ?: throw AssertionError("Reference expression not resolved to variable descriptor with accessors: ${expression.getText()}")
+            classDescriptor = bindingContext.get(CodegenBinding.CLASS_FOR_CALLABLE, variableDescriptor)
+                ?: throw IllegalStateException("Class for callable not found: $variableDescriptor\n${expression.text}")
+            lambdaClassType = typeMapper.mapClass(classDescriptor)
+            val getFunction = PropertyReferenceCodegen.findGetFunction(variableDescriptor)
+            invokeMethodDescriptor = PropertyReferenceCodegen.createFakeOpenDescriptor(getFunction, classDescriptor)
+            val resolvedCall = expression.callableReference.getResolvedCallWithAssert(bindingContext)
+            propertyReferenceInfo = PropertyReferenceInfo(resolvedCall.resultingDescriptor as VariableDescriptor, getFunction)
+        } else {
+            propertyReferenceInfo = null
+            invokeMethodDescriptor = function ?: throw AssertionError("Function is not resolved to descriptor: " + expression.text)
+            classDescriptor = bindingContext.get(CodegenBinding.CLASS_FOR_CALLABLE, invokeMethodDescriptor)
+                ?: throw IllegalStateException("Class for invoke method not found: $invokeMethodDescriptor\n${expression.text}")
+            lambdaClassType = CodegenBinding.asmTypeForAnonymousClass(bindingContext, invokeMethodDescriptor)
+        }
+
+        closure = bindingContext.get(CodegenBinding.CLOSURE, classDescriptor)
+            ?: throw AssertionError("null closure for lambda ${expression.text}")
+        returnLabels = InlineCodegen.getDeclarationLabels(expression, invokeMethodDescriptor).associateWith { null }
+        invokeMethod = typeMapper.mapAsmMethod(invokeMethodDescriptor)
+        isSuspend = invokeMethodDescriptor.isSuspend
+    }
+
+    override val capturedVars: List<CapturedParamDesc> by lazy {
+        arrayListOf<CapturedParamDesc>().apply {
+            val captureThis = closure.capturedOuterClassDescriptor
+            if (captureThis != null) {
+                val kotlinType = captureThis.defaultType
+                val type = typeMapper.mapType(kotlinType)
+                val descriptor = EnclosedValueDescriptor(
+                    AsmUtil.CAPTURED_THIS_FIELD, null,
+                    StackValue.field(type, lambdaClassType, AsmUtil.CAPTURED_THIS_FIELD, false, StackValue.LOCAL_0),
+                    type, kotlinType
+                )
+                add(getCapturedParamInfo(descriptor))
+            }
+
+            val capturedReceiver = closure.capturedReceiverFromOuterContext
+            if (capturedReceiver != null) {
+                val type = typeMapper.mapType(capturedReceiver).let {
+                    if (isBoundCallableReference) AsmUtil.boxType(it) else it
+                }
+
+                val fieldName = closure.getCapturedReceiverFieldName(typeMapper.bindingContext, languageVersionSettings)
+                val descriptor = EnclosedValueDescriptor(
+                    fieldName, null,
+                    StackValue.field(type, capturedReceiver, lambdaClassType, fieldName, false, StackValue.LOCAL_0),
+                    type, capturedReceiver
+                )
+                add(getCapturedParamInfo(descriptor))
+            }
+
+            closure.captureVariables.values.forEach { descriptor ->
+                add(getCapturedParamInfo(descriptor))
+            }
+        }
+    }
+
+    val isPropertyReference: Boolean
+        get() = propertyReferenceInfo != null
+
+    override fun isCapturedSuspend(desc: CapturedParamDesc): Boolean =
+        isCapturedSuspendLambda(closure, desc.fieldName, typeMapper.bindingContext)
+}
+
+class PsiDefaultLambda(
+    override val lambdaClassType: Type,
+    capturedArgs: Array<Type>,
+    private val parameterDescriptor: ValueParameterDescriptor,
+    offset: Int,
+    needReification: Boolean
+) : DefaultLambda(capturedArgs, parameterDescriptor.isCrossinline, offset, needReification) {
+    private lateinit var invokeMethodDescriptor: FunctionDescriptor
+
+    override val invokeMethodParameters: List<KotlinType?>
+        get() = invokeMethodDescriptor.explicitParameters.map { it.returnType }
+
+    override val invokeMethodReturnType: KotlinType?
+        get() = invokeMethodDescriptor.returnType
+
+    override fun mapAsmMethod(sourceCompiler: SourceCompilerForInline, isPropertyReference: Boolean): Method {
+        val substitutedDescriptor = parameterDescriptor.type.memberScope
+            .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
+            .single()
+        invokeMethodDescriptor = when {
+            // Property references: `(A) -> B` => `get(Any?): Any?`
+            isPropertyReference -> substitutedDescriptor.original
+            // Suspend function references: `suspend (A) -> B` => `invoke(A, Continuation<B>): Any?`
+            // TODO: default suspend lambdas are currently uninlinable
+            parameterDescriptor.type.isSuspendFunctionType ->
+                getOrCreateJvmSuspendFunctionView(
+                    substitutedDescriptor,
+                    sourceCompiler.state.languageVersionSettings.isReleaseCoroutines(),
+                    sourceCompiler.state.bindingContext
+                )
+            // Non-suspend function references and lambdas: `(A) -> B` => `invoke(A): B`
+            else -> substitutedDescriptor
+        }
+        return sourceCompiler.state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor).asmMethod
+    }
+}

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

@@ -48,7 +48,7 @@ interface SourceCompilerForInline {
 
     val lazySourceMapper: SourceMapper
 
-    fun generateLambdaBody(lambdaInfo: ExpressionLambda): SMAPAndMethodNode
+    fun generateLambdaBody(lambdaInfo: ExpressionLambda, reifiedTypeParameters: ReifiedTypeParametersUsages): SMAPAndMethodNode
 
     fun doCreateMethodNodeFromSource(
         callableDescriptor: FunctionDescriptor,
@@ -130,7 +130,7 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
     override val lazySourceMapper
         get() = codegen.parentCodegen.orCreateSourceMapper
 
-    override fun generateLambdaBody(lambdaInfo: ExpressionLambda): SMAPAndMethodNode {
+    override fun generateLambdaBody(lambdaInfo: ExpressionLambda, reifiedTypeParameters: ReifiedTypeParametersUsages): SMAPAndMethodNode {
         lambdaInfo as? PsiExpressionLambda ?: error("TODO")
         val invokeMethodDescriptor = lambdaInfo.invokeMethodDescriptor
         val jvmMethodSignature = state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor)

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt

@@ -2,11 +2,10 @@
  * Copyright 2010-2019 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.
  */
-@file:Suppress("JAVA_MODULE_DOES_NOT_EXPORT_PACKAGE")
+
 package org.jetbrains.kotlin.codegen.inline.coroutines
 
 import com.intellij.util.ArrayUtil
-import jdk.internal.org.objectweb.asm.Type
 import org.jetbrains.kotlin.codegen.ClassBuilder
 import org.jetbrains.kotlin.codegen.coroutines.*
 import org.jetbrains.kotlin.codegen.inline.*
@@ -20,6 +19,7 @@ import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.tree.*
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
@@ -287,4 +287,4 @@ private class CapturedLambdaInterpreter : BasicInterpreter(Opcodes.API_VERSION)
 
     override fun merge(v: BasicValue?, w: BasicValue?): BasicValue? =
         if (v is PossibleLambdaLoad && w is PossibleLambdaLoad && v.insn == w.insn) v else super.merge(v, w)
-}
+}

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

@@ -579,8 +579,8 @@ class InlineOnlySmapSkipper(codegen: BaseExpressionCodegen) {
         const val LOCAL_VARIABLE_INLINE_ARGUMENT_SYNTHETIC_LINE_NUMBER = 1
     }
 
-    fun onInlineLambdaStart(mv: MethodVisitor, info: LambdaInfo, smap: SourceMapper) {
-        val firstLine = info.node.node.instructions.asSequence().mapNotNull { it as? LineNumberNode }.firstOrNull()?.line ?: -1
+    fun onInlineLambdaStart(mv: MethodVisitor, lambda: MethodNode, smap: SourceMapper) {
+        val firstLine = lambda.instructions.asSequence().mapNotNull { it as? LineNumberNode }.firstOrNull()?.line ?: -1
         if (callLineNumber >= 0 && firstLine == callLineNumber) {
             // We want the debugger to be able to break both on the inline call itself, plus on each
             // invocation of the inline lambda passed to it. For that to happen there needs to be at least

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/PopBackwardPropagationTransformer.kt

@@ -17,12 +17,9 @@
 package org.jetbrains.kotlin.codegen.optimization.boxing
 
 import org.jetbrains.kotlin.codegen.optimization.OptimizationMethodVisitor
-import org.jetbrains.kotlin.codegen.optimization.common.debugText
 import org.jetbrains.kotlin.codegen.optimization.common.isLoadOperation
-import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
 import org.jetbrains.kotlin.codegen.optimization.fixStack.peekWords
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
-import org.jetbrains.kotlin.codegen.optimization.removeNodeGetNext
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.*
@@ -32,91 +29,66 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.SourceInterpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
 import java.util.*
 
+private typealias Transformation = (AbstractInsnNode) -> Unit
+
 class PopBackwardPropagationTransformer : MethodTransformer() {
     override fun transform(internalClassName: String, methodNode: MethodNode) {
         if (!OptimizationMethodVisitor.canBeOptimizedUsingSourceInterpreter(methodNode)) return
-        Transformer(methodNode).transform()
+        if (methodNode.instructions.any { it.isPop() || it.isPurePush() }) {
+            Transformer(methodNode).transform()
+        }
     }
 
     private class Transformer(val methodNode: MethodNode) {
-        private interface Transformation {
-            fun apply(insn: AbstractInsnNode)
-        }
-
-        private inline fun Transformation(crossinline body: (AbstractInsnNode) -> Unit): Transformation =
-            object : Transformation {
-                override fun apply(insn: AbstractInsnNode) {
-                    body(insn)
-                }
-            }
-
-        private val REPLACE_WITH_NOP = Transformation { insnList.set(it, createRemovableNopInsn()) }
-        private val REPLACE_WITH_POP1 = Transformation { insnList.set(it, InsnNode(Opcodes.POP)) }
-        private val REPLACE_WITH_POP2 = Transformation { insnList.set(it, InsnNode(Opcodes.POP2)) }
-        private val INSERT_POP1_AFTER = Transformation { insnList.insert(it, InsnNode(Opcodes.POP)) }
-        private val INSERT_POP2_AFTER = Transformation { insnList.insert(it, InsnNode(Opcodes.POP2)) }
+        private val REPLACE_WITH_NOP: Transformation = { insnList.set(it, InsnNode(Opcodes.NOP)) }
+        private val REPLACE_WITH_POP1: Transformation = { insnList.set(it, InsnNode(Opcodes.POP)) }
+        private val REPLACE_WITH_POP2: Transformation = { insnList.set(it, InsnNode(Opcodes.POP2)) }
+        private val INSERT_POP1_AFTER: Transformation = { insnList.insert(it, InsnNode(Opcodes.POP)) }
+        private val INSERT_POP2_AFTER: Transformation = { insnList.insert(it, InsnNode(Opcodes.POP2)) }
 
         private val insnList = methodNode.instructions
-
         private val insns = insnList.toArray()
 
         private val dontTouchInsnIndices = BitSet(insns.size)
-        private val transformations = hashMapOf<AbstractInsnNode, Transformation>()
-        private val removableNops = hashSetOf<InsnNode>()
-
-        private val frames by lazy { analyzeMethodBody() }
 
         fun transform() {
-            if (insns.none { it.isPop() || it.isPurePush() }) return
-
-            computeTransformations()
-            for ((insn, transformation) in transformations.entries) {
-                transformation.apply(insn)
-            }
-            postprocessNops()
-        }
-
-        private fun analyzeMethodBody(): Array<out Frame<SourceValue>?> {
-            val frames = Analyzer<SourceValue>(HazardsTrackingInterpreter()).analyze("fake", methodNode)
-
-            postprocessStackHazards(frames)
-
-            return frames
-        }
-
-        private fun postprocessStackHazards(frames: Array<out Frame<SourceValue>?>) {
-            val insns = methodNode.instructions.toArray()
-            for (i in frames.indices) {
+            val frames = Analyzer(HazardsTrackingInterpreter()).analyze("fake", methodNode)
+            for ((i, insn) in insns.withIndex()) {
                 val frame = frames[i] ?: continue
-                val insn = insns[i]
-
                 when (insn.opcode) {
-                    Opcodes.POP2 -> {
-                        val top2 = frame.peekWords(2) ?: throwIncorrectBytecode(insn, frame)
-                        top2.forEach { it.insns.markAsDontTouch() }
-                    }
-                    Opcodes.DUP_X1 -> {
-                        val top2 = frame.peekWords(1, 1) ?: throwIncorrectBytecode(insn, frame)
-                        top2.forEach { it.insns.markAsDontTouch() }
-                    }
-                    Opcodes.DUP2_X1 -> {
-                        val top3 = frame.peekWords(2, 1) ?: throwIncorrectBytecode(insn, frame)
-                        top3.forEach { it.insns.markAsDontTouch() }
-                    }
-                    Opcodes.DUP_X2 -> {
-                        val top3 = frame.peekWords(1, 2) ?: throwIncorrectBytecode(insn, frame)
-                        top3.forEach { it.insns.markAsDontTouch() }
-                    }
-                    Opcodes.DUP2_X2 -> {
-                        val top4 = frame.peekWords(2, 2) ?: throwIncorrectBytecode(insn, frame)
-                        top4.forEach { it.insns.markAsDontTouch() }
+                    Opcodes.POP ->
+                        frame.top()?.let { input ->
+                            // If this POP won't be removed, other POPs that touch the same values have to stay as well.
+                            if (input.insns.any { it.shouldKeep() } || input.longerWhenFusedWithPop()) {
+                                input.insns.markAsDontTouch()
+                            }
+                        }
+                    Opcodes.POP2 -> frame.peekWords(2)?.forEach { it.insns.markAsDontTouch() }
+                    Opcodes.DUP_X1 -> frame.peekWords(1, 1)?.forEach { it.insns.markAsDontTouch() }
+                    Opcodes.DUP2_X1 -> frame.peekWords(2, 1)?.forEach { it.insns.markAsDontTouch() }
+                    Opcodes.DUP_X2 -> frame.peekWords(1, 2)?.forEach { it.insns.markAsDontTouch() }
+                    Opcodes.DUP2_X2 -> frame.peekWords(2, 2)?.forEach { it.insns.markAsDontTouch() }
+                }
+            }
+
+            val transformations = hashMapOf<AbstractInsnNode, Transformation>()
+            for ((i, insn) in insns.withIndex()) {
+                val frame = frames[i] ?: continue
+                if (insn.opcode == Opcodes.POP) {
+                    val input = frame.top() ?: continue
+                    if (input.insns.none { it.shouldKeep() }) {
+                        transformations[insn] = REPLACE_WITH_NOP
+                        input.insns.forEach {
+                            if (it !in transformations) {
+                                transformations[it] = it.combineWithPop(frames, input.size)
+                            }
+                        }
                     }
                 }
             }
-        }
-
-        private fun throwIncorrectBytecode(insn: AbstractInsnNode?, frame: Frame<SourceValue>): Nothing {
-            throw AssertionError("Incorrect bytecode at ${methodNode.instructions.indexOf(insn)}: ${insn.debugText} $frame")
+            for ((insn, transformation) in transformations.entries) {
+                transformation(insn)
+            }
         }
 
         private inner class HazardsTrackingInterpreter : SourceInterpreter(Opcodes.API_VERSION) {
@@ -133,9 +105,7 @@ class PopBackwardPropagationTransformer : MethodTransformer() {
             }
 
             override fun unaryOperation(insn: AbstractInsnNode, value: SourceValue): SourceValue {
-                if (insn.opcode != Opcodes.CHECKCAST && !insn.isPrimitiveTypeConversion()) {
-                    value.insns.markAsDontTouch()
-                }
+                value.insns.markAsDontTouch()
                 return super.unaryOperation(insn, value)
             }
 
@@ -164,153 +134,48 @@ class PopBackwardPropagationTransformer : MethodTransformer() {
             }
         }
 
-
-        private fun computeTransformations() {
-            transformations.clear()
-
-            for (i in insns.indices) {
-                if (frames[i] == null) continue
-                val insn = insns[i]
-
-                if (insn.opcode == Opcodes.POP) {
-                    propagatePopBackwards(insn, 0)
-                }
-            }
-        }
-
-        private fun propagatePopBackwards(insn: AbstractInsnNode, poppedValueSize: Int) {
-            if (transformations.containsKey(insn)) return
-
+        private fun SourceValue.longerWhenFusedWithPop() = insns.fold(0) { x, insn ->
             when {
-                insn.opcode == Opcodes.POP -> {
-                    val inputTop = getInputTop(insn)
-                    val sources = inputTop.insns
-                    if (sources.all { !isDontTouch(it) } && sources.any { isTransformablePopOperand(it) }) {
-                        transformations[insn] = replaceWithNopTransformation()
-                        sources.forEach { propagatePopBackwards(it, inputTop.size) }
+                insn.isPurePush() -> x - 1
+                insn.isPrimitiveBoxing() || insn.isPrimitiveTypeConversion() -> x
+                else -> x + 1
+            }
+        } > 0
+
+        private fun AbstractInsnNode.combineWithPop(frames: Array<out Frame<SourceValue>?>, resultSize: Int): Transformation =
+            when {
+                isPurePush() -> REPLACE_WITH_NOP
+                isPrimitiveBoxing() || isPrimitiveTypeConversion() -> {
+                    val index = insnList.indexOf(this)
+                    val frame = frames[index] ?: throw AssertionError("dead instruction #$index used by non-dead instruction")
+                    val input = frame.top() ?: throw AssertionError("coercion instruction at #$index has no input")
+                    when (input.size) {
+                        1 -> REPLACE_WITH_POP1
+                        2 -> REPLACE_WITH_POP2
+                        else -> throw AssertionError("Unexpected pop value size: ${input.size}")
                     }
                 }
-
-                insn.opcode == Opcodes.CHECKCAST -> {
-                    val inputTop = getInputTop(insn)
-                    val sources = inputTop.insns
-                    val resultType = (insn as TypeInsnNode).desc
-                    if (sources.all { !isDontTouch(it) } && sources.any { isTransformableCheckcastOperand(it, resultType) }) {
-                        transformations[insn] = replaceWithNopTransformation()
-                        sources.forEach { propagatePopBackwards(it, inputTop.size) }
-                    } else {
-                        transformations[insn] = insertPopAfterTransformation(poppedValueSize)
+                else ->
+                    when (resultSize) {
+                        1 -> INSERT_POP1_AFTER
+                        2 -> INSERT_POP2_AFTER
+                        else -> throw AssertionError("Unexpected pop value size: $resultSize")
                     }
-                }
-
-                insn.isPrimitiveBoxing() -> {
-                    val boxedValueSize = getInputTop(insn).size
-                    transformations[insn] = replaceWithPopTransformation(boxedValueSize)
-                }
-
-                insn.isPurePush() -> {
-                    transformations[insn] = replaceWithNopTransformation()
-                }
-
-                insn.isPrimitiveTypeConversion() -> {
-                    val inputTop = getInputTop(insn)
-                    val sources = inputTop.insns
-                    if (sources.all { !isDontTouch(it) }) {
-                        transformations[insn] = replaceWithNopTransformation()
-                        sources.forEach { propagatePopBackwards(it, inputTop.size) }
-                    } else {
-                        transformations[insn] = replaceWithPopTransformation(poppedValueSize)
-                    }
-                }
-
-                else -> {
-                    transformations[insn] = insertPopAfterTransformation(poppedValueSize)
-                }
-            }
-        }
-
-        private fun postprocessNops() {
-            var node: AbstractInsnNode? = insnList.first
-            var hasRemovableNops = false
-            while (node != null) {
-                node = node.next
-                val begin = node ?: break
-                while (node != null && node !is LabelNode) {
-                    if (node in removableNops) {
-                        hasRemovableNops = true
-                    }
-                    node = node.next
-                }
-                val end = node
-                if (hasRemovableNops) {
-                    removeUnneededNopsInRange(begin, end)
-                }
-                hasRemovableNops = false
-            }
-        }
-
-        private fun removeUnneededNopsInRange(begin: AbstractInsnNode, end: AbstractInsnNode?) {
-            var node: AbstractInsnNode? = begin
-            var keepNop = true
-            while (node != null && node != end) {
-                if (node in removableNops && !keepNop) {
-                    node = insnList.removeNodeGetNext(node)
-                } else {
-                    if (node.isMeaningful) keepNop = false
-                    node = node.next
-                }
-            }
-        }
-
-        private fun replaceWithPopTransformation(size: Int): Transformation =
-            when (size) {
-                1 -> REPLACE_WITH_POP1
-                2 -> REPLACE_WITH_POP2
-                else -> throw AssertionError("Unexpected pop value size: $size")
             }
 
-        private fun insertPopAfterTransformation(size: Int): Transformation =
-            when (size) {
-                1 -> INSERT_POP1_AFTER
-                2 -> INSERT_POP2_AFTER
-                else -> throw AssertionError("Unexpected pop value size: $size")
-            }
-
-        private fun replaceWithNopTransformation(): Transformation =
-            REPLACE_WITH_NOP
-
-        private fun createRemovableNopInsn() =
-            InsnNode(Opcodes.NOP).apply { removableNops.add(this) }
-
-        private fun getInputTop(insn: AbstractInsnNode): SourceValue {
-            val i = insnList.indexOf(insn)
-            val frame = frames[i] ?: throw AssertionError("Unexpected dead instruction #$i")
-            return frame.top() ?: throw AssertionError("Instruction #$i has empty stack on input")
-        }
-
-        private fun isTransformableCheckcastOperand(it: AbstractInsnNode, resultType: String) =
-            it.isPrimitiveBoxing() && (it as MethodInsnNode).owner == resultType
-
-        private fun isTransformablePopOperand(insn: AbstractInsnNode) =
-            insn.opcode == Opcodes.CHECKCAST || insn.isPrimitiveBoxing() || insn.isPurePush()
-
-        private fun isDontTouch(insn: AbstractInsnNode) =
-            dontTouchInsnIndices[insnList.indexOf(insn)]
+        private fun AbstractInsnNode.shouldKeep() =
+            dontTouchInsnIndices[insnList.indexOf(this)]
     }
-
 }
 
 fun AbstractInsnNode.isPurePush() =
-    isLoadOperation() ||
-            opcode in Opcodes.ACONST_NULL..Opcodes.LDC + 2 ||
-            isUnitInstance()
+    isLoadOperation() || opcode in Opcodes.ACONST_NULL..Opcodes.LDC + 2 || isUnitInstance()
 
 fun AbstractInsnNode.isPop() =
     opcode == Opcodes.POP || opcode == Opcodes.POP2
 
 fun AbstractInsnNode.isUnitInstance() =
-    opcode == Opcodes.GETSTATIC &&
-            this is FieldInsnNode && owner == "kotlin/Unit" && name == "INSTANCE"
+    opcode == Opcodes.GETSTATIC && this is FieldInsnNode && owner == "kotlin/Unit" && name == "INSTANCE"
 
 fun AbstractInsnNode.isPrimitiveTypeConversion() =
     opcode in Opcodes.I2L..Opcodes.I2S

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt

@@ -39,7 +39,7 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt
 
     override fun transform(internalClassName: String, node: MethodNode) {
         val interpreter = RedundantBoxingInterpreter(node.instructions, generationState)
-        val frames = MethodTransformer.analyze(internalClassName, node, interpreter)
+        val frames = analyze(internalClassName, node, interpreter)
 
         interpretPopInstructionsForBoxedValues(interpreter, node, frames)
 
@@ -168,7 +168,8 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt
             val frame = frames[i] ?: continue
             val insn = insnList[i]
             if ((insn.opcode == Opcodes.ASTORE || insn.opcode == Opcodes.ALOAD) &&
-                (insn as VarInsnNode).`var` == localVariableNode.index) {
+                (insn as VarInsnNode).`var` == localVariableNode.index
+            ) {
                 if (insn.getOpcode() == Opcodes.ASTORE) {
                     values.add(frame.top()!!)
                 } else {

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

@@ -27,19 +27,19 @@ import org.jetbrains.org.objectweb.asm.commons.Method
 import java.util.*
 
 private val EXTERNAL_SOURCES_KINDS = arrayOf(
-        JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL,
-        JvmDeclarationOriginKind.DEFAULT_IMPL_DELEGATION_TO_SUPERINTERFACE_DEFAULT_IMPL,
-        JvmDeclarationOriginKind.DELEGATION,
-        JvmDeclarationOriginKind.BRIDGE
+    JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL,
+    JvmDeclarationOriginKind.DEFAULT_IMPL_DELEGATION_TO_SUPERINTERFACE_DEFAULT_IMPL,
+    JvmDeclarationOriginKind.DELEGATION,
+    JvmDeclarationOriginKind.BRIDGE
 )
 
 private val PREDEFINED_SIGNATURES = listOf(
-        "getClass()Ljava/lang/Class;",
-        "notify()V",
-        "notifyAll()V",
-        "wait()V",
-        "wait(J)V",
-        "wait(JI)V"
+    "getClass()Ljava/lang/Class;",
+    "notify()V",
+    "notifyAll()V",
+    "wait()V",
+    "wait(J)V",
+    "wait(JI)V"
 ).map { signature ->
     RawSignature(signature.substringBefore('('), signature.substring(signature.indexOf('(')), MemberKind.METHOD)
 }
@@ -77,8 +77,7 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
         val elements = LinkedHashSet<PsiElement>()
         if (noOwnImplementations) {
             elements.addIfNotNull(data.classOrigin.element)
-        }
-        else {
+        } else {
             for (origin in data.signatureOrigins) {
                 var element = origin.element
 
@@ -96,9 +95,9 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
     }
 
     override fun onClassDone(
-            classOrigin: JvmDeclarationOrigin,
-            classInternalName: String,
-            signatures: MultiMap<RawSignature, JvmDeclarationOrigin>
+        classOrigin: JvmDeclarationOrigin,
+        classInternalName: String,
+        signatures: MultiMap<RawSignature, JvmDeclarationOrigin>
     ) {
         reportDiagnosticsTasks.add {
             reportClashingWithPredefinedSignatures(classOrigin, classInternalName, signatures)
@@ -107,9 +106,9 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
     }
 
     private fun reportClashingWithPredefinedSignatures(
-            classOrigin: JvmDeclarationOrigin,
-            classInternalName: String,
-            signatures: MultiMap<RawSignature, JvmDeclarationOrigin>
+        classOrigin: JvmDeclarationOrigin,
+        classInternalName: String,
+        signatures: MultiMap<RawSignature, JvmDeclarationOrigin>
     ) {
         for (predefinedSignature in PREDEFINED_SIGNATURES) {
             if (!signatures.containsKey(predefinedSignature)) continue
@@ -122,9 +121,9 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
     }
 
     private fun reportClashingSignaturesInHierarchy(
-            classOrigin: JvmDeclarationOrigin,
-            classInternalName: String,
-            signatures: MultiMap<RawSignature, JvmDeclarationOrigin>
+        classOrigin: JvmDeclarationOrigin,
+        classInternalName: String,
+        signatures: MultiMap<RawSignature, JvmDeclarationOrigin>
     ) {
         val descriptor = classOrigin.descriptor
         if (descriptor !is ClassDescriptor) return
@@ -141,9 +140,7 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
         for ((rawSignature, origins) in groupedBySignature.entrySet()) {
             if (origins.size <= 1) continue
 
-            val diagnostic = computeDiagnosticToReport(classOrigin, classInternalName, rawSignature, origins)
-
-            when (diagnostic) {
+            when (val diagnostic = computeDiagnosticToReport(classOrigin, classInternalName, rawSignature, origins)) {
                 is ConflictingDeclarationError.AccidentalOverride -> {
                     diagnostics.report(ErrorsJvm.ACCIDENTAL_OVERRIDE.on(diagnostic.element, diagnostic.data))
                 }
@@ -156,16 +153,17 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
 
     private sealed class ConflictingDeclarationError(val element: PsiElement, val data: ConflictingJvmDeclarationsData) {
         class AccidentalOverride(element: PsiElement, data: ConflictingJvmDeclarationsData) :
-                ConflictingDeclarationError(element, data)
+            ConflictingDeclarationError(element, data)
+
         class ConflictingInheritedJvmDeclarations(element: PsiElement, data: ConflictingJvmDeclarationsData) :
-                ConflictingDeclarationError(element, data)
+            ConflictingDeclarationError(element, data)
     }
 
     private fun computeDiagnosticToReport(
-            classOrigin: JvmDeclarationOrigin,
-            classInternalName: String,
-            rawSignature: RawSignature,
-            origins: Collection<JvmDeclarationOrigin>
+        classOrigin: JvmDeclarationOrigin,
+        classInternalName: String,
+        rawSignature: RawSignature,
+        origins: Collection<JvmDeclarationOrigin>
     ): ConflictingDeclarationError? {
         var memberElement: PsiElement? = null
         var ownNonFakeCount = 0
@@ -211,19 +209,17 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
             if (member is PropertyDescriptor) {
                 processMember(member.getter)
                 processMember(member.setter)
-            }
-            else if (member is FunctionDescriptor) {
+            } else if (member is FunctionDescriptor) {
                 val signatures =
-                        if (member.kind == FAKE_OVERRIDE)
-                            member.overriddenTreeUniqueAsSequence(useOriginal = true)
-                                    // drop the root (itself)
-                                    .drop(1)
-                                    .mapTo(HashSet()) { it.asRawSignature() }
-                        else
-                            setOf(member.asRawSignature())
+                    if (member.kind == FAKE_OVERRIDE)
+                        member.overriddenTreeUniqueAsSequence(useOriginal = true)
+                            // drop the root (itself)
+                            .drop(1)
+                            .mapTo(HashSet()) { it.asRawSignature() }
+                    else
+                        setOf(member.asRawSignature())
 
-                signatures.forEach {
-                    rawSignature ->
+                signatures.forEach { rawSignature ->
                     groupedBySignature.putValue(rawSignature, OtherOrigin(member))
                 }
             }
@@ -232,10 +228,10 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
         descriptor.defaultType.memberScope.getContributedDescriptors().forEach(::processMember)
         descriptor.getParentJavaStaticClassScope()?.run {
             getContributedDescriptors(DescriptorKindFilter.FUNCTIONS)
-                    .filter {
-                        it is FunctionDescriptor && DescriptorVisibilities.isVisibleIgnoringReceiver(it, descriptor)
-                    }
-                    .forEach(::processMember)
+                .filter {
+                    it is FunctionDescriptor && DescriptorVisibilities.isVisibleIgnoringReceiver(it, descriptor)
+                }
+                .forEach(::processMember)
         }
 
         return groupedBySignature

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

@@ -245,6 +245,7 @@ class GenerationState private constructor(
         this.moduleName,
         languageVersionSettings,
         useOldManglingSchemeForFunctionsWithInlineClassesInSignatures,
+        IncompatibleClassTracker.DoNothing,
         target,
         isIrBackend
     )
@@ -330,7 +331,7 @@ class GenerationState private constructor(
 
     val typeApproximator: TypeApproximator? =
         if (languageVersionSettings.supportsFeature(LanguageFeature.NewInference))
-            TypeApproximator(module.builtIns)
+            TypeApproximator(module.builtIns, languageVersionSettings)
         else
             null
 

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

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.codegen.state
+
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
+
+interface IncompatibleClassTracker {
+    fun record(binaryClass: KotlinJvmBinaryClass)
+
+    object DoNothing : IncompatibleClassTracker {
+        override fun record(binaryClass: KotlinJvmBinaryClass) {
+        }
+    }
+}

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

@@ -87,6 +87,9 @@ class KotlinTypeMapper @JvmOverloads constructor(
     private val moduleName: String,
     val languageVersionSettings: LanguageVersionSettings,
     private val useOldInlineClassesManglingScheme: Boolean,
+    // temporary returned to preserve binary compatibility with Dagger in IDE
+    // https://android.googlesource.com/platform/tools/adt/idea/+/refs/heads/mirror-goog-studio-master-dev/dagger/src/com/android/tools/idea/dagger/DaggerAnnotatedElementsSearch.kt
+    private val incompatibleClassTracker: IncompatibleClassTracker = IncompatibleClassTracker.DoNothing,
     val jvmTarget: JvmTarget = JvmTarget.DEFAULT,
     private val isIrBackend: Boolean = false,
     private val typePreprocessor: ((KotlinType) -> KotlinType?)? = null,

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

@@ -87,11 +87,6 @@ fun CallableMemberDescriptor.createTypeParameterWithNewName(
     return newDescriptor
 }
 
-fun KotlinType.removeExternalProjections(): KotlinType {
-    val newArguments = arguments.map { TypeProjectionImpl(Variance.INVARIANT, it.type) }
-    return replace(newArguments)
-}
-
 fun isInlineClassConstructorAccessor(descriptor: FunctionDescriptor): Boolean =
     descriptor is AccessorForConstructorDescriptor &&
             descriptor.calleeDescriptor.constructedClass.isInlineClass()

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

@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.cli.common
 
-import com.intellij.util.LineSeparator
-import java.util.*
-
-enum class CompilerSystemProperties(val property: String) {
+/**
+ * @param alwaysDirectAccess Gradle has a list of properties that can be read without declaring, see https://github.com/gradle/gradle/blob/f191a61cec61afe308f2b45184cb303d32706a6f/subprojects/configuration-cache/src/main/kotlin/org/gradle/configurationcache/SystemPropertyAccessListener.kt#L32
+ */
+enum class CompilerSystemProperties(val property: String, val alwaysDirectAccess: Boolean = false) {
     COMPILE_DAEMON_ENABLED_PROPERTY("kotlin.daemon.enabled"),
     COMPILE_DAEMON_JVM_OPTIONS_PROPERTY("kotlin.daemon.jvm.options"),
     COMPILE_DAEMON_OPTIONS_PROPERTY("kotlin.daemon.options"),
@@ -36,24 +36,31 @@ enum class CompilerSystemProperties(val property: String) {
     KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY("kotlin.environment.keepalive"),
     COMPILE_DAEMON_CUSTOM_RUN_FILES_PATH_FOR_TESTS("kotlin.daemon.custom.run.files.path.for.tests"),
     KOTLIN_COLORS_ENABLED_PROPERTY("kotlin.colors.enabled"),
-    OS_NAME("os.name"),
+    OS_NAME("os.name", alwaysDirectAccess = true),
     TMP_DIR("java.io.tmpdir"),
-    USER_HOME("user.home"),
-    JAVA_VERSION("java.specification.version"),
-    JAVA_HOME("java.home"),
-    JAVA_CLASS_PATH("java.class.path"),
+    USER_HOME("user.home", alwaysDirectAccess = true),
+    JAVA_VERSION("java.specification.version", alwaysDirectAccess = true),
+    JAVA_HOME("java.home", alwaysDirectAccess = true),
+    JAVA_CLASS_PATH("java.class.path", alwaysDirectAccess = true),
     ;
 
-    var value
-        get() = (systemPropertyGetter ?: System::getProperty)(property)
+    private fun <T> getProperFunction(custom: T?, default: T): T {
+        if (alwaysDirectAccess) return default
+        return custom ?: default
+    }
+
+    var value: String?
+        get() {
+            return getProperFunction(systemPropertyGetter, System::getProperty)(property)
+        }
         set(value) {
-            (systemPropertySetter ?: System::setProperty)(property, value!!)
+            getProperFunction(systemPropertySetter, System::setProperty)(property, value!!)
         }
 
     val safeValue
         get() = value ?: error("No value for $property system property")
 
-    fun clear(): String? = (systemPropertyCleaner ?: System::clearProperty)(property)
+    fun clear(): String? = getProperFunction(systemPropertyCleaner, System::clearProperty)(property)
 
     companion object {
         var systemPropertyGetter: ((String) -> String?)? = null

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

@@ -377,7 +377,7 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
 default: `indy-with-constants` for JVM target 9 or greater, `inline` otherwise"""
 
     )
-    var stringConcat: String? by NullableStringFreezableVar(JvmStringConcat.INLINE.description)
+    var stringConcat: String? by NullableStringFreezableVar(null)
 
     @Argument(
         value = "-Xsam-conversions",

compiler/cli/cli-js-klib/build.gradle.kts

@@ -1,20 +0,0 @@
-plugins {
-    kotlin("jvm")
-    id("jps-compatible")
-}
-
-dependencies {
-    compile(project(":compiler:cli"))
-    compile(project(":compiler:ir.serialization.js"))
-    compileOnly(project(":compiler:ir.tree.persistent"))
-    runtimeOnly(project(":kotlin-reflect"))
-    if (Platform[193].orLower()) {
-        compile(intellijDep()) { includeJars("picocontainer", rootProject = rootProject) }
-    }
-    compile(intellijDep()) { includeJars("trove4j", "guava", "jdom", rootProject = rootProject) }
-    compile(intellijCoreDep()) { includeJars("intellij-core") }
-}
-
-sourceSets {
-    "main" { projectDefault() }
-}

compiler/cli/cli-js-klib/src/GenerateJsIrKlib.kt

@@ -1,153 +0,0 @@
-/*
- * Copyright 2010-2019 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.
- */
-
-// Internal CLI for building JS IR libraries
-
-package org.jetbrains.kotlin.ir.backend.js
-
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.vfs.StandardFileSystems
-import com.intellij.openapi.vfs.VirtualFileManager
-import com.intellij.psi.PsiManager
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.messages.*
-import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
-import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.multiplatform.isCommonSource
-import org.jetbrains.kotlin.serialization.js.ModuleKind
-import org.jetbrains.kotlin.util.Logger
-import java.io.File
-
-fun buildConfiguration(environment: KotlinCoreEnvironment, moduleName: String): CompilerConfiguration {
-    val runtimeConfiguration = environment.configuration.copy()
-    runtimeConfiguration.put(CommonConfigurationKeys.MODULE_NAME, moduleName)
-    runtimeConfiguration.put(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
-    runtimeConfiguration.put(
-        CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY,
-        PrintingMessageCollector(System.err, MessageRenderer.PLAIN_RELATIVE_PATHS, false)
-    )
-
-    runtimeConfiguration.languageVersionSettings = LanguageVersionSettingsImpl(
-        LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE,
-        specificFeatures = mapOf(
-            LanguageFeature.AllowContractsForCustomFunctions to LanguageFeature.State.ENABLED,
-            LanguageFeature.MultiPlatformProjects to LanguageFeature.State.ENABLED
-        ),
-        analysisFlags = mapOf(
-            AnalysisFlags.useExperimental to listOf(
-                "kotlin.RequiresOptIn",
-                "kotlin.contracts.ExperimentalContracts",
-                "kotlin.ExperimentalMultiplatform",
-            ),
-            AnalysisFlags.allowResultReturnType to true
-        )
-    )
-
-    return runtimeConfiguration
-}
-
-@Suppress("RedundantSamConstructor")
-private val environment =
-    KotlinCoreEnvironment.createForProduction(Disposable { }, CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES)
-
-fun createPsiFile(fileName: String): KtFile {
-    val psiManager = PsiManager.getInstance(environment.project)
-    val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL)
-
-    val file = fileSystem.findFileByPath(fileName) ?: error("File not found: $fileName")
-
-    return psiManager.findFile(file) as KtFile
-}
-
-
-fun buildKLib(
-    moduleName: String,
-    sources: List<String>,
-    outputPath: String,
-    allDependencies: KotlinLibraryResolveResult,
-    commonSources: List<String>
-) {
-    val configuration = buildConfiguration(environment, moduleName)
-    generateKLib(
-        project = environment.project,
-        files = sources.map { source ->
-            val file = createPsiFile(source)
-            if (source in commonSources) {
-                file.isCommonSource = true
-            }
-            file
-        },
-        analyzer = AnalyzerWithCompilerReport(configuration),
-        configuration = configuration,
-        allDependencies = allDependencies,
-        friendDependencies = emptyList(),
-        irFactory = PersistentIrFactory(), // TODO: IrFactoryImpl?
-        outputKlibPath = outputPath,
-        nopack = true
-    )
-}
-
-private fun listOfKtFilesFrom(paths: List<String>): List<String> {
-    val currentDir = File("")
-    return paths.flatMap { path ->
-        File(path)
-            .walkTopDown()
-            .filter { it.extension == "kt" }
-            .map { it.relativeToOrSelf(currentDir).path }
-            .asIterable()
-    }.distinct()
-}
-
-fun main(args: Array<String>) {
-    val inputFiles = mutableListOf<String>()
-    var outputPath: String? = null
-    val dependencies = mutableListOf<String>()
-    val commonSources = mutableListOf<String>()
-    var moduleName: String? = null
-
-    var index = 0
-    while (index < args.size) {
-        val arg = args[index++]
-
-        when (arg) {
-            "-n" -> moduleName = args[index++]
-            "-o" -> outputPath = args[index++]
-            "-d" -> dependencies += args[index++]
-            "-c" -> commonSources += args[index++]
-            else -> inputFiles += arg
-        }
-    }
-
-    if (outputPath == null) {
-        error("Please set path to .klm file: `-o some/dir/module-name.klm`")
-    }
-
-    if (moduleName == null) {
-        error("Please set module name: `-n module-name`")
-    }
-
-    val resolvedLibraries = jsResolveLibraries(
-        dependencies, emptyList(), messageCollectorLogger(MessageCollector.NONE)
-    )
-
-    buildKLib(moduleName, listOfKtFilesFrom(inputFiles), outputPath, resolvedLibraries, listOfKtFilesFrom(commonSources))
-}
-
-// Copied here from `K2JsIrCompiler` instead of reusing in order to avoid circular dependencies between Gradle tasks
-private fun messageCollectorLogger(collector: MessageCollector) = object : Logger {
-    override fun warning(message: String)= collector.report(CompilerMessageSeverity.STRONG_WARNING, message)
-    override fun error(message: String) = collector.report(CompilerMessageSeverity.ERROR, message)
-    override fun log(message: String) = collector.report(CompilerMessageSeverity.LOGGING, message)
-    override fun fatal(message: String): Nothing {
-        collector.report(CompilerMessageSeverity.ERROR, message)
-        (collector as? GroupingMessageCollector)?.flush()
-        kotlin.error(message)
-    }
-}

compiler/cli/cli-js/build.gradle.kts

@@ -11,6 +11,7 @@ dependencies {
     compile(project(":compiler:backend-common"))
     compile(project(":compiler:ir.backend.common"))
     compile(project(":compiler:ir.serialization.js"))
+    compile(project(":compiler:ir.tree.impl"))
     compile(project(":compiler:backend.js"))
     compile(project(":compiler:backend.wasm"))
     compile(project(":js:js.translator"))

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -17,7 +17,8 @@ import org.jetbrains.kotlin.cli.common.ExitCode.COMPILATION_ERROR
 import org.jetbrains.kotlin.cli.common.ExitCode.OK
 import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants
-import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.*
+import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.DCE_RUNTIME_DIAGNOSTIC_EXCEPTION
+import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.DCE_RUNTIME_DIAGNOSTIC_LOG
 import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.extensions.ScriptEvaluationExtension
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
@@ -38,6 +39,7 @@ import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalNextRoundChecker
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
 import org.jetbrains.kotlin.js.config.*
 import org.jetbrains.kotlin.library.KLIB_FILE_EXTENSION
@@ -230,6 +232,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     AnalyzerWithCompilerReport(config.configuration),
                     config.configuration,
                     PhaseConfig(wasmPhases),
+                    IrFactoryImpl,
                     allDependencies = resolvedLibraries,
                     friendDependencies = friendDependencies,
                     exportedDeclarations = setOf(FqName("main"))
@@ -256,6 +259,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                 AnalyzerWithCompilerReport(config.configuration),
                 config.configuration,
                 phaseConfig,
+                if (arguments.irDceDriven) PersistentIrFactory() else IrFactoryImpl,
                 allDependencies = resolvedLibraries,
                 friendDependencies = friendDependencies,
                 mainArguments = mainCallArguments,

compiler/cli/src/com/intellij/DynamicBundle.java

@@ -4,7 +4,6 @@ package com.intellij;
 import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.extensions.AbstractExtensionPointBean;
 import com.intellij.openapi.extensions.ExtensionPointName;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.util.ReflectionUtil;
@@ -93,7 +92,8 @@ public abstract class DynamicBundle extends AbstractBundle {
   public static final DynamicBundle INSTANCE = new DynamicBundle("") {
   };
 
-  public static class LanguageBundleEP extends AbstractExtensionPointBean {
+  @SuppressWarnings("deprecation")
+  public static class LanguageBundleEP extends com.intellij.openapi.extensions.AbstractExtensionPointBean {
     public static final ExtensionPointName<LanguageBundleEP> EP_NAME = ExtensionPointName.create("com.intellij.languageBundle");
   }
 

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

@@ -21,7 +21,7 @@ class CodeAnalysisMeasurement(private val lines: Int?, val milliseconds: Long) :
     override fun render(): String = formatMeasurement("ANALYZE", milliseconds, lines)
 }
 
-class CodeGenerationMeasurement(private val lines: Int?, private val milliseconds: Long) : PerformanceMeasurement {
+class CodeGenerationMeasurement(private val lines: Int?, val milliseconds: Long) : PerformanceMeasurement {
     override fun render(): String = formatMeasurement("GENERATE", milliseconds, lines)
 }
 

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

@@ -22,6 +22,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiJavaModule
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.light.LightJavaModule
+import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
@@ -37,6 +38,7 @@ import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleFinder
 import org.jetbrains.kotlin.cli.jvm.modules.JavaModuleGraph
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.isValidJavaFqName
+import org.jetbrains.kotlin.resolve.jvm.KotlinCliJavaFileManager
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModule
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleInfo
 import org.jetbrains.kotlin.resolve.jvm.modules.KOTLIN_STDLIB_MODULE_NAME
@@ -52,10 +54,13 @@ class ClasspathRootsResolver(
     private val contentRootToVirtualFile: (JvmContentRoot) -> VirtualFile?,
     private val javaModuleFinder: CliJavaModuleFinder,
     private val requireStdlibModule: Boolean,
-    private val outputDirectory: VirtualFile?
+    private val outputDirectory: VirtualFile?,
+    private val javaFileManager: KotlinCliJavaFileManager
 ) {
     val javaModuleGraph = JavaModuleGraph(javaModuleFinder)
 
+    private val searchScope = GlobalSearchScope.allScope(psiManager.project)
+
     data class RootsAndModules(val roots: List<JavaRoot>, val modules: List<JavaModule>)
 
     private data class RootWithPrefix(val root: VirtualFile, val packagePrefix: String?)
@@ -160,7 +165,7 @@ class ClasspathRootsResolver(
                 }
 
         if (moduleInfoFile != null) {
-            val moduleInfo = JavaModuleInfo.read(moduleInfoFile) ?: return null
+            val moduleInfo = JavaModuleInfo.read(moduleInfoFile, javaFileManager, searchScope) ?: return null
             return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(root, isBinary = true)), moduleInfoFile)
         }
 

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

@@ -35,6 +35,10 @@ class CliVirtualFileFinder(
     override fun findVirtualFileWithHeader(classId: ClassId): VirtualFile? =
         findBinaryClass(classId, classId.relativeClassName.asString().replace('.', '$') + ".class")
 
+    override fun findSourceOrBinaryVirtualFile(classId: ClassId) =
+        findBinaryClass(classId, classId.relativeClassName.asString().replace('.', '$') + ".class")
+            ?: findSourceClass(classId, classId.relativeClassName.asString() + ".java")
+
     override fun findMetadata(classId: ClassId): InputStream? {
         assert(!classId.isNestedClass) { "Nested classes are not supported here: $classId" }
 
@@ -61,8 +65,11 @@ class CliVirtualFileFinder(
         return findBinaryClass(classId, BuiltInSerializerProtocol.getBuiltInsFileName(packageFqName))?.inputStream
     }
 
-    private fun findBinaryClass(classId: ClassId, fileName: String): VirtualFile? =
-        index.findClass(classId, acceptedRootTypes = JavaRoot.OnlyBinary) { dir, _ ->
+    private fun findClass(classId: ClassId, fileName: String, rootType: Set<JavaRoot.RootType>) =
+        index.findClass(classId, acceptedRootTypes = rootType) { dir, _ ->
             dir.findChild(fileName)?.takeIf(VirtualFile::isValid)
         }?.takeIf { it in scope }
+
+    private fun findBinaryClass(classId: ClassId, fileName: String) = findClass(classId, fileName, JavaRoot.OnlyBinary)
+    private fun findSourceClass(classId: ClassId, fileName: String) = findClass(classId, fileName, JavaRoot.OnlySource)
 }

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

@@ -82,7 +82,7 @@ class KotlinCliJavaFileManagerImpl(private val myPsiManager: PsiManager) : CoreJ
     private val binaryCache: MutableMap<ClassId, JavaClass?> = THashMap()
     private val signatureParsingComponent = BinaryClassSignatureParser()
 
-    fun findClass(classId: ClassId, searchScope: GlobalSearchScope): JavaClass? = findClass(JavaClassFinder.Request(classId), searchScope)
+    fun findClass(classId: ClassId, searchScope: GlobalSearchScope) = findClass(JavaClassFinder.Request(classId), searchScope)
 
     override fun findClass(request: JavaClassFinder.Request, searchScope: GlobalSearchScope): JavaClass? {
         val (classId, classFileContentFromRequest, outerClassFromRequest) = request

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

@@ -33,13 +33,11 @@ import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.extensions.ExtensionsArea
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.LanguageLevelProjectExtension
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.io.FileUtilRt
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.*
 import com.intellij.openapi.vfs.impl.ZipHandler
-import com.intellij.pom.java.LanguageLevel
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.JavaClassSupersImpl
@@ -94,6 +92,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
@@ -191,11 +190,17 @@ class KotlinCoreEnvironment private constructor(
 
         sourceFiles.sortBy { it.virtualFile.path }
 
+        val javaFileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl
+
         val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME)
         val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL)
-        val javaModuleFinder = CliJavaModuleFinder(jdkHome?.path?.let { path ->
-            jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
-        })
+        val javaModuleFinder = CliJavaModuleFinder(
+            jdkHome?.path?.let { path ->
+                jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
+            },
+            javaFileManager,
+            project
+        )
 
         val outputDirectory =
             configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory()
@@ -208,7 +213,8 @@ class KotlinCoreEnvironment private constructor(
             this::contentRootToVirtualFile,
             javaModuleFinder,
             !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE),
-            outputDirectory?.let(this::findLocalFile)
+            outputDirectory?.let(this::findLocalFile),
+            javaFileManager
         )
 
         val (initialRoots, javaModules) =
@@ -232,7 +238,7 @@ class KotlinCoreEnvironment private constructor(
             updateClasspathFromRootsIndex(this)
         }
 
-        (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize(
+        javaFileManager.initialize(
             rootsIndex,
             packagePartProviders,
             SingleJavaFileRootsIndex(singleJavaFileRoots),
@@ -241,7 +247,7 @@ class KotlinCoreEnvironment private constructor(
 
         project.registerService(
             JavaModuleResolver::class.java,
-            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList())
+            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList(), project)
         )
 
         val finderFactory = CliVirtualFileFinderFactory(rootsIndex)
@@ -577,6 +583,7 @@ class KotlinCoreEnvironment private constructor(
         fun registerPluginExtensionPoints(project: MockProject) {
             ExpressionCodegenExtension.registerExtensionPoint(project)
             SyntheticResolveExtension.registerExtensionPoint(project)
+            SyntheticJavaResolveExtension.registerExtensionPoint(project)
             ClassBuilderInterceptorExtension.registerExtensionPoint(project)
             AnalysisHandlerExtension.registerExtensionPoint(project)
             PackageFragmentProviderExtension.registerExtensionPoint(project)

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

@@ -78,10 +78,7 @@ import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
-import org.jetbrains.kotlin.config.APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.extensions.*
 import org.jetbrains.kotlin.extensions.internal.CandidateInterceptor
 import org.jetbrains.kotlin.extensions.internal.TypeResolutionInterceptor
@@ -96,6 +93,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
@@ -192,11 +190,16 @@ class KotlinCoreEnvironment private constructor(
 
         sourceFiles.sortBy { it.virtualFile.path }
 
+        val javaFileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl
+
         val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME)
         val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL)
-        val javaModuleFinder = CliJavaModuleFinder(jdkHome?.path?.let { path ->
-            jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
-        })
+        val javaModuleFinder = CliJavaModuleFinder(
+            jdkHome?.path?.let { path ->
+                jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
+            },
+            javaFileManager
+        )
 
         val outputDirectory =
             configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory()
@@ -209,7 +212,8 @@ class KotlinCoreEnvironment private constructor(
             this::contentRootToVirtualFile,
             javaModuleFinder,
             !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE),
-            outputDirectory?.let(this::findLocalFile)
+            outputDirectory?.let(this::findLocalFile),
+            javaFileManager
         )
 
         val (initialRoots, javaModules) =
@@ -233,7 +237,7 @@ class KotlinCoreEnvironment private constructor(
             updateClasspathFromRootsIndex(this)
         }
 
-        (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize(
+        javaFileManager.initialize(
             rootsIndex,
             packagePartProviders,
             SingleJavaFileRootsIndex(singleJavaFileRoots),
@@ -242,7 +246,7 @@ class KotlinCoreEnvironment private constructor(
 
         project.registerService(
             JavaModuleResolver::class.java,
-            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList())
+            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList(), project)
         )
 
         val finderFactory = CliVirtualFileFinderFactory(rootsIndex)
@@ -569,6 +573,7 @@ class KotlinCoreEnvironment private constructor(
         fun registerPluginExtensionPoints(project: MockProject) {
             ExpressionCodegenExtension.registerExtensionPoint(project)
             SyntheticResolveExtension.registerExtensionPoint(project)
+            SyntheticJavaResolveExtension.registerExtensionPoint(project)
             ClassBuilderInterceptorExtension.registerExtensionPoint(project)
             AnalysisHandlerExtension.registerExtensionPoint(project)
             PackageFragmentProviderExtension.registerExtensionPoint(project)

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

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.cli.jvm.compiler
 
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.*
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiJavaModule
@@ -36,8 +37,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.checkKotlinPackageUsage
 import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.OUTPUT
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.WARNING
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.common.output.writeAll
@@ -304,6 +304,11 @@ object KotlinToJVMBytecodeCompiler {
         val project = environment.project
         val performanceManager = environment.configuration.get(CLIConfigurationKeys.PERF_MANAGER)
 
+        environment.messageCollector.report(
+            STRONG_WARNING,
+            "ATTENTION!\n This build uses in-dev FIR: \n  -Xuse-fir"
+        )
+
         PsiElementFinder.EP.getPoint(project).unregisterExtension(JavaElementFinder::class.java)
 
         val projectConfiguration = environment.configuration
@@ -427,6 +432,9 @@ object KotlinToJVMBytecodeCompiler {
             performanceManager?.notifyGenerationFinished()
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
             outputs[module] = generationState
+
+            PsiElementFinder.EP.getPoint(project).unregisterExtension(JavaElementFinder::class.java)
+            Disposer.dispose(environment.project)
         }
 
         val mainClassFqName: FqName? =

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt

@@ -49,6 +49,9 @@ fun CompilerConfiguration.addJvmSdkRoots(files: List<File>) {
 val CompilerConfiguration.jvmClasspathRoots: List<File>
     get() = getList(CLIConfigurationKeys.CONTENT_ROOTS).filterIsInstance<JvmClasspathRoot>().map(JvmContentRoot::file)
 
+val CompilerConfiguration.jvmModularRoots: List<File>
+    get() = getList(CLIConfigurationKeys.CONTENT_ROOTS).filterIsInstance<JvmModulePathRoot>().map(JvmContentRoot::file)
+
 @JvmOverloads
 fun CompilerConfiguration.addJavaSourceRoot(file: File, packagePrefix: String? = null) {
     add(CLIConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(file, packagePrefix))

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/index/JvmDependenciesIndex.kt

@@ -45,6 +45,7 @@ data class JavaRoot(val file: VirtualFile, val type: RootType, val prefixFqName:
 
     companion object RootTypes {
         val OnlyBinary: Set<RootType> = EnumSet.of(RootType.BINARY)
+        val OnlySource: Set<RootType> = EnumSet.of(RootType.SOURCE)
         val SourceAndBinary: Set<RootType> = EnumSet.of(RootType.BINARY, RootType.SOURCE)
     }
 }

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

@@ -54,19 +54,20 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
         }
     }
 
-    if (arguments.stringConcat != null) {
-        val runtimeStringConcat = JvmStringConcat.fromString(arguments.stringConcat!!)
+    val stringConcat = arguments.stringConcat
+    if (stringConcat != null) {
+        val runtimeStringConcat = JvmStringConcat.fromString(stringConcat)
         if (runtimeStringConcat != null) {
             put(JVMConfigurationKeys.STRING_CONCAT, runtimeStringConcat)
             if (jvmTarget.majorVersion < JvmTarget.JVM_9.majorVersion && runtimeStringConcat != JvmStringConcat.INLINE) {
                 messageCollector.report(
                     WARNING,
-                    "`-Xstring-concat=${arguments.stringConcat}` does nothing with JVM target `${jvmTarget.description}`."
+                    "`-Xstring-concat=$stringConcat` does nothing with JVM target `${jvmTarget.description}`."
                 )
             }
         } else {
             messageCollector.report(
-                ERROR, "Unknown `-Xstring-concat` mode: ${arguments.stringConcat}\n" +
+                ERROR, "Unknown `-Xstring-concat` mode: $stringConcat\n" +
                         "Supported modes: ${JvmStringConcat.values().joinToString { it.description }}"
             )
         }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleFinder.kt

@@ -16,16 +16,25 @@
 
 package org.jetbrains.kotlin.cli.jvm.modules
 
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiJavaModule
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.resolve.jvm.KotlinCliJavaFileManager
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModule
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleFinder
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleInfo
 
-class CliJavaModuleFinder(jrtFileSystemRoot: VirtualFile?) : JavaModuleFinder {
+class CliJavaModuleFinder(
+    jrtFileSystemRoot: VirtualFile?,
+    private val javaFileManager: KotlinCliJavaFileManager,
+    project: Project
+) : JavaModuleFinder {
     private val modulesRoot = jrtFileSystemRoot?.findChild("modules")
     private val userModules = linkedMapOf<String, JavaModule>()
 
+    private val allScope = GlobalSearchScope.allScope(project)
+
     fun addUserModule(module: JavaModule) {
         userModules.putIfAbsent(module.name, module)
     }
@@ -41,7 +50,7 @@ class CliJavaModuleFinder(jrtFileSystemRoot: VirtualFile?) : JavaModuleFinder {
 
     private fun findSystemModule(moduleRoot: VirtualFile): JavaModule.Explicit? {
         val file = moduleRoot.findChild(PsiJavaModule.MODULE_INFO_CLS_FILE) ?: return null
-        val moduleInfo = JavaModuleInfo.read(file) ?: return null
+        val moduleInfo = JavaModuleInfo.read(file, javaFileManager, allScope) ?: return null
         return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(moduleRoot, isBinary = true)), file)
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleResolver.kt

@@ -18,18 +18,24 @@ package org.jetbrains.kotlin.cli.jvm.modules
 
 import com.intellij.ide.highlighter.JavaClassFileType
 import com.intellij.ide.highlighter.JavaFileType
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
+import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModule
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
+import java.util.concurrent.ConcurrentHashMap
 
 class CliJavaModuleResolver(
     private val moduleGraph: JavaModuleGraph,
     private val userModules: List<JavaModule>,
-    private val systemModules: List<JavaModule.Explicit>
+    private val systemModules: List<JavaModule.Explicit>,
+    private val project: Project
 ) : JavaModuleResolver {
     init {
         assert(userModules.count(JavaModule::isSourceModule) <= 1) {
@@ -37,6 +43,14 @@ class CliJavaModuleResolver(
         }
     }
 
+    private val virtualFileFinder by lazy { VirtualFileFinder.getInstance(project) }
+
+    override fun getAnnotationsForModuleOwnerOfClass(classId: ClassId): List<JavaAnnotation>? {
+        val virtualFile = virtualFileFinder.findSourceOrBinaryVirtualFile(classId) ?: return null
+
+        return (findJavaModule(virtualFile) as? JavaModule.Explicit)?.moduleInfo?.annotations
+    }
+
     private val sourceModule: JavaModule? = userModules.firstOrNull(JavaModule::isSourceModule)
 
     private fun findJavaModule(file: VirtualFile): JavaModule? {
@@ -77,4 +91,8 @@ class CliJavaModuleResolver(
 
         return null
     }
+
+    companion object {
+        private const val MODULE_ANNOTATIONS_CACHE_SIZE = 10000
+    }
 }

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

@@ -62,8 +62,9 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
         val pluginLoadResult = loadPlugins(paths, arguments, configuration)
         if (pluginLoadResult != ExitCode.OK) return pluginLoadResult
 
+        val commonSources = arguments.commonSources?.toSet() ?: emptySet()
         for (arg in arguments.freeArgs) {
-            configuration.addKotlinSourceRoot(arg, isCommon = true)
+            configuration.addKotlinSourceRoot(arg, isCommon = arg in commonSources)
         }
         if (arguments.classpath != null) {
             configuration.addJvmClasspathRoots(arguments.classpath!!.split(File.pathSeparatorChar).map(::File))

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

@@ -101,7 +101,11 @@ object KotlinCompilerClient {
         fun CompileService.leaseImpl(): CompileServiceSession? {
             // the newJVMOptions could be checked here for additional parameters, if needed
             registerClient(clientAliveFlagFile.absolutePath)
-            reportingTargets.report(DaemonReportCategory.DEBUG, "connected to the daemon")
+            val javaExecutablePath = compilerId.javaExecutable?.absolutePath ?: "'user jvm'"
+            reportingTargets.report(
+                DaemonReportCategory.DEBUG,
+                "connected to the daemon. Daemon is using following 'java' executable to run itself: $javaExecutablePath"
+            )
 
             if (!leaseSession) return CompileServiceSession(this, CompileService.NO_SESSION)
 
@@ -367,8 +371,14 @@ object KotlinCompilerClient {
     }
 
 
-    private fun startDaemon(compilerId: CompilerId, daemonJVMOptions: DaemonJVMOptions, daemonOptions: DaemonOptions, reportingTargets: DaemonReportingTargets): Boolean {
-        val javaExecutable = File(File(CompilerSystemProperties.JAVA_HOME.safeValue, "bin"), "java")
+    private fun startDaemon(
+        compilerId: CompilerId,
+        daemonJVMOptions: DaemonJVMOptions,
+        daemonOptions: DaemonOptions,
+        reportingTargets: DaemonReportingTargets
+    ): Boolean {
+        val daemonJavaExecutable = compilerId.javaExecutable
+            ?: File(File(CompilerSystemProperties.JAVA_HOME.safeValue, "bin"), "java")
         val serverHostname = CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.value ?: error("${CompilerSystemProperties.JAVA_RMI_SERVER_HOSTNAME.property} is not set!")
         val platformSpecificOptions = listOf(
                 // hide daemon window
@@ -380,7 +390,7 @@ object KotlinCompilerClient {
                 listOf("--illegal-access=permit")
             else emptyList()
         val args = listOf(
-                   javaExecutable.absolutePath, "-cp", compilerId.compilerClasspath.joinToString(File.pathSeparator)) +
+                   daemonJavaExecutable.absolutePath, "-cp", compilerId.compilerClasspath.joinToString(File.pathSeparator)) +
                    platformSpecificOptions +
                    daemonJVMOptions.mappers.flatMap { it.toArgs("-") } +
                    javaIllegalAccessWorkaround +

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/ClientUtils.kt

@@ -49,7 +49,7 @@ suspend fun walkDaemonsAsync(
     useRMI: Boolean = true,
     useSockets: Boolean = true
 ): List<DaemonWithMetadataAsync> { // TODO: replace with Deferred<List<DaemonWithMetadataAsync>> and use mapNotNullAsync to speed this up
-    val classPathDigest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString()
+    val classPathDigest = compilerId.digest()
     val portExtractor = makePortFromRunFilenameExtractor(classPathDigest)
     return registryDir.walk().toList() // list, since walk returns Sequence and Sequence.map{...} is not inline => coroutines dont work
         .map { Pair(it, portExtractor(it.name)) }

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/CompileServiceRMIWrapper.kt

@@ -217,7 +217,7 @@ class CompileServiceRMIWrapper(val server: CompileServiceServerSide, daemonOptio
             runFileDir,
             makeRunFilenameString(
                 timestamp = "%tFT%<tH-%<tM-%<tS.%<tLZ".format(Calendar.getInstance(TimeZone.getTimeZone("Z"))),
-                digest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString(),
+                digest = compilerId.digest(),
                 port = port.toString()
             )
         )

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

@@ -55,7 +55,7 @@ fun walkDaemons(registryDir: File,
                 filter: (File, Int) -> Boolean = { _, _ -> true },
                 report: (DaemonReportCategory, String) -> Unit = { _, _ -> }
 ): Sequence<DaemonWithMetadata> {
-    val classPathDigest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString()
+    val classPathDigest = compilerId.digest()
     val portExtractor = makePortFromRunFilenameExtractor(classPathDigest)
     return registryDir.walk()
             .map { Pair(it, portExtractor(it.name)) }

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

@@ -231,12 +231,38 @@ fun ByteArray.toHexString(): String = joinToString("", transform = { "%02x".form
 
 data class CompilerId(
         var compilerClasspath: List<String> = listOf(),
-        var compilerVersion: String = ""
+        var compilerVersion: String = "",
+        var javaExecutable: File? = null
 ) : OptionsGroup {
 
     override val mappers: List<PropMapper<*, *, *>>
-        get() = listOf(PropMapper(this, CompilerId::compilerClasspath, toString = { it.joinToString(File.pathSeparator) }, fromString = { it.trimQuotes().split(File.pathSeparator) }),
-                       StringPropMapper(this, CompilerId::compilerVersion))
+        get() = listOf(
+            PropMapper(
+                dest = this,
+                prop = CompilerId::compilerClasspath,
+                toString = { it.joinToString(File.pathSeparator) },
+                fromString = { it.trimQuotes().split(File.pathSeparator) }
+            ),
+            StringPropMapper(
+                dest = this,
+                prop = CompilerId::compilerVersion
+            ),
+            PropMapper(
+                dest = this,
+                prop = CompilerId::javaExecutable,
+                toString = { it?.absolutePath },
+                fromString = { File(it.trimQuotes()) },
+                skipIf = { it == null }
+            )
+        )
+
+    fun digest(): String = compilerClasspath
+        .map { File(it).absolutePath }
+        .run {
+            javaExecutable?.let { plus(it.absolutePath) } ?: this
+        }
+        .distinctStringsDigest()
+        .toHexString()
 
     companion object {
         @JvmStatic
@@ -245,6 +271,15 @@ data class CompilerId(
         @JvmStatic
         fun makeCompilerId(paths: Iterable<File>): CompilerId =
                 CompilerId(compilerClasspath = paths.map { it.absolutePath })
+
+        @JvmStatic
+        fun makeCompilerId(
+            paths: Iterable<File>,
+            javaExecutable: File
+        ): CompilerId = CompilerId(
+            compilerClasspath = paths.map { it.absolutePath },
+            javaExecutable = javaExecutable
+        )
     }
 }
 

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.daemon
 
+import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.util.io.FileUtilRt
 import junit.framework.TestCase
@@ -277,6 +278,129 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
         }
     }
 
+    private fun getJdk8Location() = System.getenv("JDK_18") ?: System.getenv("JAVA_HOME")
+
+    fun testNewDaemonIsNotStartedForSameJavaExecutable() {
+        withFlagFile(getTestName(true), "-client1.alive") { flagFile1 ->
+            withFlagFile(getTestName(true), "-client2.alive") { flagFile2 ->
+                val daemonOptions = makeTestDaemonOptions(getTestName(true))
+                val compilerIdJdk8 = CompilerId.makeCompilerId(
+                    compilerClassPath +
+                            File(KotlinIntegrationTestBase.getCompilerLib(), "kotlin-compiler-sources.jar"),
+                    File(getJdk8Location()).resolve("bin/java")
+                )
+
+                withLogFile("kotlin-daemon-test-1") { logFile ->
+                    val daemonJVMOptions = makeTestDaemonJvmOptions(logFile)
+                    assertTrue(logFile.length() == 0L)
+
+                    val daemon1 = KotlinCompilerClient.connectToCompileService(
+                        compilerIdJdk8,
+                        flagFile1,
+                        daemonJVMOptions,
+                        daemonOptions,
+                        DaemonReportingTargets(out = System.err),
+                        autostart = true
+                    )
+                    assertNotNull("failed to connect daemon", daemon1)
+                    logFile.assertLogContainsSequence("INFO: starting daemon")
+
+
+                    val daemon2 = KotlinCompilerClient.connectToCompileService(
+                        compilerIdJdk8,
+                        flagFile2,
+                        daemonJVMOptions,
+                        daemonOptions,
+                        DaemonReportingTargets(out = System.err),
+                        autostart = true
+                    )
+                    assertNotNull("failed to connect daemon", daemon2)
+
+                    val logContent = logFile.readText().lines()
+                    assert(
+                        logContent.filter { it.contains("INFO: starting daemon") }.size == 1
+                    ) {
+                        "Second daemon instance was started!"
+                    }
+                    assert(
+                        logContent.filter {
+                            it.contains("INFO: Registered a client alive file: ${flagFile2.absolutePath}")
+                        }.size == 1
+                    ) {
+                        "Second client was not connected to the same instance!"
+                    }
+
+                    KotlinCompilerClient.shutdownCompileService(compilerIdJdk8, daemonOptions)
+
+                    Thread.sleep(100)
+
+                    logFile.assertLogContainsSequence("Shutdown started")
+                }
+            }
+        }
+    }
+
+    // Ignored on Windows OS due to https://bugs.openjdk.java.net/browse/JDK-8189953 bug in JDK 9
+    // Should be unignored once JDK10+ will be available by default on CI agents
+    fun testNewDaemonIsStartedOnJavaExecutableChange() {
+        if (SystemInfo.isWindows) return
+
+        withFlagFile(getTestName(true), "-client1.alive") { flagFile1 ->
+            withFlagFile(getTestName(true), "-client2.alive") { flagFile2 ->
+                val daemonOptions = makeTestDaemonOptions(getTestName(true))
+                val compilerIdJdk8 = CompilerId.makeCompilerId(
+                    compilerClassPath +
+                            File(KotlinIntegrationTestBase.getCompilerLib(), "kotlin-compiler-sources.jar"),
+                    File(getJdk8Location()).resolve("bin/java")
+                )
+                val compilerIdJdk9 = CompilerId.makeCompilerId(
+                    compilerClassPath +
+                            File(KotlinIntegrationTestBase.getCompilerLib(), "kotlin-compiler-sources.jar"),
+                    File(System.getenv("JDK_9")).resolve("bin/java")
+                )
+
+                withLogFile("kotlin-daemon-test-1") { logFile1 ->
+                    withLogFile("kotlin-daemon-test-2") { logFile2 ->
+                        val daemonJdk8JVMOptions = makeTestDaemonJvmOptions(logFile1)
+                        assertTrue(logFile1.length() == 0L)
+                        val daemonJdk9JVMOptions = makeTestDaemonJvmOptions(logFile2)
+                        assertTrue(logFile2.length() == 0L)
+
+                        val daemonJdk7 = KotlinCompilerClient.connectToCompileService(
+                            compilerIdJdk8,
+                            flagFile1,
+                            daemonJdk8JVMOptions,
+                            daemonOptions,
+                            DaemonReportingTargets(out = System.err),
+                            autostart = true
+                        )
+                        assertNotNull("failed to connect daemon", daemonJdk7)
+                        logFile1.assertLogContainsSequence("INFO: starting daemon")
+
+                        val daemonJdk9 = KotlinCompilerClient.connectToCompileService(
+                            compilerIdJdk9,
+                            flagFile2,
+                            daemonJdk9JVMOptions,
+                            daemonOptions,
+                            DaemonReportingTargets(out = System.err),
+                            autostart = true
+                        )
+                        assertNotNull("failed to connect daemon", daemonJdk9)
+                        logFile2.assertLogContainsSequence("INFO: starting daemon")
+
+                        KotlinCompilerClient.shutdownCompileService(compilerIdJdk8, daemonOptions)
+                        KotlinCompilerClient.shutdownCompileService(compilerIdJdk9, daemonOptions)
+
+                        Thread.sleep(100)
+
+                        logFile1.assertLogContainsSequence("Shutdown started")
+                        logFile2.assertLogContainsSequence("Shutdown started")
+                    }
+                }
+            }
+        }
+    }
+
     fun testDaemonRunError() {
         withFlagFile(getTestName(true), ".alive") { flagFile ->
             val daemonOptions = DaemonOptions(shutdownDelayMilliseconds = 1, verbose = true, runFilesPath = File(testTempDir, getTestName(true)).absolutePath)

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

@@ -243,7 +243,7 @@ abstract class CompileServiceImplBase(
             runFileDir,
             makeRunFilenameString(
                 timestamp = "%tFT%<tH-%<tM-%<tS.%<tLZ".format(Calendar.getInstance(TimeZone.getTimeZone("Z"))),
-                digest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString(),
+                digest = compilerId.digest(),
                 port = port.toString()
             )
         )

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

@@ -56,6 +56,11 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli
             runTest("compiler/testData/loadJava/compiledKotlin/annotations/AnnotationInAnnotationArguments.kt");
         }
 
+        @TestMetadata("AnnotationInArray.kt")
+        public void testAnnotationInArray() throws Exception {
+            runTest("compiler/testData/loadJava/compiledKotlin/annotations/AnnotationInArray.kt");
+        }
+
         @TestMetadata("ClassLiteralArguments.kt")
         public void testClassLiteralArguments() throws Exception {
             runTest("compiler/testData/loadJava/compiledKotlin/annotations/ClassLiteralArguments.kt");
@@ -438,6 +443,11 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli
                 runTest("compiler/testData/loadJava/compiledKotlin/annotations/types/ClassLiteralArgument.kt");
             }
 
+            @TestMetadata("DefinitelyNotNull.kt")
+            public void testDefinitelyNotNull() throws Exception {
+                runTest("compiler/testData/loadJava/compiledKotlin/annotations/types/DefinitelyNotNull.kt");
+            }
+
             @TestMetadata("ReceiverParameter.kt")
             public void testReceiverParameter() throws Exception {
                 runTest("compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.kt");

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

@@ -29,6 +29,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
     }
 
+    @TestMetadata("annotationUsedAsAnnotationArgument.kt")
+    public void testAnnotationUsedAsAnnotationArgument() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.kt");
+    }
+
     @TestMetadata("asImports.kt")
     public void testAsImports() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/asImports.kt");
@@ -174,6 +179,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         runTest("compiler/fir/analysis-tests/testData/resolve/ft.kt");
     }
 
+    @TestMetadata("funInterfaceDeclaration.kt")
+    public void testFunInterfaceDeclaration() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolve/funInterfaceDeclaration.kt");
+    }
+
     @TestMetadata("functionTypeAlias.kt")
     public void testFunctionTypeAlias() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/functionTypeAlias.kt");
@@ -496,6 +506,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt");
         }
 
+        @TestMetadata("argParamTypeMismatch.kt")
+        public void testArgParamTypeMismatch() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.kt");
+        }
+
         @TestMetadata("argumentsOfAnnotations.kt")
         public void testArgumentsOfAnnotations() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt");
@@ -941,6 +956,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constVal"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("const.kt")
+        public void testConst() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/constVal/const.kt");
+        }
+
         @TestMetadata("constValNotTopLevelOrObject.kt")
         public void testConstValNotTopLevelOrObject() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/constVal/constValNotTopLevelOrObject.kt");
@@ -970,6 +990,24 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         }
     }
 
+    @TestMetadata("compiler/fir/analysis-tests/testData/resolve/contracts")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Contracts extends AbstractLazyBodyIsNotTouchedTilContractsPhaseTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInContracts() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/contracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
+        }
+
+        @TestMetadata("genericContract.kt")
+        public void testGenericContract() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/contracts/genericContract.kt");
+        }
+    }
+
     @TestMetadata("compiler/fir/analysis-tests/testData/resolve/delegates")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
@@ -1150,6 +1188,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt");
         }
 
+        @TestMetadata("multipleBounds.kt")
+        public void testMultipleBounds() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt");
+        }
+
         @TestMetadata("nonConstValInAnnotationArgument.kt")
         public void testNonConstValInAnnotationArgument() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt");
@@ -2681,6 +2724,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/problems/doubleGenericDiamond.kt");
         }
 
+        @TestMetadata("fakeTypeMismatchOnExtensionReference.kt")
+        public void testFakeTypeMismatchOnExtensionReference() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/problems/fakeTypeMismatchOnExtensionReference.kt");
+        }
+
         @TestMetadata("falseIntersection.kt")
         public void testFalseIntersection() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/problems/falseIntersection.kt");
@@ -2807,11 +2855,21 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt");
         }
 
+        @TestMetadata("leakedImplicitType.kt")
+        public void testLeakedImplicitType() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/references/leakedImplicitType.kt");
+        }
+
         @TestMetadata("referenceToExtension.kt")
         public void testReferenceToExtension() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/references/referenceToExtension.kt");
         }
 
+        @TestMetadata("referenceToField.kt")
+        public void testReferenceToField() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/references/referenceToField.kt");
+        }
+
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/references/simple.kt");
@@ -2835,6 +2893,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("funInterfaceConstructorReference.kt")
+        public void testFunInterfaceConstructorReference() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/funInterfaceConstructorReference.kt");
+        }
+
         @TestMetadata("genericSam.kt")
         public void testGenericSam() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSam.kt");

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

@@ -9,6 +9,7 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJavaTest
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetModule
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.test.ConfigurationKind
@@ -54,6 +55,7 @@ abstract class AbstractFirLoadCompiledKotlin : AbstractFirLoadBinariesTest() {
         val file = File(path)
 
         val configuration = newConfiguration(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, emptyList(), emptyList<File>())
+        AbstractLoadJavaTest.updateConfigurationWithDirectives(file.readText(), configuration)
         val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 
         return compileKotlinToDirAndGetModule(listOf(file), tmpdir, environment)

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/AnnotationInArray.txt

@@ -0,0 +1,20 @@
+public final annotation class Anno : R|kotlin/Annotation| {
+    public final val value: R|kotlin/Array<test/Bnno>|
+        public get(): R|kotlin/Array<test/Bnno>|
+
+    public constructor(value: R|kotlin/Array<test/Bnno>|): R|test/Anno|
+
+}
+
+@R|test/Anno|(value = <implicitArrayOf>(@R|test/Bnno|(value = String(x)) , @R|test/Bnno|(value = String(y)) )) public final class AnnotationInArray : R|kotlin/Any| {
+    public constructor(): R|test/AnnotationInArray|
+
+}
+
+public final annotation class Bnno : R|kotlin/Annotation| {
+    public final val value: R|kotlin/String|
+        public get(): R|kotlin/String|
+
+    public constructor(value: R|kotlin/String|): R|test/Bnno|
+
+}

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/types/DefinitelyNotNull.txt

@@ -0,0 +1 @@
+public final fun <T> foo(x: R|T!!|, y: R|kotlin/collections/List<T!!>|, z: R|(T!!) -> T!!|): R|T!!|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/types/SupertypesAndBounds.txt

@@ -1,4 +1,4 @@
-public final annotation class A : R|kotlin/Annotation| {
+@R|kotlin/annotation/Target|(allowedTargets = <implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.TYPE|())) public final annotation class A : R|kotlin/Annotation| {
     public constructor(): R|test/A|
 
 }

compiler/fir/analysis-tests/testData/loadCompiledKotlin/fromLoadJava/kotlinSignature/MethodWithFunctionTypes.txt

@@ -1,5 +1,5 @@
 public open class MethodWithFunctionTypes : R|kotlin/Any| {
-    public open fun foo(f: R|(kotlin/String?) -> kotlin/String|): R|kotlin/String.() -> kotlin/String?|
+    public open fun foo(f: R|(kotlin/String?) -> kotlin/String|): R|(kotlin/String.() -> kotlin/String?)?|
 
     public constructor(): R|test/MethodWithFunctionTypes|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/prop/NonConstValWithConstantValueAttribute.txt

@@ -1,16 +1,16 @@
-public final val nonConstVal1: R|kotlin/Int|
+public final val nonConstVal1: R|kotlin/Int| = Int(1)
     public get(): R|kotlin/Int|
 
 public final class C : R|kotlin/Any| {
     public final companion object Companion : R|kotlin/Any| {
-        public final val nonConstVal3: R|kotlin/Int|
+        public final val nonConstVal3: R|kotlin/Int| = Int(3)
             public get(): R|kotlin/Int|
 
         private constructor(): R|test/C.Companion|
 
     }
 
-    public final val nonConstVal2: R|kotlin/Int|
+    public final val nonConstVal2: R|kotlin/Int| = Int(2)
         public get(): R|kotlin/Int|
 
     public constructor(): R|test/C|

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

@@ -1,8 +1,16 @@
 public final fun test1(): R|suspend () -> kotlin/Unit|
 
+public final fun test1N(): R|(suspend () -> kotlin/Unit)?|
+
 public final fun test2(): R|suspend kotlin/Int.() -> kotlin/Int|
 
+public final fun test2N(): R|(suspend kotlin/Int.() -> kotlin/Int)?|
+
 public final fun test3(): R|kotlin/collections/List<kotlin/coroutines/SuspendFunction0<kotlin/Unit>>|
 
+public final fun test3N(): R|kotlin/collections/List<kotlin/coroutines/SuspendFunction0<kotlin/Unit>?>|
+
 public final fun test4(): R|suspend () -> kotlin/coroutines/SuspendFunction0<kotlin/Unit>|
 
+public final fun test4N(): R|(suspend () -> kotlin/coroutines/SuspendFunction0<kotlin/Unit>?)?|
+

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

@@ -0,0 +1,27 @@
+FILE: annotationUsedAsAnnotationArgument.kt
+    public final annotation class Ann : R|kotlin/Annotation| {
+        public constructor(): R|Ann| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public final annotation class Ann2 : R|kotlin/Annotation| {
+        public constructor(): R|Ann2| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public final annotation class Ann3 : R|kotlin/Annotation| {
+        public constructor(arg: R|kotlin/Int|, s: R|kotlin/String|): R|Ann3| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final val arg: R|kotlin/Int| = R|<local>/arg|
+            public get(): R|kotlin/Int|
+
+        public final val s: R|kotlin/String| = R|<local>/s|
+            public get(): R|kotlin/String|
+
+    }
+    @R|Ann3|(@R|Ann3|(@R|Ann|() Int(5), String()) @R|Ann2|() Int(1), String()) public final val a: R|kotlin/Int| = Int(0)
+        public get(): R|kotlin/Int|

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

@@ -0,0 +1,11 @@
+annotation class Ann
+
+annotation class Ann2
+
+annotation class Ann3(val arg: Int, val s: String)
+
+@Ann3(
+    <!ANNOTATION_USED_AS_ANNOTATION_ARGUMENT!>@Ann3(
+        <!ANNOTATION_USED_AS_ANNOTATION_ARGUMENT!>@Ann<!> 5, ""
+    )<!> <!ANNOTATION_USED_AS_ANNOTATION_ARGUMENT!>@Ann2<!> 1, ""
+) val a = 0

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

@@ -15,5 +15,5 @@ class B : A() {
 }
 
 fun test(b: B) {
-    b.<!HIDDEN!>foo<!>("")
+    b.<!INVISIBLE_REFERENCE!>foo<!>("")
 }

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

@@ -0,0 +1,17 @@
+FILE: argParamTypeMismatch.kt
+    public final fun foo(first: R|kotlin/String|): R|kotlin/Unit| {
+    }
+    public final fun foo2(first: R|kotlin/String|, second: R|kotlin/Int|): R|kotlin/Unit| {
+    }
+    public final fun test(): R|kotlin/Unit| {
+        lval int: R|kotlin/Int| = Int(1)
+        <Inapplicable(INAPPLICABLE): /foo>#(R|<local>/int|)
+        <Inapplicable(INAPPLICABLE): /foo>#(Int(2))
+        <Inapplicable(INAPPLICABLE): /foo>#(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <inline=Inline, kind=EXACTLY_ONCE>  {
+            ^ Int(20)
+        }
+        ))
+        R|/foo2|(String(asdf), Int(3))
+        <Inapplicable(INAPPLICABLE): /foo2>#(Int(4), String(asdf))
+        <Inapplicable(INAPPLICABLE): /foo2>#(Int(5), Int(6))
+    }

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

@@ -0,0 +1,13 @@
+fun foo(first: String) {}
+fun foo2(first: String, second: Int) {}
+
+fun test() {
+    val int = 1
+    foo(<!ARGUMENT_TYPE_MISMATCH!>int<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>2<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>run { 20 }<!>)
+
+    foo2("asdf", 3)
+    foo2(<!ARGUMENT_TYPE_MISMATCH!>4<!>, <!ARGUMENT_TYPE_MISMATCH!>"asdf"<!>)
+    foo2(<!ARGUMENT_TYPE_MISMATCH!>5<!>, 6)
+}

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

@@ -9,7 +9,7 @@ public @interface Ann {
 // FILE: main.kt
 
 @Ann(x = 10, s = "")
-<!INAPPLICABLE_CANDIDATE!>@Ann(10, "")<!>
+@Ann(<!ARGUMENT_TYPE_MISMATCH!>10<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 @Ann(x = 10, s = "", y = 10)
 class A
 

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

@@ -21,6 +21,6 @@ fun test() {
     baz(1, "my", "yours")
     baz(1, z = true)
 
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(0, "", false)
+    baz(0, "", <!ARGUMENT_TYPE_MISMATCH!>false<!>)
 }
 

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

@@ -6,8 +6,8 @@ fun foo2(block: (C, C) -> Unit) = block(C(0, ""), C(0, ""))
 fun test() {
     foo1 { (x, y) -> C(x, y) }
     foo1 { (x: Int, y: String) -> C(x, y) }
-    foo1 { (x: String, y: Int) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x, y) }
+    foo1 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>) -> C(<!ARGUMENT_TYPE_MISMATCH!>x<!>, <!ARGUMENT_TYPE_MISMATCH!>y<!>) }
     foo2 { (x, y), (z, w) -> C(x + z, y + w) }
     foo2 { (x: Int, y: String), (z: Int, w: String) -> C(x + z, y + w) }
-    foo2 { (x: String, y: Int), (z: String, w: Int) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x + z, y + w) }
+    foo2 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>), (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>z: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>w: Int<!>) -> C(<!ARGUMENT_TYPE_MISMATCH!>x + z<!>, <!ARGUMENT_TYPE_MISMATCH!>y + w<!>) }
 }

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

@@ -5,7 +5,7 @@ fun takeAny(x: Any) {}
 fun takeString(x: String) {}
 
 fun test_0() {
-    1l
+    1L
     1
     10000000000
 }
@@ -17,9 +17,9 @@ fun test_1() {
 }
 
 fun test_2() {
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
+    takeInt(<!ARGUMENT_TYPE_MISMATCH!>10000000000<!>)
     takeLong(10000000000)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000<!>)
 }
 
 fun test_3() {
@@ -35,14 +35,14 @@ fun test_4() {
 }
 
 fun test_5() {
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
+    takeString(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
+    takeString(<!ARGUMENT_TYPE_MISMATCH!>run { 1 }<!>)
 }
 
 annotation class Ann(val x: Byte)
 
 @Ann(10)
 fun test_6() {
-    <!INAPPLICABLE_CANDIDATE!>@Ann(300)<!>
+    @Ann(<!ARGUMENT_TYPE_MISMATCH!>300<!>)
     val x = ""
 }

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

@@ -9,7 +9,7 @@ public @interface Ann {
 @Ann("a", "b")
 fun test_1() {}
 
-<!INAPPLICABLE_CANDIDATE!>@Ann(arrayOf("a", "b"))<!>
+@Ann(<!ARGUMENT_TYPE_MISMATCH!>arrayOf("a", "b")<!>)
 fun test_2() {}
 
 @Ann(*arrayOf("a", "b"))

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

@@ -13,6 +13,6 @@ fun takeOutA(array: Array<out A>) {}
 
 fun test(array: Array<B>) {
     A.take(array)
-    <!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
+    takeA(<!ARGUMENT_TYPE_MISMATCH!>array<!>)
     takeOutA(array)
 }

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

@@ -16,7 +16,7 @@ fun test(ordinal: Int) {
     buildString {
         insert(KDocTemplate()) {
             definition {
-                ordinal?.let {}
+                ordinal<!UNNECESSARY_SAFE_CALL!>?.<!>let {}
             }
         }
     }

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

@@ -31,33 +31,33 @@ fun test_3() {
 fun takeByte(b: Byte) {}
 
 fun test_4() {
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 127<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>-100 - 100<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>10 * 10<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 * 100<!>)
     <!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 % 10<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 % 10<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 and 100<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>128 and 511<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 or 100<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 or 0<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>511 xor 511<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>512 xor 511<!>)
 }
 
 fun test_5() {
     takeByte(-1)
     takeByte(+1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1.inv()<!>)
 }
 
 fun test_6() {
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 127 + 1 }<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + run { 1 }<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 1 + 1 }<!>)
     1 + 1
     run { 1 }
     1 + run { 1 }

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

@@ -8,10 +8,10 @@ fun test() {
     foo(third = false, second = 2.71, fourth = "?!", first = 0)
 
     foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>0.0<!>, <!ARGUMENT_TYPE_MISMATCH!>false<!>, <!ARGUMENT_TYPE_MISMATCH!>0<!>, "")
     foo(1, 2.0, third = true, "")
     foo(second = 0.0, first = 0, fourth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
+    foo(first = <!ARGUMENT_TYPE_MISMATCH!>0.0<!>, second = <!ARGUMENT_TYPE_MISMATCH!>0<!>, third = <!ARGUMENT_TYPE_MISMATCH!>""<!>, fourth = <!ARGUMENT_TYPE_MISMATCH!>false<!>)
     foo(first = 0, second = 0.0, third = false, fourth = "", <!ARGUMENT_PASSED_TWICE!>first<!> = 1)
     foo(0, 0.0, false, <!NAMED_PARAMETER_NOT_FOUND!>foth<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

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

@@ -8,5 +8,5 @@ FILE: stringTemplates.kt
     public final fun foo(s: R|kotlin/String|): R|kotlin/Unit| {
     }
     public final fun test(a: R|A|): R|kotlin/Unit| {
-        R|/foo|(<strcat>(R|<local>/a|.R|kotlin/Any.toString|()))
+        R|/foo|(<strcat>(R|<local>/a|))
     }

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

@@ -7,8 +7,8 @@ fun test() {
     foo(1, "my", "yours")
     foo(1, *arrayOf("my", "yours"))
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    foo(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 
     bar(1, z = true, y = *arrayOf("my", "yours"))
 

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

@@ -9,7 +9,7 @@ fun bar(x: B) {}
 
 fun test(c: C) {
     // Argument mapping error
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     // Ambiguity
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(c)

compiler/fir/analysis-tests/testData/resolve/callResolution/safeCallOnTypeAlias.fir.txt

@@ -1,5 +1,5 @@
 FILE: safeCallOnTypeAlias.kt
-    public final typealias MyTypeAlias = R|() -> kotlin/String?|
+    public final typealias MyTypeAlias = R|(() -> kotlin/String?)?|
     public final fun foo(x: R|MyTypeAlias|): R|kotlin/Unit| {
         R|<local>/x|?.{ $subj$.R|kotlin/let|<R|() -> kotlin/String?|, R|kotlin/String?|>(<L> = let@fun <anonymous>(y: R|() -> kotlin/String?|): R|kotlin/String?| <inline=Inline, kind=EXACTLY_ONCE>  {
             ^ R|<local>/y|.R|SubstitutionOverride<kotlin/Function0.invoke: R|kotlin/String?|>|()?.{ $subj$.R|kotlin/let|<R|kotlin/String|, R|kotlin/String|>(<L> = let@fun <anonymous>(result: R|kotlin/String|): R|kotlin/String| <inline=Inline, kind=EXACTLY_ONCE>  {

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

@@ -191,63 +191,68 @@ digraph complex_kt {
         subgraph cluster_19 {
             color=blue
             56 [label="Enter block"];
-            57 [label="Access variable this@R|/firstIsInstanceOrNull|"];
-            58 [label="Function call: this@R|/firstIsInstanceOrNull|.R|SubstitutionOverride<kotlin/collections/List.iterator: R|kotlin/collections/Iterator<CapturedType(*)>|>|()"];
-            59 [label="Variable declaration: lval <iterator>: R|kotlin/collections/Iterator<kotlin/Any?>|"];
             subgraph cluster_20 {
                 color=blue
-                60 [label="Enter while loop"];
+                57 [label="Enter block"];
+                58 [label="Access variable this@R|/firstIsInstanceOrNull|"];
+                59 [label="Function call: this@R|/firstIsInstanceOrNull|.R|SubstitutionOverride<kotlin/collections/List.iterator: R|kotlin/collections/Iterator<CapturedType(*)>|>|()"];
+                60 [label="Variable declaration: lval <iterator>: R|kotlin/collections/Iterator<kotlin/Any?>|"];
                 subgraph cluster_21 {
                     color=blue
-                    61 [label="Enter loop condition"];
-                    62 [label="Access variable R|<local>/<iterator>|"];
-                    63 [label="Function call: R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()"];
-                    64 [label="Exit loop condition"];
-                }
-                subgraph cluster_22 {
-                    color=blue
-                    65 [label="Enter loop block"];
+                    61 [label="Enter while loop"];
+                    subgraph cluster_22 {
+                        color=blue
+                        62 [label="Enter loop condition"];
+                        63 [label="Access variable R|<local>/<iterator>|"];
+                        64 [label="Function call: R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()"];
+                        65 [label="Exit loop condition"];
+                    }
                     subgraph cluster_23 {
                         color=blue
-                        66 [label="Enter block"];
-                        67 [label="Access variable R|<local>/<iterator>|"];
-                        68 [label="Function call: R|<local>/<iterator>|.R|SubstitutionOverride<kotlin/collections/Iterator.next: R|kotlin/Any?|>|()"];
-                        69 [label="Variable declaration: lval element: R|kotlin/Any?|"];
+                        66 [label="Enter loop block"];
                         subgraph cluster_24 {
                             color=blue
-                            70 [label="Enter when"];
+                            67 [label="Enter block"];
+                            68 [label="Access variable R|<local>/<iterator>|"];
+                            69 [label="Function call: R|<local>/<iterator>|.R|SubstitutionOverride<kotlin/collections/Iterator.next: R|kotlin/Any?|>|()"];
+                            70 [label="Variable declaration: lval element: R|kotlin/Any?|"];
                             subgraph cluster_25 {
                                 color=blue
-                                71 [label="Enter when branch condition "];
-                                72 [label="Access variable R|<local>/element|"];
-                                73 [label="Type operator: (R|<local>/element| is R|T|)"];
-                                74 [label="Exit when branch condition"];
+                                71 [label="Enter when"];
+                                subgraph cluster_26 {
+                                    color=blue
+                                    72 [label="Enter when branch condition "];
+                                    73 [label="Access variable R|<local>/element|"];
+                                    74 [label="Type operator: (R|<local>/element| is R|T|)"];
+                                    75 [label="Exit when branch condition"];
+                                }
+                                76 [label="Synthetic else branch"];
+                                77 [label="Enter when branch result"];
+                                subgraph cluster_27 {
+                                    color=blue
+                                    78 [label="Enter block"];
+                                    79 [label="Access variable R|<local>/element|"];
+                                    80 [label="Jump: ^firstIsInstanceOrNull R|<local>/element|"];
+                                    81 [label="Stub" style="filled" fillcolor=gray];
+                                    82 [label="Exit block" style="filled" fillcolor=gray];
+                                }
+                                83 [label="Exit when branch result" style="filled" fillcolor=gray];
+                                84 [label="Exit when"];
                             }
-                            75 [label="Synthetic else branch"];
-                            76 [label="Enter when branch result"];
-                            subgraph cluster_26 {
-                                color=blue
-                                77 [label="Enter block"];
-                                78 [label="Access variable R|<local>/element|"];
-                                79 [label="Jump: ^firstIsInstanceOrNull R|<local>/element|"];
-                                80 [label="Stub" style="filled" fillcolor=gray];
-                                81 [label="Exit block" style="filled" fillcolor=gray];
-                            }
-                            82 [label="Exit when branch result" style="filled" fillcolor=gray];
-                            83 [label="Exit when"];
+                            85 [label="Exit block"];
                         }
-                        84 [label="Exit block"];
+                        86 [label="Exit loop block"];
                     }
-                    85 [label="Exit loop block"];
+                    87 [label="Exit whileloop"];
                 }
-                86 [label="Exit whileloop"];
+                88 [label="Exit block"];
             }
-            87 [label="Const: Null(null)"];
-            88 [label="Jump: ^firstIsInstanceOrNull Null(null)"];
-            89 [label="Stub" style="filled" fillcolor=gray];
-            90 [label="Exit block" style="filled" fillcolor=gray];
+            89 [label="Const: Null(null)"];
+            90 [label="Jump: ^firstIsInstanceOrNull Null(null)"];
+            91 [label="Stub" style="filled" fillcolor=gray];
+            92 [label="Exit block" style="filled" fillcolor=gray];
         }
-        91 [label="Exit function firstIsInstanceOrNull" style="filled" fillcolor=red];
+        93 [label="Exit function firstIsInstanceOrNull" style="filled" fillcolor=red];
     }
     55 -> {56};
     56 -> {57};
@@ -258,8 +263,8 @@ digraph complex_kt {
     61 -> {62};
     62 -> {63};
     63 -> {64};
-    64 -> {86 65};
-    65 -> {66};
+    64 -> {65};
+    65 -> {87 66};
     66 -> {67};
     67 -> {68};
     68 -> {69};
@@ -268,24 +273,26 @@ digraph complex_kt {
     71 -> {72};
     72 -> {73};
     73 -> {74};
-    74 -> {76 75};
-    75 -> {83};
-    76 -> {77};
+    74 -> {75};
+    75 -> {77 76};
+    76 -> {84};
     77 -> {78};
     78 -> {79};
-    79 -> {91};
-    79 -> {80} [style=dotted];
+    79 -> {80};
+    80 -> {93};
     80 -> {81} [style=dotted];
     81 -> {82} [style=dotted];
     82 -> {83} [style=dotted];
-    83 -> {84};
+    83 -> {84} [style=dotted];
     84 -> {85};
-    85 -> {61} [color=green style=dashed];
-    86 -> {87};
+    85 -> {86};
+    86 -> {62} [color=green style=dashed];
     87 -> {88};
-    88 -> {91};
-    88 -> {89} [style=dotted];
-    89 -> {90} [style=dotted];
+    88 -> {89};
+    89 -> {90};
+    90 -> {93};
     90 -> {91} [style=dotted];
+    91 -> {92} [style=dotted];
+    92 -> {93} [style=dotted];
 
 }

compiler/fir/analysis-tests/testData/resolve/cfg/complex.fir.txt

@@ -25,13 +25,16 @@ FILE: complex.kt
 
     }
     public final inline fun <reified T : R|kotlin/Any|> R|kotlin/collections/List<*>|.firstIsInstanceOrNull(): R|T?| {
-        lval <iterator>: R|kotlin/collections/Iterator<kotlin/Any?>| = this@R|/firstIsInstanceOrNull|.R|SubstitutionOverride<kotlin/collections/List.iterator: R|kotlin/collections/Iterator<CapturedType(*)>|>|()
-        while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
-            lval element: R|kotlin/Any?| = R|<local>/<iterator>|.R|SubstitutionOverride<kotlin/collections/Iterator.next: R|kotlin/Any?|>|()
-            when () {
-                (R|<local>/element| is R|T|) ->  {
-                    ^firstIsInstanceOrNull R|<local>/element|
+         {
+            lval <iterator>: R|kotlin/collections/Iterator<kotlin/Any?>| = this@R|/firstIsInstanceOrNull|.R|SubstitutionOverride<kotlin/collections/List.iterator: R|kotlin/collections/Iterator<CapturedType(*)>|>|()
+            while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
+                lval element: R|kotlin/Any?| = R|<local>/<iterator>|.R|SubstitutionOverride<kotlin/collections/Iterator.next: R|kotlin/Any?|>|()
+                when () {
+                    (R|<local>/element| is R|T|) ->  {
+                        ^firstIsInstanceOrNull R|<local>/element|
+                    }
                 }
+
             }
 
         }

compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt

@@ -72,7 +72,7 @@ fun test_4(x: Any, y: Any) {
         }
 
     )
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
+    takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>) // Bad
     takeInt(y) // OK
     takeInt(a) // Bad
 }

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

@@ -19,85 +19,78 @@ digraph initBlockAndInPlaceLambda_kt {
 
     subgraph cluster_2 {
         color=red
-        4 [label="Enter function getter" style="filled" fillcolor=red];
-        5 [label="Exit function getter" style="filled" fillcolor=red];
+        4 [label="Enter class C" style="filled" fillcolor=red];
+        5 [label="Part of class initialization"];
+        6 [label="Exit class C" style="filled" fillcolor=red];
     }
-    4 -> {5};
+    4 -> {5} [color=green];
+    5 -> {6} [style=dotted];
+    5 -> {10} [color=green];
+    5 -> {10} [style=dashed];
 
     subgraph cluster_3 {
         color=red
-        6 [label="Enter class C" style="filled" fillcolor=red];
-        7 [label="Part of class initialization"];
-        8 [label="Exit class C" style="filled" fillcolor=red];
+        7 [label="Enter function <init>" style="filled" fillcolor=red];
+        8 [label="Delegated constructor call: super<R|kotlin/Any|>()"];
+        9 [label="Exit function <init>" style="filled" fillcolor=red];
     }
-    6 -> {7} [color=green];
-    7 -> {8} [style=dotted];
-    7 -> {12} [color=green];
-    7 -> {12} [style=dashed];
+    7 -> {8};
+    8 -> {9};
 
     subgraph cluster_4 {
         color=red
-        9 [label="Enter function <init>" style="filled" fillcolor=red];
-        10 [label="Delegated constructor call: super<R|kotlin/Any|>()"];
-        11 [label="Exit function <init>" style="filled" fillcolor=red];
-    }
-    9 -> {10};
-    10 -> {11};
-
-    subgraph cluster_5 {
-        color=red
-        12 [label="Enter init block" style="filled" fillcolor=red];
-        subgraph cluster_6 {
+        10 [label="Enter init block" style="filled" fillcolor=red];
+        subgraph cluster_5 {
             color=blue
-            13 [label="Enter block"];
-            14 [label="Access variable R|<local>/a|"];
-            15 [label="Access variable R|/A.b|"];
-            16 [label="Enter safe call"];
-            17 [label="Postponed enter to lambda"];
-            subgraph cluster_7 {
+            11 [label="Enter block"];
+            12 [label="Access variable R|<local>/a|"];
+            13 [label="Access variable R|/A.b|"];
+            14 [label="Enter safe call"];
+            15 [label="Postponed enter to lambda"];
+            subgraph cluster_6 {
                 color=blue
-                25 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-                subgraph cluster_8 {
+                23 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+                subgraph cluster_7 {
                     color=blue
-                    26 [label="Enter block"];
-                    27 [label="Access variable R|<local>/a|"];
-                    28 [label="Access variable R|<local>/it|"];
-                    29 [label="Function call: R|/C.C|(...)"];
-                    30 [label="Exit block"];
+                    24 [label="Enter block"];
+                    25 [label="Access variable R|<local>/a|"];
+                    26 [label="Access variable R|<local>/it|"];
+                    27 [label="Function call: R|/C.C|(...)"];
+                    28 [label="Exit block"];
                 }
-                31 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
+                29 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
             }
-            18 [label="Call arguments union" style="filled" fillcolor=yellow];
-            19 [label="Postponed exit from lambda"];
-            20 [label="Function call: $subj$.R|kotlin/let|<R|B|, R|C|>(...)"];
-            21 [label="Exit safe call"];
-            22 [label="Variable declaration: lval c: R|C?|"];
-            23 [label="Exit block"];
+            16 [label="Call arguments union" style="filled" fillcolor=yellow];
+            17 [label="Postponed exit from lambda"];
+            18 [label="Function call: $subj$.R|kotlin/let|<R|B|, R|C|>(...)"];
+            19 [label="Exit safe call"];
+            20 [label="Variable declaration: lval c: R|C?|"];
+            21 [label="Exit block"];
         }
-        24 [label="Exit init block" style="filled" fillcolor=red];
+        22 [label="Exit init block" style="filled" fillcolor=red];
     }
+    10 -> {11};
+    11 -> {12};
     12 -> {13};
-    13 -> {14};
+    13 -> {14 19};
     14 -> {15};
-    15 -> {16 21};
-    16 -> {17};
-    17 -> {25};
-    17 -> {19} [color=red];
-    17 -> {25} [style=dashed];
-    18 -> {20} [color=red];
-    19 -> {20} [color=green];
+    15 -> {23};
+    15 -> {17} [color=red];
+    15 -> {23} [style=dashed];
+    16 -> {18} [color=red];
+    17 -> {18} [color=green];
+    18 -> {19};
+    19 -> {20};
     20 -> {21};
     21 -> {22};
-    22 -> {23};
+    22 -> {6} [color=green];
     23 -> {24};
-    24 -> {8} [color=green];
+    24 -> {25};
     25 -> {26};
     26 -> {27};
     27 -> {28};
     28 -> {29};
-    29 -> {30};
-    30 -> {31};
-    31 -> {18} [color=red];
-    31 -> {19} [color=green];
+    29 -> {16} [color=red];
+    29 -> {17} [color=green];
 
 }

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

@@ -44,27 +44,20 @@ digraph innerClassInAnonymousObject_kt {
 
     subgraph cluster_5 {
         color=red
-        14 [label="Enter function getter" style="filled" fillcolor=red];
-        15 [label="Exit function getter" style="filled" fillcolor=red];
+        14 [label="Enter property" style="filled" fillcolor=red];
+        15 [label="Exit anonymous object"];
+        16 [label="Exit property" style="filled" fillcolor=red];
     }
-    14 -> {15};
-
     subgraph cluster_6 {
-        color=red
-        16 [label="Enter property" style="filled" fillcolor=red];
-        17 [label="Exit anonymous object"];
-        18 [label="Exit property" style="filled" fillcolor=red];
-    }
-    subgraph cluster_7 {
         color=blue
         12 [label="Enter class <anonymous object>" style="filled" fillcolor=red];
         13 [label="Exit class <anonymous object>" style="filled" fillcolor=red];
     }
-    16 -> {17};
-    16 -> {0 5 8} [color=red];
-    17 -> {18};
-    17 -> {0 12} [color=green];
-    17 -> {0 12} [style=dashed];
+    14 -> {15};
+    14 -> {0 5 8} [color=red];
+    15 -> {16};
+    15 -> {0 12} [color=green];
+    15 -> {0 12} [style=dashed];
     12 -> {13} [color=green];
 
 }

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

@@ -127,7 +127,7 @@ digraph jumps_kt {
             }
             51 [label="Variable declaration: lval y: R|kotlin/Int?|"];
             52 [label="Access variable R|<local>/y|"];
-            53 [label="Function call: R|<local>/y|.<Inapplicable(INAPPLICABLE_WRONG_RECEIVER): kotlin/Int.inc>#()"];
+            53 [label="Function call: R|<local>/y|.<Inapplicable(UNSAFE_CALL): kotlin/Int.inc>#()"];
             54 [label="Exit block"];
         }
         55 [label="Exit function test_2" style="filled" fillcolor=red];

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

@@ -22,7 +22,7 @@ FILE: jumps.kt
             }
         }
 
-        R|<local>/y|.<Inapplicable(INAPPLICABLE_WRONG_RECEIVER): kotlin/Int.inc>#()
+        R|<local>/y|.<Inapplicable(UNSAFE_CALL): kotlin/Int.inc>#()
     }
     public final fun test_3(x: R|kotlin/Int?|): R|kotlin/Unit| {
         while(Boolean(true)) {

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

@@ -5,26 +5,19 @@ digraph lambdaAsReturnOfLambda_kt {
 
     subgraph cluster_0 {
         color=red
-        14 [label="Enter function getter" style="filled" fillcolor=red];
-        15 [label="Exit function getter" style="filled" fillcolor=red];
-    }
-    14 -> {15};
-
-    subgraph cluster_1 {
-        color=red
-        16 [label="Enter property" style="filled" fillcolor=red];
-        17 [label="Postponed enter to lambda"];
-        subgraph cluster_2 {
+        14 [label="Enter property" style="filled" fillcolor=red];
+        15 [label="Postponed enter to lambda"];
+        subgraph cluster_1 {
             color=blue
             0 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            subgraph cluster_3 {
+            subgraph cluster_2 {
                 color=blue
                 1 [label="Enter block"];
                 2 [label="Postponed enter to lambda"];
-                subgraph cluster_4 {
+                subgraph cluster_3 {
                     color=blue
                     8 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-                    subgraph cluster_5 {
+                    subgraph cluster_4 {
                         color=blue
                         9 [label="Enter block"];
                         10 [label="Access variable R|<local>/foo|"];
@@ -43,15 +36,15 @@ digraph lambdaAsReturnOfLambda_kt {
             }
             7 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
         }
-        18 [label="Postponed exit from lambda"];
-        19 [label="Function call: R|/run|<R|(kotlin/String) -> kotlin/Unit|>(...)"];
-        20 [label="Exit property" style="filled" fillcolor=red];
+        16 [label="Postponed exit from lambda"];
+        17 [label="Function call: R|/run|<R|(kotlin/String) -> kotlin/Unit|>(...)"];
+        18 [label="Exit property" style="filled" fillcolor=red];
     }
+    14 -> {15};
+    15 -> {16 0};
+    15 -> {0} [style=dashed];
     16 -> {17};
-    17 -> {18 0};
-    17 -> {0} [style=dashed];
-    18 -> {19};
-    19 -> {20};
+    17 -> {18};
     0 -> {1};
     1 -> {2};
     2 -> {3 8};
@@ -67,39 +60,39 @@ digraph lambdaAsReturnOfLambda_kt {
     11 -> {12};
     12 -> {13};
 
-    subgraph cluster_6 {
+    subgraph cluster_5 {
         color=red
-        21 [label="Enter function bar" style="filled" fillcolor=red];
-        subgraph cluster_7 {
+        19 [label="Enter function bar" style="filled" fillcolor=red];
+        subgraph cluster_6 {
             color=blue
-            22 [label="Enter block"];
-            23 [label="Exit block"];
+            20 [label="Enter block"];
+            21 [label="Exit block"];
         }
-        24 [label="Exit function bar" style="filled" fillcolor=red];
+        22 [label="Exit function bar" style="filled" fillcolor=red];
     }
+    19 -> {20};
+    20 -> {21};
     21 -> {22};
-    22 -> {23};
-    23 -> {24};
 
-    subgraph cluster_8 {
+    subgraph cluster_7 {
         color=red
-        25 [label="Enter function run" style="filled" fillcolor=red];
-        subgraph cluster_9 {
+        23 [label="Enter function run" style="filled" fillcolor=red];
+        subgraph cluster_8 {
             color=blue
-            26 [label="Enter block"];
-            27 [label="Function call: R|<local>/block|.R|SubstitutionOverride<kotlin/Function0.invoke: R|R|>|()"];
-            28 [label="Jump: ^run R|<local>/block|.R|SubstitutionOverride<kotlin/Function0.invoke: R|R|>|()"];
-            29 [label="Stub" style="filled" fillcolor=gray];
-            30 [label="Exit block" style="filled" fillcolor=gray];
+            24 [label="Enter block"];
+            25 [label="Function call: R|<local>/block|.R|SubstitutionOverride<kotlin/Function0.invoke: R|R|>|()"];
+            26 [label="Jump: ^run R|<local>/block|.R|SubstitutionOverride<kotlin/Function0.invoke: R|R|>|()"];
+            27 [label="Stub" style="filled" fillcolor=gray];
+            28 [label="Exit block" style="filled" fillcolor=gray];
         }
-        31 [label="Exit function run" style="filled" fillcolor=red];
+        29 [label="Exit function run" style="filled" fillcolor=red];
     }
+    23 -> {24};
+    24 -> {25};
     25 -> {26};
-    26 -> {27};
-    27 -> {28};
-    28 -> {31};
+    26 -> {29};
+    26 -> {27} [style=dotted];
+    27 -> {28} [style=dotted];
     28 -> {29} [style=dotted];
-    29 -> {30} [style=dotted];
-    30 -> {31} [style=dotted];
 
 }

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

@@ -118,44 +118,49 @@ digraph loops_kt {
         subgraph cluster_13 {
             color=blue
             37 [label="Enter block"];
-            38 [label="Const: Int(0)"];
-            39 [label="Const: Int(5)"];
-            40 [label="Function call: Int(0).R|kotlin/Int.rangeTo|(...)"];
-            41 [label="Function call: Int(0).R|kotlin/Int.rangeTo|(...).R|kotlin/ranges/IntProgression.iterator|()"];
-            42 [label="Variable declaration: lval <iterator>: R|kotlin/collections/IntIterator|"];
             subgraph cluster_14 {
                 color=blue
-                43 [label="Enter while loop"];
+                38 [label="Enter block"];
+                39 [label="Const: Int(0)"];
+                40 [label="Const: Int(5)"];
+                41 [label="Function call: Int(0).R|kotlin/Int.rangeTo|(...)"];
+                42 [label="Function call: Int(0).R|kotlin/Int.rangeTo|(...).R|kotlin/ranges/IntProgression.iterator|()"];
+                43 [label="Variable declaration: lval <iterator>: R|kotlin/collections/IntIterator|"];
                 subgraph cluster_15 {
                     color=blue
-                    44 [label="Enter loop condition"];
-                    45 [label="Access variable R|<local>/<iterator>|"];
-                    46 [label="Function call: R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()"];
-                    47 [label="Exit loop condition"];
-                }
-                subgraph cluster_16 {
-                    color=blue
-                    48 [label="Enter loop block"];
+                    44 [label="Enter while loop"];
+                    subgraph cluster_16 {
+                        color=blue
+                        45 [label="Enter loop condition"];
+                        46 [label="Access variable R|<local>/<iterator>|"];
+                        47 [label="Function call: R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()"];
+                        48 [label="Exit loop condition"];
+                    }
                     subgraph cluster_17 {
                         color=blue
-                        49 [label="Enter block"];
-                        50 [label="Access variable R|<local>/<iterator>|"];
-                        51 [label="Function call: R|<local>/<iterator>|.R|kotlin/collections/IntIterator.next|()"];
-                        52 [label="Variable declaration: lval i: R|kotlin/Int|"];
-                        53 [label="Access variable R|<local>/x|"];
-                        54 [label="Type operator: (R|<local>/x| is R|kotlin/String|)"];
-                        55 [label="Variable declaration: lval y: R|kotlin/Boolean|"];
-                        56 [label="Exit block"];
+                        49 [label="Enter loop block"];
+                        subgraph cluster_18 {
+                            color=blue
+                            50 [label="Enter block"];
+                            51 [label="Access variable R|<local>/<iterator>|"];
+                            52 [label="Function call: R|<local>/<iterator>|.R|kotlin/collections/IntIterator.next|()"];
+                            53 [label="Variable declaration: lval i: R|kotlin/Int|"];
+                            54 [label="Access variable R|<local>/x|"];
+                            55 [label="Type operator: (R|<local>/x| is R|kotlin/String|)"];
+                            56 [label="Variable declaration: lval y: R|kotlin/Boolean|"];
+                            57 [label="Exit block"];
+                        }
+                        58 [label="Exit loop block"];
                     }
-                    57 [label="Exit loop block"];
+                    59 [label="Exit whileloop"];
                 }
-                58 [label="Exit whileloop"];
+                60 [label="Exit block"];
             }
-            59 [label="Access variable R|<local>/x|"];
-            60 [label="Type operator: (R|<local>/x| is R|kotlin/String|)"];
-            61 [label="Exit block"];
+            61 [label="Access variable R|<local>/x|"];
+            62 [label="Type operator: (R|<local>/x| is R|kotlin/String|)"];
+            63 [label="Exit block"];
         }
-        62 [label="Exit function testFor" style="filled" fillcolor=red];
+        64 [label="Exit function testFor" style="filled" fillcolor=red];
     }
     36 -> {37};
     37 -> {38};
@@ -168,8 +173,8 @@ digraph loops_kt {
     44 -> {45};
     45 -> {46};
     46 -> {47};
-    47 -> {58 48};
-    48 -> {49};
+    47 -> {48};
+    48 -> {59 49};
     49 -> {50};
     50 -> {51};
     51 -> {52};
@@ -178,226 +183,226 @@ digraph loops_kt {
     54 -> {55};
     55 -> {56};
     56 -> {57};
-    57 -> {44} [color=green style=dashed];
-    58 -> {59};
+    57 -> {58};
+    58 -> {45} [color=green style=dashed];
     59 -> {60};
     60 -> {61};
     61 -> {62};
+    62 -> {63};
+    63 -> {64};
 
-    subgraph cluster_18 {
+    subgraph cluster_19 {
         color=red
-        63 [label="Enter function testWhileTrue" style="filled" fillcolor=red];
-        subgraph cluster_19 {
+        65 [label="Enter function testWhileTrue" style="filled" fillcolor=red];
+        subgraph cluster_20 {
             color=blue
-            64 [label="Enter block"];
-            subgraph cluster_20 {
+            66 [label="Enter block"];
+            subgraph cluster_21 {
                 color=blue
-                65 [label="Enter while loop"];
-                subgraph cluster_21 {
-                    color=blue
-                    66 [label="Enter loop condition"];
-                    67 [label="Const: Boolean(true)"];
-                    68 [label="Exit loop condition"];
-                }
+                67 [label="Enter while loop"];
                 subgraph cluster_22 {
                     color=blue
-                    69 [label="Enter loop block"];
-                    subgraph cluster_23 {
-                        color=blue
-                        70 [label="Enter block"];
-                        71 [label="Const: Int(1)"];
-                        72 [label="Exit block"];
-                    }
-                    73 [label="Exit loop block"];
+                    68 [label="Enter loop condition"];
+                    69 [label="Const: Boolean(true)"];
+                    70 [label="Exit loop condition"];
                 }
-                74 [label="Exit whileloop" style="filled" fillcolor=gray];
+                subgraph cluster_23 {
+                    color=blue
+                    71 [label="Enter loop block"];
+                    subgraph cluster_24 {
+                        color=blue
+                        72 [label="Enter block"];
+                        73 [label="Const: Int(1)"];
+                        74 [label="Exit block"];
+                    }
+                    75 [label="Exit loop block"];
+                }
+                76 [label="Exit whileloop" style="filled" fillcolor=gray];
             }
-            75 [label="Const: Int(1)" style="filled" fillcolor=gray];
-            76 [label="Exit block" style="filled" fillcolor=gray];
+            77 [label="Const: Int(1)" style="filled" fillcolor=gray];
+            78 [label="Exit block" style="filled" fillcolor=gray];
         }
-        77 [label="Exit function testWhileTrue" style="filled" fillcolor=red style="filled" fillcolor=gray];
+        79 [label="Exit function testWhileTrue" style="filled" fillcolor=red style="filled" fillcolor=gray];
     }
-    63 -> {64};
-    64 -> {65};
     65 -> {66};
     66 -> {67};
     67 -> {68};
     68 -> {69};
-    68 -> {74} [style=dotted];
     69 -> {70};
     70 -> {71};
+    70 -> {76} [style=dotted];
     71 -> {72};
     72 -> {73};
-    73 -> {66} [color=green style=dashed];
-    74 -> {75} [style=dotted];
-    75 -> {76} [style=dotted];
+    73 -> {74};
+    74 -> {75};
+    75 -> {68} [color=green style=dashed];
     76 -> {77} [style=dotted];
+    77 -> {78} [style=dotted];
+    78 -> {79} [style=dotted];
 
-    subgraph cluster_24 {
+    subgraph cluster_25 {
         color=red
-        78 [label="Enter function testWhileTrueWithBreak" style="filled" fillcolor=red];
-        subgraph cluster_25 {
+        80 [label="Enter function testWhileTrueWithBreak" style="filled" fillcolor=red];
+        subgraph cluster_26 {
             color=blue
-            79 [label="Enter block"];
-            subgraph cluster_26 {
+            81 [label="Enter block"];
+            subgraph cluster_27 {
                 color=blue
-                80 [label="Enter while loop"];
-                subgraph cluster_27 {
-                    color=blue
-                    81 [label="Enter loop condition"];
-                    82 [label="Const: Boolean(true)"];
-                    83 [label="Exit loop condition"];
-                }
+                82 [label="Enter while loop"];
                 subgraph cluster_28 {
                     color=blue
-                    84 [label="Enter loop block"];
-                    subgraph cluster_29 {
+                    83 [label="Enter loop condition"];
+                    84 [label="Const: Boolean(true)"];
+                    85 [label="Exit loop condition"];
+                }
+                subgraph cluster_29 {
+                    color=blue
+                    86 [label="Enter loop block"];
+                    subgraph cluster_30 {
                         color=blue
-                        85 [label="Enter block"];
-                        subgraph cluster_30 {
+                        87 [label="Enter block"];
+                        subgraph cluster_31 {
                             color=blue
-                            86 [label="Enter when"];
-                            subgraph cluster_31 {
-                                color=blue
-                                87 [label="Enter when branch condition "];
-                                88 [label="Access variable R|<local>/b|"];
-                                89 [label="Exit when branch condition"];
-                            }
-                            90 [label="Synthetic else branch"];
-                            91 [label="Enter when branch result"];
+                            88 [label="Enter when"];
                             subgraph cluster_32 {
                                 color=blue
-                                92 [label="Enter block"];
-                                93 [label="Jump: break@@@[Boolean(true)] "];
-                                94 [label="Stub" style="filled" fillcolor=gray];
-                                95 [label="Exit block" style="filled" fillcolor=gray];
+                                89 [label="Enter when branch condition "];
+                                90 [label="Access variable R|<local>/b|"];
+                                91 [label="Exit when branch condition"];
                             }
-                            96 [label="Exit when branch result" style="filled" fillcolor=gray];
-                            97 [label="Exit when"];
+                            92 [label="Synthetic else branch"];
+                            93 [label="Enter when branch result"];
+                            subgraph cluster_33 {
+                                color=blue
+                                94 [label="Enter block"];
+                                95 [label="Jump: break@@@[Boolean(true)] "];
+                                96 [label="Stub" style="filled" fillcolor=gray];
+                                97 [label="Exit block" style="filled" fillcolor=gray];
+                            }
+                            98 [label="Exit when branch result" style="filled" fillcolor=gray];
+                            99 [label="Exit when"];
                         }
-                        98 [label="Exit block"];
+                        100 [label="Exit block"];
                     }
-                    99 [label="Exit loop block"];
+                    101 [label="Exit loop block"];
                 }
-                100 [label="Exit whileloop"];
+                102 [label="Exit whileloop"];
             }
-            101 [label="Const: Int(1)"];
-            102 [label="Exit block"];
+            103 [label="Const: Int(1)"];
+            104 [label="Exit block"];
         }
-        103 [label="Exit function testWhileTrueWithBreak" style="filled" fillcolor=red];
+        105 [label="Exit function testWhileTrueWithBreak" style="filled" fillcolor=red];
     }
-    78 -> {79};
-    79 -> {80};
     80 -> {81};
     81 -> {82};
     82 -> {83};
     83 -> {84};
-    83 -> {100} [style=dotted];
     84 -> {85};
     85 -> {86};
+    85 -> {102} [style=dotted];
     86 -> {87};
     87 -> {88};
     88 -> {89};
-    89 -> {91 90};
-    90 -> {97};
-    91 -> {92};
-    92 -> {93};
-    93 -> {100};
-    93 -> {94} [style=dotted];
-    94 -> {95} [style=dotted];
+    89 -> {90};
+    90 -> {91};
+    91 -> {93 92};
+    92 -> {99};
+    93 -> {94};
+    94 -> {95};
+    95 -> {102};
     95 -> {96} [style=dotted];
     96 -> {97} [style=dotted];
-    97 -> {98};
-    98 -> {99};
-    99 -> {81} [color=green style=dashed];
+    97 -> {98} [style=dotted];
+    98 -> {99} [style=dotted];
+    99 -> {100};
     100 -> {101};
-    101 -> {102};
+    101 -> {83} [color=green style=dashed];
     102 -> {103};
+    103 -> {104};
+    104 -> {105};
 
-    subgraph cluster_33 {
+    subgraph cluster_34 {
         color=red
-        104 [label="Enter function testWhileFalse" style="filled" fillcolor=red];
-        subgraph cluster_34 {
+        106 [label="Enter function testWhileFalse" style="filled" fillcolor=red];
+        subgraph cluster_35 {
             color=blue
-            105 [label="Enter block"];
-            subgraph cluster_35 {
+            107 [label="Enter block"];
+            subgraph cluster_36 {
                 color=blue
-                106 [label="Enter while loop"];
-                subgraph cluster_36 {
-                    color=blue
-                    107 [label="Enter loop condition"];
-                    108 [label="Const: Boolean(false)"];
-                    109 [label="Exit loop condition"];
-                }
+                108 [label="Enter while loop"];
                 subgraph cluster_37 {
                     color=blue
-                    110 [label="Enter loop block" style="filled" fillcolor=gray];
-                    subgraph cluster_38 {
-                        color=blue
-                        111 [label="Enter block" style="filled" fillcolor=gray];
-                        112 [label="Const: Int(1)" style="filled" fillcolor=gray];
-                        113 [label="Exit block" style="filled" fillcolor=gray];
-                    }
-                    114 [label="Exit loop block" style="filled" fillcolor=gray];
+                    109 [label="Enter loop condition"];
+                    110 [label="Const: Boolean(false)"];
+                    111 [label="Exit loop condition"];
                 }
-                115 [label="Exit whileloop"];
+                subgraph cluster_38 {
+                    color=blue
+                    112 [label="Enter loop block" style="filled" fillcolor=gray];
+                    subgraph cluster_39 {
+                        color=blue
+                        113 [label="Enter block" style="filled" fillcolor=gray];
+                        114 [label="Const: Int(1)" style="filled" fillcolor=gray];
+                        115 [label="Exit block" style="filled" fillcolor=gray];
+                    }
+                    116 [label="Exit loop block" style="filled" fillcolor=gray];
+                }
+                117 [label="Exit whileloop"];
             }
-            116 [label="Const: Int(1)"];
-            117 [label="Exit block"];
+            118 [label="Const: Int(1)"];
+            119 [label="Exit block"];
         }
-        118 [label="Exit function testWhileFalse" style="filled" fillcolor=red];
+        120 [label="Exit function testWhileFalse" style="filled" fillcolor=red];
     }
-    104 -> {105};
-    105 -> {106};
     106 -> {107};
     107 -> {108};
     108 -> {109};
-    109 -> {115};
-    109 -> {110} [style=dotted];
-    110 -> {111} [style=dotted];
+    109 -> {110};
+    110 -> {111};
+    111 -> {117};
     111 -> {112} [style=dotted];
     112 -> {113} [style=dotted];
     113 -> {114} [style=dotted];
-    114 -> {107} [color=green style=dotted];
-    115 -> {116};
-    116 -> {117};
+    114 -> {115} [style=dotted];
+    115 -> {116} [style=dotted];
+    116 -> {109} [color=green style=dotted];
     117 -> {118};
-
-    subgraph cluster_39 {
-        color=red
-        119 [label="Enter function testDoWhileTrue" style="filled" fillcolor=red];
-        subgraph cluster_40 {
-            color=blue
-            120 [label="Enter block"];
-            subgraph cluster_41 {
-                color=blue
-                121 [label="Enter do-while loop"];
-                subgraph cluster_42 {
-                    color=blue
-                    122 [label="Enter loop block"];
-                    subgraph cluster_43 {
-                        color=blue
-                        123 [label="Enter block"];
-                        124 [label="Const: Int(1)"];
-                        125 [label="Exit block"];
-                    }
-                    126 [label="Exit loop block"];
-                }
-                subgraph cluster_44 {
-                    color=blue
-                    127 [label="Enter loop condition"];
-                    128 [label="Const: Boolean(true)"];
-                    129 [label="Exit loop condition"];
-                }
-                130 [label="Exit do-whileloop" style="filled" fillcolor=gray];
-            }
-            131 [label="Const: Int(1)" style="filled" fillcolor=gray];
-            132 [label="Exit block" style="filled" fillcolor=gray];
-        }
-        133 [label="Exit function testDoWhileTrue" style="filled" fillcolor=red style="filled" fillcolor=gray];
-    }
+    118 -> {119};
     119 -> {120};
-    120 -> {121};
+
+    subgraph cluster_40 {
+        color=red
+        121 [label="Enter function testDoWhileTrue" style="filled" fillcolor=red];
+        subgraph cluster_41 {
+            color=blue
+            122 [label="Enter block"];
+            subgraph cluster_42 {
+                color=blue
+                123 [label="Enter do-while loop"];
+                subgraph cluster_43 {
+                    color=blue
+                    124 [label="Enter loop block"];
+                    subgraph cluster_44 {
+                        color=blue
+                        125 [label="Enter block"];
+                        126 [label="Const: Int(1)"];
+                        127 [label="Exit block"];
+                    }
+                    128 [label="Exit loop block"];
+                }
+                subgraph cluster_45 {
+                    color=blue
+                    129 [label="Enter loop condition"];
+                    130 [label="Const: Boolean(true)"];
+                    131 [label="Exit loop condition"];
+                }
+                132 [label="Exit do-whileloop" style="filled" fillcolor=gray];
+            }
+            133 [label="Const: Int(1)" style="filled" fillcolor=gray];
+            134 [label="Exit block" style="filled" fillcolor=gray];
+        }
+        135 [label="Exit function testDoWhileTrue" style="filled" fillcolor=red style="filled" fillcolor=gray];
+    }
     121 -> {122};
     122 -> {123};
     123 -> {124};
@@ -406,128 +411,128 @@ digraph loops_kt {
     126 -> {127};
     127 -> {128};
     128 -> {129};
-    129 -> {130} [style=dotted];
-    129 -> {122} [color=green style=dashed];
-    130 -> {131} [style=dotted];
+    129 -> {130};
+    130 -> {131};
     131 -> {132} [style=dotted];
+    131 -> {124} [color=green style=dashed];
     132 -> {133} [style=dotted];
+    133 -> {134} [style=dotted];
+    134 -> {135} [style=dotted];
 
-    subgraph cluster_45 {
+    subgraph cluster_46 {
         color=red
-        134 [label="Enter function testDoWhileTrueWithBreak" style="filled" fillcolor=red];
-        subgraph cluster_46 {
+        136 [label="Enter function testDoWhileTrueWithBreak" style="filled" fillcolor=red];
+        subgraph cluster_47 {
             color=blue
-            135 [label="Enter block"];
-            subgraph cluster_47 {
+            137 [label="Enter block"];
+            subgraph cluster_48 {
                 color=blue
-                136 [label="Enter do-while loop"];
-                subgraph cluster_48 {
+                138 [label="Enter do-while loop"];
+                subgraph cluster_49 {
                     color=blue
-                    137 [label="Enter loop block"];
-                    subgraph cluster_49 {
+                    139 [label="Enter loop block"];
+                    subgraph cluster_50 {
                         color=blue
-                        138 [label="Enter block"];
-                        subgraph cluster_50 {
+                        140 [label="Enter block"];
+                        subgraph cluster_51 {
                             color=blue
-                            139 [label="Enter when"];
-                            subgraph cluster_51 {
-                                color=blue
-                                140 [label="Enter when branch condition "];
-                                141 [label="Access variable R|<local>/b|"];
-                                142 [label="Exit when branch condition"];
-                            }
-                            143 [label="Synthetic else branch"];
-                            144 [label="Enter when branch result"];
+                            141 [label="Enter when"];
                             subgraph cluster_52 {
                                 color=blue
-                                145 [label="Enter block"];
-                                146 [label="Jump: break@@@[Boolean(true)] "];
-                                147 [label="Stub" style="filled" fillcolor=gray];
-                                148 [label="Exit block" style="filled" fillcolor=gray];
+                                142 [label="Enter when branch condition "];
+                                143 [label="Access variable R|<local>/b|"];
+                                144 [label="Exit when branch condition"];
                             }
-                            149 [label="Exit when branch result" style="filled" fillcolor=gray];
-                            150 [label="Exit when"];
+                            145 [label="Synthetic else branch"];
+                            146 [label="Enter when branch result"];
+                            subgraph cluster_53 {
+                                color=blue
+                                147 [label="Enter block"];
+                                148 [label="Jump: break@@@[Boolean(true)] "];
+                                149 [label="Stub" style="filled" fillcolor=gray];
+                                150 [label="Exit block" style="filled" fillcolor=gray];
+                            }
+                            151 [label="Exit when branch result" style="filled" fillcolor=gray];
+                            152 [label="Exit when"];
                         }
-                        151 [label="Exit block"];
+                        153 [label="Exit block"];
                     }
-                    152 [label="Exit loop block"];
+                    154 [label="Exit loop block"];
                 }
-                subgraph cluster_53 {
+                subgraph cluster_54 {
                     color=blue
-                    153 [label="Enter loop condition"];
-                    154 [label="Const: Boolean(true)"];
-                    155 [label="Exit loop condition"];
+                    155 [label="Enter loop condition"];
+                    156 [label="Const: Boolean(true)"];
+                    157 [label="Exit loop condition"];
                 }
-                156 [label="Exit do-whileloop"];
+                158 [label="Exit do-whileloop"];
             }
-            157 [label="Const: Int(1)"];
-            158 [label="Exit block"];
+            159 [label="Const: Int(1)"];
+            160 [label="Exit block"];
         }
-        159 [label="Exit function testDoWhileTrueWithBreak" style="filled" fillcolor=red];
+        161 [label="Exit function testDoWhileTrueWithBreak" style="filled" fillcolor=red];
     }
-    134 -> {135};
-    135 -> {136};
     136 -> {137};
     137 -> {138};
     138 -> {139};
     139 -> {140};
     140 -> {141};
     141 -> {142};
-    142 -> {144 143};
-    143 -> {150};
-    144 -> {145};
-    145 -> {146};
-    146 -> {156};
-    146 -> {147} [style=dotted];
-    147 -> {148} [style=dotted];
+    142 -> {143};
+    143 -> {144};
+    144 -> {146 145};
+    145 -> {152};
+    146 -> {147};
+    147 -> {148};
+    148 -> {158};
     148 -> {149} [style=dotted];
     149 -> {150} [style=dotted];
-    150 -> {151};
-    151 -> {152};
+    150 -> {151} [style=dotted];
+    151 -> {152} [style=dotted];
     152 -> {153};
     153 -> {154};
     154 -> {155};
-    155 -> {156} [style=dotted];
-    155 -> {137} [color=green style=dashed];
+    155 -> {156};
     156 -> {157};
-    157 -> {158};
+    157 -> {158} [style=dotted];
+    157 -> {139} [color=green style=dashed];
     158 -> {159};
-
-    subgraph cluster_54 {
-        color=red
-        160 [label="Enter function testDoWhileFalse" style="filled" fillcolor=red];
-        subgraph cluster_55 {
-            color=blue
-            161 [label="Enter block"];
-            subgraph cluster_56 {
-                color=blue
-                162 [label="Enter do-while loop"];
-                subgraph cluster_57 {
-                    color=blue
-                    163 [label="Enter loop block"];
-                    subgraph cluster_58 {
-                        color=blue
-                        164 [label="Enter block"];
-                        165 [label="Const: Int(1)"];
-                        166 [label="Exit block"];
-                    }
-                    167 [label="Exit loop block"];
-                }
-                subgraph cluster_59 {
-                    color=blue
-                    168 [label="Enter loop condition"];
-                    169 [label="Const: Boolean(false)"];
-                    170 [label="Exit loop condition"];
-                }
-                171 [label="Exit do-whileloop"];
-            }
-            172 [label="Const: Int(1)"];
-            173 [label="Exit block"];
-        }
-        174 [label="Exit function testDoWhileFalse" style="filled" fillcolor=red];
-    }
+    159 -> {160};
     160 -> {161};
-    161 -> {162};
+
+    subgraph cluster_55 {
+        color=red
+        162 [label="Enter function testDoWhileFalse" style="filled" fillcolor=red];
+        subgraph cluster_56 {
+            color=blue
+            163 [label="Enter block"];
+            subgraph cluster_57 {
+                color=blue
+                164 [label="Enter do-while loop"];
+                subgraph cluster_58 {
+                    color=blue
+                    165 [label="Enter loop block"];
+                    subgraph cluster_59 {
+                        color=blue
+                        166 [label="Enter block"];
+                        167 [label="Const: Int(1)"];
+                        168 [label="Exit block"];
+                    }
+                    169 [label="Exit loop block"];
+                }
+                subgraph cluster_60 {
+                    color=blue
+                    170 [label="Enter loop condition"];
+                    171 [label="Const: Boolean(false)"];
+                    172 [label="Exit loop condition"];
+                }
+                173 [label="Exit do-whileloop"];
+            }
+            174 [label="Const: Int(1)"];
+            175 [label="Exit block"];
+        }
+        176 [label="Exit function testDoWhileFalse" style="filled" fillcolor=red];
+    }
     162 -> {163};
     163 -> {164};
     164 -> {165};
@@ -537,9 +542,11 @@ digraph loops_kt {
     168 -> {169};
     169 -> {170};
     170 -> {171};
-    170 -> {163} [color=green style=dotted];
     171 -> {172};
     172 -> {173};
+    172 -> {165} [color=green style=dotted];
     173 -> {174};
+    174 -> {175};
+    175 -> {176};
 
 }

compiler/fir/analysis-tests/testData/resolve/cfg/loops.fir.txt

@@ -14,10 +14,13 @@ FILE: loops.kt
         (R|<local>/x| is R|kotlin/String|)
     }
     public final fun testFor(x: R|kotlin/Any?|): R|kotlin/Unit| {
-        lval <iterator>: R|kotlin/collections/IntIterator| = Int(0).R|kotlin/Int.rangeTo|(Int(5)).R|kotlin/ranges/IntProgression.iterator|()
-        while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
-            lval i: R|kotlin/Int| = R|<local>/<iterator>|.R|kotlin/collections/IntIterator.next|()
-            lval y: R|kotlin/Boolean| = (R|<local>/x| is R|kotlin/String|)
+         {
+            lval <iterator>: R|kotlin/collections/IntIterator| = Int(0).R|kotlin/Int.rangeTo|(Int(5)).R|kotlin/ranges/IntProgression.iterator|()
+            while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
+                lval i: R|kotlin/Int| = R|<local>/<iterator>|.R|kotlin/collections/IntIterator.next|()
+                lval y: R|kotlin/Boolean| = (R|<local>/x| is R|kotlin/String|)
+            }
+
         }
 
         (R|<local>/x| is R|kotlin/String|)

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

@@ -27,8 +27,8 @@ digraph postponedLambdaInConstructor_kt {
     }
     5 -> {6} [color=green];
     6 -> {7} [style=dotted];
-    6 -> {29} [color=green];
-    6 -> {29} [style=dashed];
+    6 -> {27} [color=green];
+    6 -> {27} [style=dashed];
 
     subgraph cluster_3 {
         color=red
@@ -88,35 +88,28 @@ digraph postponedLambdaInConstructor_kt {
 
     subgraph cluster_8 {
         color=red
-        27 [label="Enter function getter" style="filled" fillcolor=red];
-        28 [label="Exit function getter" style="filled" fillcolor=red];
+        27 [label="Enter property" style="filled" fillcolor=red];
+        28 [label="Access variable R|<local>/s|"];
+        29 [label="Exit property" style="filled" fillcolor=red];
     }
     27 -> {28};
+    28 -> {29};
+    29 -> {7} [color=green];
 
     subgraph cluster_9 {
         color=red
-        29 [label="Enter property" style="filled" fillcolor=red];
-        30 [label="Access variable R|<local>/s|"];
-        31 [label="Exit property" style="filled" fillcolor=red];
-    }
-    29 -> {30};
-    30 -> {31};
-    31 -> {7} [color=green];
-
-    subgraph cluster_10 {
-        color=red
-        32 [label="Enter function foo" style="filled" fillcolor=red];
-        subgraph cluster_11 {
+        30 [label="Enter function foo" style="filled" fillcolor=red];
+        subgraph cluster_10 {
             color=blue
-            33 [label="Enter block"];
-            34 [label="Function call: this@R|/B|.R|/B.foo|()"];
-            35 [label="Exit block"];
+            31 [label="Enter block"];
+            32 [label="Function call: this@R|/B|.R|/B.foo|()"];
+            33 [label="Exit block"];
         }
-        36 [label="Exit function foo" style="filled" fillcolor=red];
+        34 [label="Exit function foo" style="filled" fillcolor=red];
     }
+    30 -> {31};
+    31 -> {32};
     32 -> {33};
     33 -> {34};
-    34 -> {35};
-    35 -> {36};
 
 }

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

@@ -21,312 +21,298 @@ digraph propertiesAndInitBlocks_kt {
 
     subgraph cluster_2 {
         color=red
-        5 [label="Enter function getter" style="filled" fillcolor=red];
-        6 [label="Exit function getter" style="filled" fillcolor=red];
+        5 [label="Enter property" style="filled" fillcolor=red];
+        6 [label="Const: Int(1)"];
+        7 [label="Exit property" style="filled" fillcolor=red];
     }
     5 -> {6};
+    6 -> {7};
 
     subgraph cluster_3 {
         color=red
-        7 [label="Enter property" style="filled" fillcolor=red];
-        8 [label="Const: Int(1)"];
-        9 [label="Exit property" style="filled" fillcolor=red];
+        8 [label="Enter function getter" style="filled" fillcolor=red];
+        subgraph cluster_4 {
+            color=blue
+            9 [label="Enter block"];
+            10 [label="Const: Int(1)"];
+            11 [label="Jump: ^ Int(1)"];
+            12 [label="Stub" style="filled" fillcolor=gray];
+            13 [label="Exit block" style="filled" fillcolor=gray];
+        }
+        14 [label="Exit function getter" style="filled" fillcolor=red];
     }
-    7 -> {8};
     8 -> {9};
-
-    subgraph cluster_4 {
-        color=red
-        10 [label="Enter function getter" style="filled" fillcolor=red];
-        subgraph cluster_5 {
-            color=blue
-            11 [label="Enter block"];
-            12 [label="Const: Int(1)"];
-            13 [label="Jump: ^ Int(1)"];
-            14 [label="Stub" style="filled" fillcolor=gray];
-            15 [label="Exit block" style="filled" fillcolor=gray];
-        }
-        16 [label="Exit function getter" style="filled" fillcolor=red];
-    }
+    9 -> {10};
     10 -> {11};
-    11 -> {12};
-    12 -> {13};
-    13 -> {16};
+    11 -> {14};
+    11 -> {12} [style=dotted];
+    12 -> {13} [style=dotted];
     13 -> {14} [style=dotted];
-    14 -> {15} [style=dotted];
-    15 -> {16} [style=dotted];
 
-    subgraph cluster_6 {
+    subgraph cluster_5 {
         color=red
-        17 [label="Enter function setter" style="filled" fillcolor=red];
-        subgraph cluster_7 {
+        15 [label="Enter function setter" style="filled" fillcolor=red];
+        subgraph cluster_6 {
             color=blue
-            18 [label="Enter block"];
-            19 [label="Const: Int(1)"];
-            20 [label="Assignment: F|/x2|"];
-            21 [label="Exit block"];
+            16 [label="Enter block"];
+            17 [label="Const: Int(1)"];
+            18 [label="Assignment: F|/x2|"];
+            19 [label="Exit block"];
         }
-        22 [label="Exit function setter" style="filled" fillcolor=red];
+        20 [label="Exit function setter" style="filled" fillcolor=red];
     }
+    15 -> {16};
+    16 -> {17};
     17 -> {18};
     18 -> {19};
     19 -> {20};
-    20 -> {21};
+
+    subgraph cluster_7 {
+        color=red
+        21 [label="Enter property" style="filled" fillcolor=red];
+        22 [label="Const: Int(1)"];
+        23 [label="Exit property" style="filled" fillcolor=red];
+    }
     21 -> {22};
+    22 -> {23};
 
     subgraph cluster_8 {
         color=red
-        23 [label="Enter property" style="filled" fillcolor=red];
-        24 [label="Const: Int(1)"];
-        25 [label="Exit property" style="filled" fillcolor=red];
-    }
-    23 -> {24};
-    24 -> {25};
-
-    subgraph cluster_9 {
-        color=red
-        37 [label="Enter function foo" style="filled" fillcolor=red];
-        subgraph cluster_10 {
+        35 [label="Enter function foo" style="filled" fillcolor=red];
+        subgraph cluster_9 {
             color=blue
-            38 [label="Enter block"];
-            39 [label="Const: Int(1)"];
-            40 [label="Const: Int(1)"];
-            41 [label="Function call: Int(1).R|kotlin/Int.plus|(...)"];
-            42 [label="Variable declaration: lval c: R|kotlin/Int|"];
-            43 [label="Function call: R|java/lang/Exception.Exception|()"];
-            44 [label="Throw: throw R|java/lang/Exception.Exception|()"];
-            45 [label="Stub" style="filled" fillcolor=gray];
-            46 [label="Exit block" style="filled" fillcolor=gray];
+            36 [label="Enter block"];
+            37 [label="Const: Int(1)"];
+            38 [label="Const: Int(1)"];
+            39 [label="Function call: Int(1).R|kotlin/Int.plus|(...)"];
+            40 [label="Variable declaration: lval c: R|kotlin/Int|"];
+            41 [label="Function call: R|java/lang/Exception.Exception|()"];
+            42 [label="Throw: throw R|java/lang/Exception.Exception|()"];
+            43 [label="Stub" style="filled" fillcolor=gray];
+            44 [label="Exit block" style="filled" fillcolor=gray];
         }
-        47 [label="Exit function foo" style="filled" fillcolor=red];
+        45 [label="Exit function foo" style="filled" fillcolor=red];
     }
+    35 -> {36};
+    36 -> {37};
     37 -> {38};
     38 -> {39};
     39 -> {40};
     40 -> {41};
     41 -> {42};
-    42 -> {43};
-    43 -> {44};
-    44 -> {47}    [label=onUncaughtException];
+    42 -> {45}    [label=onUncaughtException];
+    42 -> {43} [style=dotted];
+    43 -> {44} [style=dotted];
     44 -> {45} [style=dotted];
-    45 -> {46} [style=dotted];
-    46 -> {47} [style=dotted];
+
+    subgraph cluster_10 {
+        color=red
+        46 [label="Enter function <init>" style="filled" fillcolor=red];
+        47 [label="Delegated constructor call: super<R|kotlin/Any|>()"];
+        48 [label="Exit function <init>" style="filled" fillcolor=red];
+    }
+    46 -> {47};
+    47 -> {48};
 
     subgraph cluster_11 {
         color=red
-        48 [label="Enter function <init>" style="filled" fillcolor=red];
-        49 [label="Delegated constructor call: super<R|kotlin/Any|>()"];
-        50 [label="Exit function <init>" style="filled" fillcolor=red];
-    }
-    48 -> {49};
-    49 -> {50};
-
-    subgraph cluster_12 {
-        color=red
-        51 [label="Enter init block" style="filled" fillcolor=red];
-        subgraph cluster_13 {
+        49 [label="Enter init block" style="filled" fillcolor=red];
+        subgraph cluster_12 {
             color=blue
-            52 [label="Enter block"];
-            53 [label="Function call: R|java/lang/Exception.Exception|()"];
-            54 [label="Throw: throw R|java/lang/Exception.Exception|()"];
-            55 [label="Stub" style="filled" fillcolor=gray];
-            56 [label="Const: Int(1)" style="filled" fillcolor=gray];
-            57 [label="Exit block" style="filled" fillcolor=gray];
+            50 [label="Enter block"];
+            51 [label="Function call: R|java/lang/Exception.Exception|()"];
+            52 [label="Throw: throw R|java/lang/Exception.Exception|()"];
+            53 [label="Stub" style="filled" fillcolor=gray];
+            54 [label="Const: Int(1)" style="filled" fillcolor=gray];
+            55 [label="Exit block" style="filled" fillcolor=gray];
         }
-        58 [label="Exit init block" style="filled" fillcolor=red];
+        56 [label="Exit init block" style="filled" fillcolor=red];
     }
+    49 -> {50};
+    50 -> {51};
     51 -> {52};
-    52 -> {53};
-    53 -> {54};
-    54 -> {58}    [label=onUncaughtException];
+    52 -> {56}    [label=onUncaughtException];
+    52 -> {53} [style=dotted];
+    53 -> {54} [style=dotted];
     54 -> {55} [style=dotted];
     55 -> {56} [style=dotted];
-    56 -> {57} [style=dotted];
-    57 -> {58} [style=dotted];
-    58 -> {36} [color=green];
+    56 -> {34} [color=green];
 
-    subgraph cluster_14 {
+    subgraph cluster_13 {
         color=red
-        59 [label="Enter function getter" style="filled" fillcolor=red];
-        subgraph cluster_15 {
+        57 [label="Enter function getter" style="filled" fillcolor=red];
+        subgraph cluster_14 {
             color=blue
-            60 [label="Enter block"];
-            61 [label="Exit local class <getter>"];
-            62 [label="Exit block"];
+            58 [label="Enter block"];
+            59 [label="Exit local class <getter>"];
+            60 [label="Exit block"];
         }
-        63 [label="Exit function getter" style="filled" fillcolor=red];
+        61 [label="Exit function getter" style="filled" fillcolor=red];
     }
-    subgraph cluster_16 {
+    subgraph cluster_15 {
         color=blue
-        64 [label="Enter class GetterLocalClass" style="filled" fillcolor=red];
-        65 [label="Part of class initialization"];
-        66 [label="Exit class GetterLocalClass" style="filled" fillcolor=red];
+        62 [label="Enter class GetterLocalClass" style="filled" fillcolor=red];
+        63 [label="Part of class initialization"];
+        64 [label="Exit class GetterLocalClass" style="filled" fillcolor=red];
     }
+    57 -> {58};
+    58 -> {59};
+    58 -> {65 68} [color=red];
     59 -> {60};
+    59 -> {65 62} [color=green];
+    59 -> {65 62} [style=dashed];
     60 -> {61};
-    60 -> {67 70} [color=red];
-    61 -> {62};
-    61 -> {67 64} [color=green];
-    61 -> {67 64} [style=dashed];
-    62 -> {63};
-    64 -> {65} [color=green];
-    65 -> {66} [style=dotted];
-    65 -> {70} [color=green];
-    65 -> {70} [style=dashed];
+    62 -> {63} [color=green];
+    63 -> {64} [style=dotted];
+    63 -> {68} [color=green];
+    63 -> {68} [style=dashed];
+
+    subgraph cluster_16 {
+        color=red
+        65 [label="Enter function <init>" style="filled" fillcolor=red];
+        66 [label="Delegated constructor call: super<R|kotlin/Any|>()"];
+        67 [label="Exit function <init>" style="filled" fillcolor=red];
+    }
+    65 -> {66};
+    66 -> {67};
 
     subgraph cluster_17 {
         color=red
-        67 [label="Enter function <init>" style="filled" fillcolor=red];
-        68 [label="Delegated constructor call: super<R|kotlin/Any|>()"];
-        69 [label="Exit function <init>" style="filled" fillcolor=red];
-    }
-    67 -> {68};
-    68 -> {69};
-
-    subgraph cluster_18 {
-        color=red
-        70 [label="Enter init block" style="filled" fillcolor=red];
-        subgraph cluster_19 {
+        68 [label="Enter init block" style="filled" fillcolor=red];
+        subgraph cluster_18 {
             color=blue
-            71 [label="Enter block"];
-            72 [label="Function call: R|java/lang/Exception.Exception|()"];
-            73 [label="Throw: throw R|java/lang/Exception.Exception|()"];
-            74 [label="Stub" style="filled" fillcolor=gray];
-            75 [label="Exit block" style="filled" fillcolor=gray];
+            69 [label="Enter block"];
+            70 [label="Function call: R|java/lang/Exception.Exception|()"];
+            71 [label="Throw: throw R|java/lang/Exception.Exception|()"];
+            72 [label="Stub" style="filled" fillcolor=gray];
+            73 [label="Exit block" style="filled" fillcolor=gray];
         }
-        76 [label="Exit init block" style="filled" fillcolor=red];
+        74 [label="Exit init block" style="filled" fillcolor=red];
     }
+    68 -> {69};
+    69 -> {70};
     70 -> {71};
-    71 -> {72};
-    72 -> {73};
-    73 -> {76}    [label=onUncaughtException];
+    71 -> {74}    [label=onUncaughtException];
+    71 -> {72} [style=dotted];
+    72 -> {73} [style=dotted];
     73 -> {74} [style=dotted];
-    74 -> {75} [style=dotted];
-    75 -> {76} [style=dotted];
-    76 -> {66} [color=green];
+    74 -> {64} [color=green];
 
-    subgraph cluster_20 {
+    subgraph cluster_19 {
         color=red
-        77 [label="Enter property" style="filled" fillcolor=red];
-        78 [label="Postponed enter to lambda"];
-        subgraph cluster_21 {
+        75 [label="Enter property" style="filled" fillcolor=red];
+        76 [label="Postponed enter to lambda"];
+        subgraph cluster_20 {
             color=blue
-            26 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+            24 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+            subgraph cluster_21 {
+                color=blue
+                25 [label="Enter block"];
+                26 [label="Exit local class <anonymous>"];
+                27 [label="Function call: R|java/lang/Exception.Exception|()"];
+                28 [label="Throw: throw R|java/lang/Exception.Exception|()"];
+                29 [label="Stub" style="filled" fillcolor=gray];
+                30 [label="Exit block" style="filled" fillcolor=gray];
+            }
             subgraph cluster_22 {
                 color=blue
-                27 [label="Enter block"];
-                28 [label="Exit local class <anonymous>"];
-                29 [label="Function call: R|java/lang/Exception.Exception|()"];
-                30 [label="Throw: throw R|java/lang/Exception.Exception|()"];
-                31 [label="Stub" style="filled" fillcolor=gray];
-                32 [label="Exit block" style="filled" fillcolor=gray];
+                32 [label="Enter class InitializerLocalClass" style="filled" fillcolor=red];
+                33 [label="Part of class initialization"];
+                34 [label="Exit class InitializerLocalClass" style="filled" fillcolor=red];
             }
-            subgraph cluster_23 {
-                color=blue
-                34 [label="Enter class InitializerLocalClass" style="filled" fillcolor=red];
-                35 [label="Part of class initialization"];
-                36 [label="Exit class InitializerLocalClass" style="filled" fillcolor=red];
-            }
-            33 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
+            31 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
         }
-        79 [label="Postponed exit from lambda"];
-        80 [label="Function call: R|/run|(...)"];
-        81 [label="Exit property" style="filled" fillcolor=red];
+        77 [label="Postponed exit from lambda"];
+        78 [label="Function call: R|/run|(...)"];
+        79 [label="Exit property" style="filled" fillcolor=red];
     }
+    75 -> {76};
+    76 -> {24};
+    76 -> {77} [color=red];
+    76 -> {24} [style=dashed];
     77 -> {78};
-    78 -> {26};
-    78 -> {79} [color=red];
-    78 -> {26} [style=dashed];
-    79 -> {80};
-    80 -> {81};
-    26 -> {33 27};
+    78 -> {79};
+    24 -> {31 25};
+    25 -> {26};
+    25 -> {35 46 49} [color=red];
+    26 -> {27};
+    26 -> {46 32} [color=green];
+    26 -> {46 32} [style=dashed];
     27 -> {28};
-    27 -> {37 48 51} [color=red];
-    28 -> {29};
-    28 -> {48 34} [color=green];
-    28 -> {48 34} [style=dashed];
-    29 -> {30};
-    30 -> {81}    [label=onUncaughtException];
+    28 -> {79}    [label=onUncaughtException];
+    28 -> {29} [style=dotted];
+    29 -> {30} [style=dotted];
     30 -> {31} [style=dotted];
-    31 -> {32} [style=dotted];
-    32 -> {33} [style=dotted];
-    33 -> {79} [color=green];
-    33 -> {26} [color=green style=dashed];
-    34 -> {35} [color=green];
-    35 -> {36} [style=dotted];
-    35 -> {51} [color=green];
-    35 -> {51} [style=dashed];
+    31 -> {77} [color=green];
+    31 -> {24} [color=green style=dashed];
+    32 -> {33} [color=green];
+    33 -> {34} [style=dotted];
+    33 -> {49} [color=green];
+    33 -> {49} [style=dashed];
 
-    subgraph cluster_24 {
+    subgraph cluster_23 {
         color=red
-        82 [label="Enter function getter" style="filled" fillcolor=red];
-        83 [label="Exit function getter" style="filled" fillcolor=red];
-    }
-    82 -> {83};
-
-    subgraph cluster_25 {
-        color=red
-        84 [label="Enter property" style="filled" fillcolor=red];
-        subgraph cluster_26 {
+        80 [label="Enter property" style="filled" fillcolor=red];
+        subgraph cluster_24 {
             color=blue
-            85 [label="Try expression enter"];
+            81 [label="Try expression enter"];
+            subgraph cluster_25 {
+                color=blue
+                82 [label="Try main block enter"];
+                subgraph cluster_26 {
+                    color=blue
+                    83 [label="Enter block"];
+                    84 [label="Const: Int(1)"];
+                    85 [label="Exit block"];
+                }
+                86 [label="Try main block exit"];
+            }
             subgraph cluster_27 {
                 color=blue
-                86 [label="Try main block enter"];
+                87 [label="Catch enter"];
                 subgraph cluster_28 {
                     color=blue
-                    87 [label="Enter block"];
-                    88 [label="Const: Int(1)"];
-                    89 [label="Exit block"];
+                    88 [label="Enter block"];
+                    89 [label="Const: Int(2)"];
+                    90 [label="Exit block"];
                 }
-                90 [label="Try main block exit"];
+                91 [label="Catch exit"];
             }
             subgraph cluster_29 {
                 color=blue
-                91 [label="Catch enter"];
+                92 [label="Enter finally"];
                 subgraph cluster_30 {
                     color=blue
-                    92 [label="Enter block"];
-                    93 [label="Const: Int(2)"];
-                    94 [label="Exit block"];
+                    93 [label="Enter block"];
+                    94 [label="Const: Int(0)"];
+                    95 [label="Exit block"];
                 }
-                95 [label="Catch exit"];
+                96 [label="Exit finally"];
             }
-            subgraph cluster_31 {
-                color=blue
-                96 [label="Enter finally"];
-                subgraph cluster_32 {
-                    color=blue
-                    97 [label="Enter block"];
-                    98 [label="Const: Int(0)"];
-                    99 [label="Exit block"];
-                }
-                100 [label="Exit finally"];
-            }
-            101 [label="Try expression exit"];
+            97 [label="Try expression exit"];
         }
-        102 [label="Exit property" style="filled" fillcolor=red];
+        98 [label="Exit property" style="filled" fillcolor=red];
     }
+    80 -> {81};
+    81 -> {82 87};
+    81 -> {92}    [label=onUncaughtException];
+    82 -> {83};
+    83 -> {84};
     84 -> {85};
-    85 -> {86 91};
-    85 -> {96}    [label=onUncaughtException];
-    86 -> {87};
+    85 -> {86};
+    86 -> {92 87};
     87 -> {88};
+    87 -> {92}    [label=onUncaughtException];
     88 -> {89};
     89 -> {90};
-    90 -> {96 91};
+    90 -> {91};
     91 -> {92};
-    91 -> {96}    [label=onUncaughtException];
     92 -> {93};
     93 -> {94};
     94 -> {95};
     95 -> {96};
     96 -> {97};
+    96 -> {98}    [label=onUncaughtException];
     97 -> {98};
-    98 -> {99};
-    99 -> {100};
-    100 -> {101};
-    100 -> {102}    [label=onUncaughtException];
-    101 -> {102};
 
 }

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

@@ -33,72 +33,58 @@ digraph safeCalls_kt {
 
     subgraph cluster_4 {
         color=red
-        8 [label="Enter function getter" style="filled" fillcolor=red];
-        9 [label="Exit function getter" style="filled" fillcolor=red];
+        8 [label="Enter function test_1" style="filled" fillcolor=red];
+        subgraph cluster_5 {
+            color=blue
+            9 [label="Enter block"];
+            10 [label="Access variable R|<local>/x|"];
+            11 [label="Enter safe call"];
+            12 [label="Function call: $subj$.R|/A.foo|()"];
+            13 [label="Exit safe call"];
+            14 [label="Enter safe call"];
+            15 [label="Function call: $subj$.R|/A.bar|()"];
+            16 [label="Exit safe call"];
+            17 [label="Exit block"];
+        }
+        18 [label="Exit function test_1" style="filled" fillcolor=red];
     }
     8 -> {9};
-
-    subgraph cluster_5 {
-        color=red
-        10 [label="Enter function getter" style="filled" fillcolor=red];
-        11 [label="Exit function getter" style="filled" fillcolor=red];
-    }
-    10 -> {11};
+    9 -> {10};
+    10 -> {11 13};
+    11 -> {12};
+    12 -> {13};
+    13 -> {14 16};
+    14 -> {15};
+    15 -> {16};
+    16 -> {17};
+    17 -> {18};
 
     subgraph cluster_6 {
         color=red
-        12 [label="Enter function test_1" style="filled" fillcolor=red];
+        19 [label="Enter function test_2" style="filled" fillcolor=red];
         subgraph cluster_7 {
             color=blue
-            13 [label="Enter block"];
-            14 [label="Access variable R|<local>/x|"];
-            15 [label="Enter safe call"];
-            16 [label="Function call: $subj$.R|/A.foo|()"];
-            17 [label="Exit safe call"];
-            18 [label="Enter safe call"];
-            19 [label="Function call: $subj$.R|/A.bar|()"];
-            20 [label="Exit safe call"];
-            21 [label="Exit block"];
+            20 [label="Enter block"];
+            21 [label="Access variable R|<local>/x|"];
+            22 [label="Enter safe call"];
+            23 [label="Access variable R|/B.foo|"];
+            24 [label="Exit safe call"];
+            25 [label="Enter safe call"];
+            26 [label="Access variable R|/B.bar|"];
+            27 [label="Exit safe call"];
+            28 [label="Exit block"];
         }
-        22 [label="Exit function test_1" style="filled" fillcolor=red];
+        29 [label="Exit function test_2" style="filled" fillcolor=red];
     }
-    12 -> {13};
-    13 -> {14};
-    14 -> {15 17};
-    15 -> {16};
-    16 -> {17};
-    17 -> {18 20};
-    18 -> {19};
     19 -> {20};
     20 -> {21};
-    21 -> {22};
-
-    subgraph cluster_8 {
-        color=red
-        23 [label="Enter function test_2" style="filled" fillcolor=red];
-        subgraph cluster_9 {
-            color=blue
-            24 [label="Enter block"];
-            25 [label="Access variable R|<local>/x|"];
-            26 [label="Enter safe call"];
-            27 [label="Access variable R|/B.foo|"];
-            28 [label="Exit safe call"];
-            29 [label="Enter safe call"];
-            30 [label="Access variable R|/B.bar|"];
-            31 [label="Exit safe call"];
-            32 [label="Exit block"];
-        }
-        33 [label="Exit function test_2" style="filled" fillcolor=red];
-    }
+    21 -> {22 24};
+    22 -> {23};
     23 -> {24};
-    24 -> {25};
-    25 -> {26 28};
+    24 -> {25 27};
+    25 -> {26};
     26 -> {27};
     27 -> {28};
-    28 -> {29 31};
-    29 -> {30};
-    30 -> {31};
-    31 -> {32};
-    32 -> {33};
+    28 -> {29};
 
 }

compiler/fir/analysis-tests/testData/resolve/constVal/const.fir.txt

@@ -0,0 +1,60 @@
+FILE: const.kt
+    public final const val a: R|kotlin/String| = String(something)
+        public get(): R|kotlin/String|
+    public final const val b: <ERROR TYPE REF: Cannot infer variable type without initializer / getter / delegate>
+        public get(): <ERROR TYPE REF: Cannot infer variable type without initializer / getter / delegate>
+    public final const val c: R|kotlin/Nothing?| = Null(null)
+        public get(): R|kotlin/Nothing?|
+    public final const val d: R|ForConst.Companion| = Q|ForConst|
+        public get(): R|ForConst.Companion|
+    public final const val e: R|kotlin/String| = Q|ForConst|.R|/ForConst.Companion.one|()
+        public get(): R|kotlin/String|
+    public final const val f: R|kotlin/Int| = Int(1).R|kotlin/Int.plus|(Int(2)).R|kotlin/Int.times|(Int(3)).R|kotlin/Int.div|(Int(4)).R|kotlin/Int.rem|(Int(5)).R|kotlin/Int.minus|(Int(1))
+        public get(): R|kotlin/Int|
+    public final const val g: R|kotlin/String| = <strcat>(String(string ), R|/f|)
+        public get(): R|kotlin/String|
+    public final const val h: R|kotlin/String| = String(string).R|kotlin/String.plus|(R|/g|)
+        public get(): R|kotlin/String|
+    public final const val i: R|kotlin/String| = Q|ForConst|.R|/ForConst.Companion.one|().R|kotlin/String.plus|(String(one))
+        public get(): R|kotlin/String|
+    public final const val j: R|kotlin/Int| = Int(4).R|kotlin/Int.times|(Q|ForConst|.R|/ForConst.Companion.two|())
+        public get(): R|kotlin/Int|
+    public final val k: R|kotlin/Int| = Int(3).R|kotlin/Int.minus|(Q|ForConst|.R|/ForConst.Companion.two|())
+        public get(): R|kotlin/Int|
+    public final const val l: R|kotlin/Int| = R|/k|
+        public get(): R|kotlin/Int|
+    public final class ForConst : R|kotlin/Any| {
+        public constructor(): R|ForConst| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final companion object Companion : R|kotlin/Any| {
+            private constructor(): R|ForConst.Companion| {
+                super<R|kotlin/Any|>()
+            }
+
+            public final fun one(): R|kotlin/String| {
+                ^one String(1)
+            }
+
+            public final fun two(): R|kotlin/Int| {
+                ^two Int(2)
+            }
+
+        }
+
+    }
+    private final const val MAJOR_BITS: R|kotlin/Int| = Int(3)
+        private get(): R|kotlin/Int|
+    private final const val MINOR_BITS: R|kotlin/Int| = Int(4)
+        private get(): R|kotlin/Int|
+    private final const val PATCH_BITS: R|kotlin/Int| = Int(7)
+        private get(): R|kotlin/Int|
+    private final const val MAJOR_MASK: R|kotlin/Int| = Int(1).R|kotlin/Int.shl|(R|/MAJOR_BITS|).R|kotlin/Int.minus|(Int(1))
+        private get(): R|kotlin/Int|
+    private final const val MINOR_MASK: R|kotlin/Int| = Int(1).R|kotlin/Int.shl|(R|/MINOR_BITS|).R|kotlin/Int.minus|(Int(1))
+        private get(): R|kotlin/Int|
+    private final const val PATCH_MASK: R|kotlin/Int| = Int(1).R|kotlin/Int.shl|(R|/PATCH_BITS|).R|kotlin/Int.minus|(Int(1))
+        private get(): R|kotlin/Int|
+    private final const val stringFromJava: R|kotlin/String| = Q|Constants|.R|/Constants.FIRST|.R|kotlin/String.plus|(String(+)).R|kotlin/String.plus|(Q|Constants|.R|/Constants.SECOND|)
+        private get(): R|kotlin/String|

compiler/fir/analysis-tests/testData/resolve/constVal/const.kt

@@ -0,0 +1,36 @@
+// FILE: Constants.java
+
+public class Constants {
+    public static final String FIRST = "1st";
+    public static final String SECOND = "2nd";
+}
+
+// FILE: const.kt
+const val a = "something"
+<!MUST_BE_INITIALIZED!><!CONST_VAL_WITHOUT_INITIALIZER!>const<!> val b<!>
+<!TYPE_CANT_BE_USED_FOR_CONST_VAL!>const<!> val c = null
+<!TYPE_CANT_BE_USED_FOR_CONST_VAL!>const<!> val d = ForConst
+const val e = <!CONST_VAL_WITH_NON_CONST_INITIALIZER!>ForConst.one()<!>
+const val f = ((1 + 2) * 3) / 4 % 5 - 1
+const val g = "string $f"
+const val h = "string" + g
+const val i = <!CONST_VAL_WITH_NON_CONST_INITIALIZER!>ForConst.one() + "one"<!>
+const val j = <!CONST_VAL_WITH_NON_CONST_INITIALIZER!>4 * ForConst.two()<!>
+val k = 3 - ForConst.two()
+const val l = <!CONST_VAL_WITH_NON_CONST_INITIALIZER!>k<!>
+
+class ForConst{
+    companion object {
+        fun one(): String = "1"
+        fun two(): Int = 2
+    }
+}
+
+private const val MAJOR_BITS = 3
+private const val MINOR_BITS = 4
+private const val PATCH_BITS = 7
+private const val MAJOR_MASK = (1 shl MAJOR_BITS) - 1 // False positive error
+private const val MINOR_MASK = (1 shl MINOR_BITS) - 1 // False positive error
+private const val PATCH_MASK = (1 shl PATCH_BITS) - 1    // False positive error
+
+private const val stringFromJava = Constants.FIRST + "+" + Constants.SECOND