1

Support type enhancement on freshly supported module level annotations
2026-03-15 00:21:29 +00:00 · 2021-04-08 17:39:20 +03:00 · 2021-04-08 17:39:19 +03:00 · 2021-04-08 17:39:09 +03:00 · 2021-04-08 17:39:08 +03:00 · 2021-04-08 17:39:07 +03:00
4310 changed files with 34141 additions and 119042 deletions
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -63,6 +63,27 @@
      <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" />
@@ -80,4 +101,4 @@
      <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
    </codeStyleSettings>
  </code_scheme>
-</component>
+</component>
--- a/.idea/dictionaries/sebastiansellmair.xml
+++ b/.idea/dictionaries/sebastiansellmair.xml
@@ -3,7 +3,6 @@
    <words>
      <w>cinterops</w>
      <w>interops</w>
-      <w>klibrary</w>
    </words>
  </dictionary>
-</component>
+</component>
--- a/.idea/runConfigurations/Test__Commonizer.xml
+++ b/.idea/runConfigurations/Test__Commonizer.xml
@@ -1,25 +0,0 @@
-<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>
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -192,7 +192,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-5613"
+    extra["versions.kotlin-native"] = "1.5.20-dev-3553"
 }

 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -368,8 +368,7 @@ val gradlePluginProjects = listOf(
    ":kotlin-annotation-processing-gradle",
    ":kotlin-noarg",
    ":kotlin-sam-with-receiver",
-    ":kotlin-parcelize-compiler",
-    ":kotlin-lombok"
+    ":kotlin-parcelize-compiler"
 )

 apply {
@@ -578,6 +577,26 @@ 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"
--- a/buildSrc/src/main/kotlin/dependencies.kt
+++ b/buildSrc/src/main/kotlin/dependencies.kt
@@ -118,8 +118,7 @@ fun DependencyHandler.projectArchives(name: String): ProjectDependency = project
 fun Project.testApiJUnit5(
    vintageEngine: Boolean = false,
    runner: Boolean = false,
-    suiteApi: Boolean = false,
-    jupiterParams: Boolean = false
+    suiteApi: Boolean = false
 ) {
    with(dependencies) {
        val platformVersion = commonVer("org.junit", "junit-bom")
@@ -128,11 +127,6 @@ 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(
--- a/buildSrc/src/main/kotlin/plugins/KotlinBuildPublishingPlugin.kt
+++ b/buildSrc/src/main/kotlin/plugins/KotlinBuildPublishingPlugin.kt
@@ -5,7 +5,6 @@

 package plugins

-import PublishToMavenLocalSerializable
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.attributes.Usage
@@ -14,10 +13,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.*
@@ -28,6 +27,7 @@ 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,40 +132,32 @@ fun Project.configureDefaultPublishing() {
        }
    }

-    val signingRequired = project.providers.gradleProperty("signingRequired").forUseAtConfigurationTime().orNull?.toBoolean()
-        ?: project.providers.gradleProperty("isSonatypeRelease").forUseAtConfigurationTime().orNull?.toBoolean() ?: false
-
-    if (signingRequired) {
-        apply<SigningPlugin>()
-        configureSigning()
-    }
+    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() =
@@ -189,4 +181,4 @@ private fun PublishToMavenRepository.configureRepository() {
            }
        }
    }
-}
+}
--- a/buildSrc/src/main/kotlin/tasks.kt
+++ b/buildSrc/src/main/kotlin/tasks.kt
@@ -7,22 +7,13 @@
 // 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
@@ -47,7 +38,6 @@ 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",
@@ -289,30 +279,3 @@ 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()
-    }
-}
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/SamType.kt
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/SamType.kt
@@ -87,4 +87,4 @@ open class SamTypeFactory {
    companion object {
        val INSTANCE = SamTypeFactory()
    }
-}
+}
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
@@ -158,14 +158,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
        for (int i = 0; i < superInterfaceTypes.size(); i++) {
            KotlinType superInterfaceType = superInterfaceTypes.get(i);
            sw.writeInterface();
-            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();
+            superInterfaceAsmTypes[i] = typeMapper.mapSupertype(superInterfaceType, sw).getInternalName();
            sw.writeInterfaceEnd();
        }

--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
@@ -3009,7 +3009,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(), state.getLanguageVersionSettings());
+            TypeApproximator approximator = new TypeApproximator(state.getModule().getBuiltIns());

            KotlinType approximatedType =
                    TypeUtils.contains(type, (containedType) -> CapturedTypeConstructorKt.isCaptured(containedType)) ?
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.kt
@@ -188,12 +188,6 @@ class JvmRuntimeTypes(
            else -> if (isMutable) mutablePropertyReferences else propertyReferences
        }

-        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
-        }
+        return classes[arity].defaultType
    }
 }
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineTransformerMethodVisitor.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineTransformerMethodVisitor.kt
@@ -999,7 +999,7 @@ class CoroutineTransformerMethodVisitor(
                else -> next = next.next
            }
        }
-        return null
+        return next
    }

    // 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,
-                    min(variable.end, nextSuspensionPointStartLabel(variable.start)),
+                    nextSuspensionPointStartLabel(variable.start),
                    variable.index
                )
            )
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt
+++ b/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 = analyze(internalClassName, node, interpreter)
+        val frames = MethodTransformer.analyze(internalClassName, node, interpreter)

        interpretPopInstructionsForBoxedValues(interpreter, node, frames)

@@ -168,8 +168,7 @@ 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 {
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt
+++ b/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,7 +77,8 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
        val elements = LinkedHashSet<PsiElement>()
        if (noOwnImplementations) {
            elements.addIfNotNull(data.classOrigin.element)
-        } else {
+        }
+        else {
            for (origin in data.signatureOrigins) {
                var element = origin.element

@@ -95,9 +96,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)
@@ -106,9 +107,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
@@ -121,9 +122,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
@@ -140,7 +141,9 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
        for ((rawSignature, origins) in groupedBySignature.entrySet()) {
            if (origins.size <= 1) continue

-            when (val diagnostic = computeDiagnosticToReport(classOrigin, classInternalName, rawSignature, origins)) {
+            val diagnostic = computeDiagnosticToReport(classOrigin, classInternalName, rawSignature, origins)
+
+            when (diagnostic) {
                is ConflictingDeclarationError.AccidentalOverride -> {
                    diagnostics.report(ErrorsJvm.ACCIDENTAL_OVERRIDE.on(diagnostic.element, diagnostic.data))
                }
@@ -153,17 +156,16 @@ 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
@@ -209,17 +211,19 @@ 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))
                }
            }
@@ -228,10 +232,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
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
@@ -330,7 +330,7 @@ class GenerationState private constructor(

    val typeApproximator: TypeApproximator? =
        if (languageVersionSettings.supportsFeature(LanguageFeature.NewInference))
-            TypeApproximator(module.builtIns, languageVersionSettings)
+            TypeApproximator(module.builtIns)
        else
            null

--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMapperUtils.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMapperUtils.kt
@@ -87,6 +87,11 @@ 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()
--- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/Properties.kt
+++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/Properties.kt
@@ -16,10 +16,10 @@

 package org.jetbrains.kotlin.cli.common

-/**
- * @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) {
+import com.intellij.util.LineSeparator
+import java.util.*
+
+enum class CompilerSystemProperties(val property: String) {
    COMPILE_DAEMON_ENABLED_PROPERTY("kotlin.daemon.enabled"),
    COMPILE_DAEMON_JVM_OPTIONS_PROPERTY("kotlin.daemon.jvm.options"),
    COMPILE_DAEMON_OPTIONS_PROPERTY("kotlin.daemon.options"),
@@ -36,31 +36,24 @@ enum class CompilerSystemProperties(val property: String, val alwaysDirectAccess
    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", alwaysDirectAccess = true),
+    OS_NAME("os.name"),
    TMP_DIR("java.io.tmpdir"),
-    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),
+    USER_HOME("user.home"),
+    JAVA_VERSION("java.specification.version"),
+    JAVA_HOME("java.home"),
+    JAVA_CLASS_PATH("java.class.path"),
    ;

-    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)
-        }
+    var value
+        get() = (systemPropertyGetter ?: System::getProperty)(property)
        set(value) {
-            getProperFunction(systemPropertySetter, System::setProperty)(property, value!!)
+            (systemPropertySetter ?: System::setProperty)(property, value!!)
        }

    val safeValue
        get() = value ?: error("No value for $property system property")

-    fun clear(): String? = getProperFunction(systemPropertyCleaner, System::clearProperty)(property)
+    fun clear(): String? = (systemPropertyCleaner ?: System::clearProperty)(property)

    companion object {
        var systemPropertyGetter: ((String) -> String?)? = null
--- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt
+++ b/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(null)
+    var stringConcat: String? by NullableStringFreezableVar(JvmStringConcat.INLINE.description)

    @Argument(
        value = "-Xsam-conversions",
--- a/compiler/cli/cli-js-klib/build.gradle.kts
+++ b/compiler/cli/cli-js-klib/build.gradle.kts
@@ -0,0 +1,20 @@
+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() }
+}
--- a/compiler/cli/cli-js-klib/src/GenerateJsIrKlib.kt
+++ b/compiler/cli/cli-js-klib/src/GenerateJsIrKlib.kt
@@ -0,0 +1,153 @@
+/*
+ * 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)
+    }
+}
--- a/compiler/cli/cli-js/build.gradle.kts
+++ b/compiler/cli/cli-js/build.gradle.kts
@@ -11,7 +11,6 @@ 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"))
--- a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt
+++ b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt
@@ -17,8 +17,7 @@ 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.DCE_RUNTIME_DIAGNOSTIC_EXCEPTION
-import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.DCE_RUNTIME_DIAGNOSTIC_LOG
+import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.*
 import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.extensions.ScriptEvaluationExtension
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
@@ -39,7 +38,6 @@ 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
@@ -232,7 +230,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                    AnalyzerWithCompilerReport(config.configuration),
                    config.configuration,
                    PhaseConfig(wasmPhases),
-                    IrFactoryImpl,
                    allDependencies = resolvedLibraries,
                    friendDependencies = friendDependencies,
                    exportedDeclarations = setOf(FqName("main"))
@@ -259,7 +256,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                AnalyzerWithCompilerReport(config.configuration),
                config.configuration,
                phaseConfig,
-                if (arguments.irDceDriven) PersistentIrFactory() else IrFactoryImpl,
                allDependencies = resolvedLibraries,
                friendDependencies = friendDependencies,
                mainArguments = mainCallArguments,
--- a/compiler/cli/src/com/intellij/DynamicBundle.java
+++ b/compiler/cli/src/com/intellij/DynamicBundle.java
@@ -4,6 +4,7 @@ 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;
@@ -92,8 +93,7 @@ public abstract class DynamicBundle extends AbstractBundle {
  public static final DynamicBundle INSTANCE = new DynamicBundle("") {
  };

-  @SuppressWarnings("deprecation")
-  public static class LanguageBundleEP extends com.intellij.openapi.extensions.AbstractExtensionPointBean {
+  public static class LanguageBundleEP extends AbstractExtensionPointBean {
    public static final ExtensionPointName<LanguageBundleEP> EP_NAME = ExtensionPointName.create("com.intellij.languageBundle");
  }

--- a/compiler/cli/src/org/jetbrains/kotlin/cli/common/performanceMeasurements.kt
+++ b/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?, val milliseconds: Long) : PerformanceMeasurement {
+class CodeGenerationMeasurement(private val lines: Int?, private val milliseconds: Long) : PerformanceMeasurement {
    override fun render(): String = formatMeasurement("GENERATE", milliseconds, lines)
 }

--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/ClasspathRootsResolver.kt
+++ b/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.testFramework.LightVirtualFile
 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,7 +54,8 @@ 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)

@@ -160,7 +163,7 @@ class ClasspathRootsResolver(
                }

        if (moduleInfoFile != null) {
-            val moduleInfo = JavaModuleInfo.read(moduleInfoFile) ?: return null
+            val moduleInfo = JavaModuleInfo.read(moduleInfoFile, javaFileManager) ?: return null
            return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(root, isBinary = true)), moduleInfoFile)
        }

--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliVirtualFileFinder.kt
+++ b/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)
 }
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt
@@ -82,7 +82,9 @@ 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(classId: ClassId): JavaClass? = findClass(JavaClassFinder.Request(classId), allScope)

    override fun findClass(request: JavaClassFinder.Request, searchScope: GlobalSearchScope): JavaClass? {
        val (classId, classFileContentFromRequest, outerClassFromRequest) = request
@@ -110,7 +112,7 @@ class KotlinCliJavaFileManagerImpl(private val myPsiManager: PsiManager) : CoreJ
                val classContent = classFileContentFromRequest ?: virtualFile.contentsToByteArray()
                if (virtualFile.nameWithoutExtension.contains("$") && isNotTopLevelClass(classContent)) return@getOrPut null

-                val resolver = ClassifierResolutionContext { findClass(it, allScope) }
+                val resolver = ClassifierResolutionContext { findClass(it) }

                BinaryJavaClass(
                    virtualFile, classId.asSingleFqName(), resolver, signatureParsingComponent,
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt
@@ -92,7 +92,6 @@ 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
@@ -190,11 +189,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()
@@ -207,7 +211,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) =
@@ -231,7 +236,7 @@ class KotlinCoreEnvironment private constructor(
            updateClasspathFromRootsIndex(this)
        }

-        (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize(
+        javaFileManager.initialize(
            rootsIndex,
            packagePartProviders,
            SingleJavaFileRootsIndex(singleJavaFileRoots),
@@ -240,7 +245,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)
@@ -576,7 +581,6 @@ 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)
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42
+++ b/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,7 +93,6 @@ 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
@@ -193,11 +189,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()
@@ -210,7 +211,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) =
@@ -234,7 +236,7 @@ class KotlinCoreEnvironment private constructor(
            updateClasspathFromRootsIndex(this)
        }

-        (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize(
+        javaFileManager.initialize(
            rootsIndex,
            packagePartProviders,
            SingleJavaFileRootsIndex(singleJavaFileRoots),
@@ -243,7 +245,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)
@@ -570,7 +572,6 @@ 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)
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt
@@ -17,7 +17,6 @@
 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
@@ -37,7 +36,8 @@ 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.*
+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.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.common.output.writeAll
@@ -304,11 +304,6 @@ 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
@@ -432,9 +427,6 @@ object KotlinToJVMBytecodeCompiler {
            performanceManager?.notifyGenerationFinished()
            ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
            outputs[module] = generationState
-
-            PsiElementFinder.EP.getPoint(project).unregisterExtension(JavaElementFinder::class.java)
-            Disposer.dispose(environment.project)
        }

        val mainClassFqName: FqName? =
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt
+++ b/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))
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/index/JvmDependenciesIndex.kt
+++ b/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)
    }
 }
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt
@@ -54,20 +54,19 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
        }
    }

-    val stringConcat = arguments.stringConcat
-    if (stringConcat != null) {
-        val runtimeStringConcat = JvmStringConcat.fromString(stringConcat)
+    if (arguments.stringConcat != null) {
+        val runtimeStringConcat = JvmStringConcat.fromString(arguments.stringConcat!!)
        if (runtimeStringConcat != null) {
            put(JVMConfigurationKeys.STRING_CONCAT, runtimeStringConcat)
            if (jvmTarget.majorVersion < JvmTarget.JVM_9.majorVersion && runtimeStringConcat != JvmStringConcat.INLINE) {
                messageCollector.report(
                    WARNING,
-                    "`-Xstring-concat=$stringConcat` does nothing with JVM target `${jvmTarget.description}`."
+                    "`-Xstring-concat=${arguments.stringConcat}` does nothing with JVM target `${jvmTarget.description}`."
                )
            }
        } else {
            messageCollector.report(
-                ERROR, "Unknown `-Xstring-concat` mode: $stringConcat\n" +
+                ERROR, "Unknown `-Xstring-concat` mode: ${arguments.stringConcat}\n" +
                        "Supported modes: ${JvmStringConcat.values().joinToString { it.description }}"
            )
        }
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleFinder.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleFinder.kt
@@ -18,11 +18,12 @@ package org.jetbrains.kotlin.cli.jvm.modules

 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiJavaModule
+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?, val javaFileManager: KotlinCliJavaFileManager) : JavaModuleFinder {
    private val modulesRoot = jrtFileSystemRoot?.findChild("modules")
    private val userModules = linkedMapOf<String, JavaModule>()

@@ -41,7 +42,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) ?: return null
        return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(moduleRoot, isBinary = true)), file)
    }
 }
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleResolver.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleResolver.kt
@@ -18,10 +18,14 @@ 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
@@ -29,7 +33,8 @@ import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 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 +42,13 @@ class CliJavaModuleResolver(
        }
    }

+    private val virtualFileFinder by lazy { VirtualFileFinder.getInstance(project) }
+
+    override fun getModuleAnnotations(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? {
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataCompiler.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataCompiler.kt
@@ -62,9 +62,8 @@ 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 = arg in commonSources)
+            configuration.addKotlinSourceRoot(arg, isCommon = true)
        }
        if (arguments.classpath != null) {
            configuration.addJvmClasspathRoots(arguments.classpath!!.split(File.pathSeparatorChar).map(::File))
--- a/compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/KotlinCompilerClient.kt
+++ b/compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/KotlinCompilerClient.kt
@@ -367,14 +367,8 @@ object KotlinCompilerClient {
    }


-    private fun startDaemon(
-        compilerId: CompilerId,
-        daemonJVMOptions: DaemonJVMOptions,
-        daemonOptions: DaemonOptions,
-        reportingTargets: DaemonReportingTargets
-    ): Boolean {
-        val daemonJavaExecutable = compilerId.javaExecutable
-            ?: File(File(CompilerSystemProperties.JAVA_HOME.safeValue, "bin"), "java")
+    private fun startDaemon(compilerId: CompilerId, daemonJVMOptions: DaemonJVMOptions, daemonOptions: DaemonOptions, reportingTargets: DaemonReportingTargets): Boolean {
+        val 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
@@ -386,7 +380,7 @@ object KotlinCompilerClient {
                listOf("--illegal-access=permit")
            else emptyList()
        val args = listOf(
-                   daemonJavaExecutable.absolutePath, "-cp", compilerId.compilerClasspath.joinToString(File.pathSeparator)) +
+                   javaExecutable.absolutePath, "-cp", compilerId.compilerClasspath.joinToString(File.pathSeparator)) +
                   platformSpecificOptions +
                   daemonJVMOptions.mappers.flatMap { it.toArgs("-") } +
                   javaIllegalAccessWorkaround +
--- a/compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/ClientUtils.kt
+++ b/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.digest()
+    val classPathDigest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString()
    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)) }
--- a/compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/CompileServiceRMIWrapper.kt
+++ b/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.digest(),
+                digest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString(),
                port = port.toString()
            )
        )
--- a/compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/ClientUtils.kt
+++ b/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.digest()
+    val classPathDigest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString()
    val portExtractor = makePortFromRunFilenameExtractor(classPathDigest)
    return registryDir.walk()
            .map { Pair(it, portExtractor(it.name)) }
--- a/compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/DaemonParams.kt
+++ b/compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/DaemonParams.kt
@@ -231,38 +231,12 @@ fun ByteArray.toHexString(): String = joinToString("", transform = { "%02x".form

 data class CompilerId(
        var compilerClasspath: List<String> = listOf(),
-        var compilerVersion: String = "",
-        var javaExecutable: File? = null
+        var compilerVersion: String = ""
 ) : OptionsGroup {

    override val mappers: List<PropMapper<*, *, *>>
-        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()
+        get() = listOf(PropMapper(this, CompilerId::compilerClasspath, toString = { it.joinToString(File.pathSeparator) }, fromString = { it.trimQuotes().split(File.pathSeparator) }),
+                       StringPropMapper(this, CompilerId::compilerVersion))

    companion object {
        @JvmStatic
@@ -271,15 +245,6 @@ 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
-        )
    }
 }

--- a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt
+++ b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt
@@ -5,7 +5,6 @@

 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
@@ -278,129 +277,6 @@ 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)
--- a/compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt
+++ b/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.digest(),
+                digest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString(),
                port = port.toString()
            )
        )
--- a/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java
+++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java
@@ -56,11 +56,6 @@ 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");
@@ -443,11 +438,6 @@ 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");
--- a/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java
+++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java
@@ -29,11 +29,6 @@ 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");
@@ -179,11 +174,6 @@ 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");
@@ -506,11 +496,6 @@ 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");
@@ -956,11 +941,6 @@ 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");
@@ -990,24 +970,6 @@ 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)
@@ -1188,11 +1150,6 @@ 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");
@@ -2724,11 +2681,6 @@ 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");
@@ -2855,21 +2807,11 @@ 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");
@@ -2893,11 +2835,6 @@ 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");
--- a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt
+++ b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt
@@ -9,7 +9,6 @@ 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
@@ -55,7 +54,6 @@ 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)
--- a/compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/AnnotationInArray.txt
+++ b/compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/AnnotationInArray.txt
@@ -1,20 +0,0 @@
-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|
-
-}
--- a/compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/types/DefinitelyNotNull.txt
+++ b/compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/types/DefinitelyNotNull.txt
@@ -1 +0,0 @@
-public final fun <T> foo(x: R|T!!|, y: R|kotlin/collections/List<T!!>|, z: R|(T!!) -> T!!|): R|T!!|
--- a/compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/types/SupertypesAndBounds.txt
+++ b/compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/types/SupertypesAndBounds.txt
@@ -1,4 +1,4 @@
-@R|kotlin/annotation/Target|(allowedTargets = <implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.TYPE|())) public final annotation class A : R|kotlin/Annotation| {
+public final annotation class A : R|kotlin/Annotation| {
    public constructor(): R|test/A|

 }
--- a/compiler/fir/analysis-tests/testData/loadCompiledKotlin/fromLoadJava/kotlinSignature/MethodWithFunctionTypes.txt
+++ b/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|

--- a/compiler/fir/analysis-tests/testData/loadCompiledKotlin/prop/NonConstValWithConstantValueAttribute.txt
+++ b/compiler/fir/analysis-tests/testData/loadCompiledKotlin/prop/NonConstValWithConstantValueAttribute.txt
@@ -1,16 +1,16 @@
-public final val nonConstVal1: R|kotlin/Int| = Int(1)
+public final val nonConstVal1: R|kotlin/Int|
    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| = Int(3)
+        public final val nonConstVal3: R|kotlin/Int|
            public get(): R|kotlin/Int|

        private constructor(): R|test/C.Companion|

    }

-    public final val nonConstVal2: R|kotlin/Int| = Int(2)
+    public final val nonConstVal2: R|kotlin/Int|
        public get(): R|kotlin/Int|

    public constructor(): R|test/C|
--- a/compiler/fir/analysis-tests/testData/loadCompiledKotlin/type/SuspendFunction.txt
+++ b/compiler/fir/analysis-tests/testData/loadCompiledKotlin/type/SuspendFunction.txt
@@ -1,16 +1,8 @@
 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>?)?|
-
--- a/compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.fir.txt
@@ -1,27 +0,0 @@
-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|
--- a/compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.kt
@@ -1,11 +0,0 @@
-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
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt
@@ -15,5 +15,5 @@ class B : A() {
 }

 fun test(b: B) {
-    b.<!INVISIBLE_REFERENCE!>foo<!>("")
+    b.<!HIDDEN!>foo<!>("")
 }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.fir.txt
@@ -1,17 +0,0 @@
-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))
-    }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.kt
@@ -1,13 +0,0 @@
-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)
-}
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt
@@ -9,7 +9,7 @@ public @interface Ann {
 // FILE: main.kt

@Ann(x = 10, s = "")
-@Ann(<!ARGUMENT_TYPE_MISMATCH!>10<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
+<!INAPPLICABLE_CANDIDATE!>@Ann(10, "")<!>
@Ann(x = 10, s = "", y = 10)
 class A

--- a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
@@ -21,6 +21,6 @@ fun test() {
    baz(1, "my", "yours")
    baz(1, z = true)

-    baz(0, "", <!ARGUMENT_TYPE_MISMATCH!>false<!>)
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(0, "", false)
 }

--- a/compiler/fir/analysis-tests/testData/resolve/arguments/destructuring.kt
+++ b/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 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>) -> C(<!ARGUMENT_TYPE_MISMATCH!>x<!>, <!ARGUMENT_TYPE_MISMATCH!>y<!>) }
+    foo1 { (x: String, y: Int) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x, 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 { (<!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<!>) }
+    foo2 { (x: String, y: Int), (z: String, w: Int) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x + z, y + w) }
 }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
+++ b/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() {
-    takeInt(<!ARGUMENT_TYPE_MISMATCH!>10000000000<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
    takeLong(10000000000)
-    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
 }

 fun test_3() {
@@ -35,14 +35,14 @@ fun test_4() {
 }

 fun test_5() {
-    takeString(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
-    takeString(<!ARGUMENT_TYPE_MISMATCH!>run { 1 }<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
+    <!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
 }

 annotation class Ann(val x: Byte)

@Ann(10)
 fun test_6() {
-    @Ann(<!ARGUMENT_TYPE_MISMATCH!>300<!>)
+    <!INAPPLICABLE_CANDIDATE!>@Ann(300)<!>
    val x = ""
 }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt
@@ -9,7 +9,7 @@ public @interface Ann {
@Ann("a", "b")
 fun test_1() {}

-@Ann(<!ARGUMENT_TYPE_MISMATCH!>arrayOf("a", "b")<!>)
+<!INAPPLICABLE_CANDIDATE!>@Ann(arrayOf("a", "b"))<!>
 fun test_2() {}

@Ann(*arrayOf("a", "b"))
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
+++ 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)
-    takeA(<!ARGUMENT_TYPE_MISMATCH!>array<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
    takeOutA(array)
 }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt
@@ -16,7 +16,7 @@ fun test(ordinal: Int) {
    buildString {
        insert(KDocTemplate()) {
            definition {
-                ordinal<!UNNECESSARY_SAFE_CALL!>?.<!>let {}
+                ordinal?.let {}
            }
        }
    }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
@@ -31,33 +31,33 @@ fun test_3() {
 fun takeByte(b: Byte) {}

 fun test_4() {
-    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<!>)
+    <!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)
    <!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
-    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<!>)
+    <!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)
 }

 fun test_5() {
    takeByte(-1)
    takeByte(+1)
-    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1.inv()<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
 }

 fun test_6() {
-    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 127 + 1 }<!>)
-    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + run { 1 }<!>)
-    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 1 + 1 }<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
    1 + 1
    run { 1 }
    1 + run { 1 }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
+++ b/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!>)<!>
-    foo(<!ARGUMENT_TYPE_MISMATCH!>0.0<!>, <!ARGUMENT_TYPE_MISMATCH!>false<!>, <!ARGUMENT_TYPE_MISMATCH!>0<!>, "")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
    foo(1, 2.0, third = true, "")
    foo(second = 0.0, first = 0, fourth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    foo(first = <!ARGUMENT_TYPE_MISMATCH!>0.0<!>, second = <!ARGUMENT_TYPE_MISMATCH!>0<!>, third = <!ARGUMENT_TYPE_MISMATCH!>""<!>, fourth = <!ARGUMENT_TYPE_MISMATCH!>false<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = 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!>)<!>
 }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.fir.txt
+++ b/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|/foo|(<strcat>(R|<local>/a|.R|kotlin/Any.toString|()))
    }
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
@@ -7,8 +7,8 @@ fun test() {
    foo(1, "my", "yours")
    foo(1, *arrayOf("my", "yours"))

-    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
-    foo(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)

    bar(1, z = true, y = *arrayOf("my", "yours"))

--- a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
@@ -9,7 +9,7 @@ fun bar(x: B) {}

 fun test(c: C) {
    // Argument mapping error
-    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>("")

    // Ambiguity
    <!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(c)
--- a/compiler/fir/analysis-tests/testData/resolve/callResolution/safeCallOnTypeAlias.fir.txt
+++ b/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>  {
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.dot
@@ -191,68 +191,63 @@ 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
-                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?>|"];
+                60 [label="Enter while loop"];
                subgraph cluster_21 {
                    color=blue
-                    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"];
-                    }
+                    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"];
                    subgraph cluster_23 {
                        color=blue
-                        66 [label="Enter loop block"];
+                        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?|"];
                        subgraph cluster_24 {
                            color=blue
-                            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?|"];
+                            70 [label="Enter when"];
                            subgraph cluster_25 {
                                color=blue
-                                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"];
+                                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"];
                            }
-                            85 [label="Exit block"];
+                            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"];
                        }
-                        86 [label="Exit loop block"];
+                        84 [label="Exit block"];
                    }
-                    87 [label="Exit whileloop"];
+                    85 [label="Exit loop block"];
                }
-                88 [label="Exit block"];
+                86 [label="Exit whileloop"];
            }
-            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];
+            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];
        }
-        93 [label="Exit function firstIsInstanceOrNull" style="filled" fillcolor=red];
+        91 [label="Exit function firstIsInstanceOrNull" style="filled" fillcolor=red];
    }
    55 -> {56};
    56 -> {57};
@@ -263,8 +258,8 @@ digraph complex_kt {
    61 -> {62};
    62 -> {63};
    63 -> {64};
-    64 -> {65};
-    65 -> {87 66};
+    64 -> {86 65};
+    65 -> {66};
    66 -> {67};
    67 -> {68};
    68 -> {69};
@@ -273,26 +268,24 @@ digraph complex_kt {
    71 -> {72};
    72 -> {73};
    73 -> {74};
-    74 -> {75};
-    75 -> {77 76};
-    76 -> {84};
+    74 -> {76 75};
+    75 -> {83};
+    76 -> {77};
    77 -> {78};
    78 -> {79};
-    79 -> {80};
-    80 -> {93};
+    79 -> {91};
+    79 -> {80} [style=dotted];
    80 -> {81} [style=dotted];
    81 -> {82} [style=dotted];
    82 -> {83} [style=dotted];
-    83 -> {84} [style=dotted];
+    83 -> {84};
    84 -> {85};
-    85 -> {86};
-    86 -> {62} [color=green style=dashed];
+    85 -> {61} [color=green style=dashed];
+    86 -> {87};
    87 -> {88};
-    88 -> {89};
-    89 -> {90};
-    90 -> {93};
+    88 -> {91};
+    88 -> {89} [style=dotted];
+    89 -> {90} [style=dotted];
    90 -> {91} [style=dotted];
-    91 -> {92} [style=dotted];
-    92 -> {93} [style=dotted];

 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.fir.txt
@@ -25,16 +25,13 @@ 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|
                }
-
            }

        }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
@@ -72,7 +72,7 @@ fun test_4(x: Any, y: Any) {
        }

    )
-    takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>) // Bad
+    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
    takeInt(y) // OK
    takeInt(a) // Bad
 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.dot
@@ -19,78 +19,85 @@ digraph initBlockAndInPlaceLambda_kt {

    subgraph cluster_2 {
        color=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 [label="Enter function getter" style="filled" fillcolor=red];
+        5 [label="Exit function getter" style="filled" fillcolor=red];
    }
-    4 -> {5} [color=green];
-    5 -> {6} [style=dotted];
-    5 -> {10} [color=green];
-    5 -> {10} [style=dashed];
+    4 -> {5};

    subgraph cluster_3 {
        color=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 [label="Enter class C" style="filled" fillcolor=red];
+        7 [label="Part of class initialization"];
+        8 [label="Exit class C" style="filled" fillcolor=red];
    }
-    7 -> {8};
-    8 -> {9};
+    6 -> {7} [color=green];
+    7 -> {8} [style=dotted];
+    7 -> {12} [color=green];
+    7 -> {12} [style=dashed];

    subgraph cluster_4 {
        color=red
-        10 [label="Enter init block" style="filled" fillcolor=red];
-        subgraph cluster_5 {
-            color=blue
-            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
-                23 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-                subgraph cluster_7 {
-                    color=blue
-                    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"];
-                }
-                29 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-            }
-            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"];
-        }
-        22 [label="Exit init block" style="filled" fillcolor=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};
-    11 -> {12};
+
+    subgraph cluster_5 {
+        color=red
+        12 [label="Enter init block" style="filled" fillcolor=red];
+        subgraph cluster_6 {
+            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 {
+                color=blue
+                25 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+                subgraph cluster_8 {
+                    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"];
+                }
+                31 [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"];
+        }
+        24 [label="Exit init block" style="filled" fillcolor=red];
+    }
    12 -> {13};
-    13 -> {14 19};
+    13 -> {14};
    14 -> {15};
-    15 -> {23};
-    15 -> {17} [color=red];
-    15 -> {23} [style=dashed];
-    16 -> {18} [color=red];
-    17 -> {18} [color=green];
-    18 -> {19};
-    19 -> {20};
+    15 -> {16 21};
+    16 -> {17};
+    17 -> {25};
+    17 -> {19} [color=red];
+    17 -> {25} [style=dashed];
+    18 -> {20} [color=red];
+    19 -> {20} [color=green];
    20 -> {21};
    21 -> {22};
-    22 -> {6} [color=green];
+    22 -> {23};
    23 -> {24};
-    24 -> {25};
+    24 -> {8} [color=green];
    25 -> {26};
    26 -> {27};
    27 -> {28};
    28 -> {29};
-    29 -> {16} [color=red];
-    29 -> {17} [color=green];
+    29 -> {30};
+    30 -> {31};
+    31 -> {18} [color=red];
+    31 -> {19} [color=green];

 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/innerClassInAnonymousObject.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/innerClassInAnonymousObject.dot
@@ -44,20 +44,27 @@ digraph innerClassInAnonymousObject_kt {

    subgraph cluster_5 {
        color=red
-        14 [label="Enter property" style="filled" fillcolor=red];
-        15 [label="Exit anonymous object"];
-        16 [label="Exit property" style="filled" fillcolor=red];
+        14 [label="Enter function getter" style="filled" fillcolor=red];
+        15 [label="Exit function getter" 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];
    }
-    14 -> {15};
-    14 -> {0 5 8} [color=red];
-    15 -> {16};
-    15 -> {0 12} [color=green];
-    15 -> {0 12} [style=dashed];
+    16 -> {17};
+    16 -> {0 5 8} [color=red];
+    17 -> {18};
+    17 -> {0 12} [color=green];
+    17 -> {0 12} [style=dashed];
    12 -> {13} [color=green];

 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.dot
+++ b/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(UNSAFE_CALL): kotlin/Int.inc>#()"];
+            53 [label="Function call: R|<local>/y|.<Inapplicable(INAPPLICABLE_WRONG_RECEIVER): kotlin/Int.inc>#()"];
            54 [label="Exit block"];
        }
        55 [label="Exit function test_2" style="filled" fillcolor=red];
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.fir.txt
@@ -22,7 +22,7 @@ FILE: jumps.kt
            }
        }

-        R|<local>/y|.<Inapplicable(UNSAFE_CALL): kotlin/Int.inc>#()
+        R|<local>/y|.<Inapplicable(INAPPLICABLE_WRONG_RECEIVER): kotlin/Int.inc>#()
    }
    public final fun test_3(x: R|kotlin/Int?|): R|kotlin/Unit| {
        while(Boolean(true)) {
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/lambdaAsReturnOfLambda.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/lambdaAsReturnOfLambda.dot
@@ -5,19 +5,26 @@ digraph lambdaAsReturnOfLambda_kt {

    subgraph cluster_0 {
        color=red
-        14 [label="Enter property" style="filled" fillcolor=red];
-        15 [label="Postponed enter to lambda"];
-        subgraph cluster_1 {
+        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 {
            color=blue
            0 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            subgraph cluster_2 {
+            subgraph cluster_3 {
                color=blue
                1 [label="Enter block"];
                2 [label="Postponed enter to lambda"];
-                subgraph cluster_3 {
+                subgraph cluster_4 {
                    color=blue
                    8 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-                    subgraph cluster_4 {
+                    subgraph cluster_5 {
                        color=blue
                        9 [label="Enter block"];
                        10 [label="Access variable R|<local>/foo|"];
@@ -36,15 +43,15 @@ digraph lambdaAsReturnOfLambda_kt {
            }
            7 [label="Exit function anonymousFunction" 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];
+        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];
    }
-    14 -> {15};
-    15 -> {16 0};
-    15 -> {0} [style=dashed];
    16 -> {17};
-    17 -> {18};
+    17 -> {18 0};
+    17 -> {0} [style=dashed];
+    18 -> {19};
+    19 -> {20};
    0 -> {1};
    1 -> {2};
    2 -> {3 8};
@@ -60,39 +67,39 @@ digraph lambdaAsReturnOfLambda_kt {
    11 -> {12};
    12 -> {13};

-    subgraph cluster_5 {
+    subgraph cluster_6 {
        color=red
-        19 [label="Enter function bar" style="filled" fillcolor=red];
-        subgraph cluster_6 {
+        21 [label="Enter function bar" style="filled" fillcolor=red];
+        subgraph cluster_7 {
            color=blue
-            20 [label="Enter block"];
-            21 [label="Exit block"];
+            22 [label="Enter block"];
+            23 [label="Exit block"];
        }
-        22 [label="Exit function bar" style="filled" fillcolor=red];
+        24 [label="Exit function bar" style="filled" fillcolor=red];
    }
-    19 -> {20};
-    20 -> {21};
    21 -> {22};
-
-    subgraph cluster_7 {
-        color=red
-        23 [label="Enter function run" style="filled" fillcolor=red];
-        subgraph cluster_8 {
-            color=blue
-            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];
-        }
-        29 [label="Exit function run" style="filled" fillcolor=red];
-    }
+    22 -> {23};
    23 -> {24};
-    24 -> {25};
+
+    subgraph cluster_8 {
+        color=red
+        25 [label="Enter function run" style="filled" fillcolor=red];
+        subgraph cluster_9 {
+            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];
+        }
+        31 [label="Exit function run" style="filled" fillcolor=red];
+    }
    25 -> {26};
-    26 -> {29};
-    26 -> {27} [style=dotted];
-    27 -> {28} [style=dotted];
+    26 -> {27};
+    27 -> {28};
+    28 -> {31};
    28 -> {29} [style=dotted];
+    29 -> {30} [style=dotted];
+    30 -> {31} [style=dotted];

 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/loops.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/loops.dot
@@ -118,49 +118,44 @@ 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
-                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|"];
+                43 [label="Enter while loop"];
                subgraph cluster_15 {
                    color=blue
-                    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"];
-                    }
+                    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"];
                    subgraph cluster_17 {
                        color=blue
-                        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"];
+                        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"];
                    }
-                    59 [label="Exit whileloop"];
+                    57 [label="Exit loop block"];
                }
-                60 [label="Exit block"];
+                58 [label="Exit whileloop"];
            }
-            61 [label="Access variable R|<local>/x|"];
-            62 [label="Type operator: (R|<local>/x| is R|kotlin/String|)"];
-            63 [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"];
        }
-        64 [label="Exit function testFor" style="filled" fillcolor=red];
+        62 [label="Exit function testFor" style="filled" fillcolor=red];
    }
    36 -> {37};
    37 -> {38};
@@ -173,8 +168,8 @@ digraph loops_kt {
    44 -> {45};
    45 -> {46};
    46 -> {47};
-    47 -> {48};
-    48 -> {59 49};
+    47 -> {58 48};
+    48 -> {49};
    49 -> {50};
    50 -> {51};
    51 -> {52};
@@ -183,226 +178,226 @@ digraph loops_kt {
    54 -> {55};
    55 -> {56};
    56 -> {57};
-    57 -> {58};
-    58 -> {45} [color=green style=dashed];
+    57 -> {44} [color=green style=dashed];
+    58 -> {59};
    59 -> {60};
    60 -> {61};
    61 -> {62};
-    62 -> {63};
-    63 -> {64};

-    subgraph cluster_19 {
+    subgraph cluster_18 {
        color=red
-        65 [label="Enter function testWhileTrue" style="filled" fillcolor=red];
-        subgraph cluster_20 {
+        63 [label="Enter function testWhileTrue" style="filled" fillcolor=red];
+        subgraph cluster_19 {
            color=blue
-            66 [label="Enter block"];
-            subgraph cluster_21 {
+            64 [label="Enter block"];
+            subgraph cluster_20 {
                color=blue
-                67 [label="Enter while loop"];
+                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"];
+                }
                subgraph cluster_22 {
                    color=blue
-                    68 [label="Enter loop condition"];
-                    69 [label="Const: Boolean(true)"];
-                    70 [label="Exit loop condition"];
-                }
-                subgraph cluster_23 {
-                    color=blue
-                    71 [label="Enter loop block"];
-                    subgraph cluster_24 {
+                    69 [label="Enter loop block"];
+                    subgraph cluster_23 {
                        color=blue
-                        72 [label="Enter block"];
-                        73 [label="Const: Int(1)"];
-                        74 [label="Exit block"];
+                        70 [label="Enter block"];
+                        71 [label="Const: Int(1)"];
+                        72 [label="Exit block"];
                    }
-                    75 [label="Exit loop block"];
+                    73 [label="Exit loop block"];
                }
-                76 [label="Exit whileloop" style="filled" fillcolor=gray];
+                74 [label="Exit whileloop" style="filled" fillcolor=gray];
            }
-            77 [label="Const: Int(1)" style="filled" fillcolor=gray];
-            78 [label="Exit block" style="filled" fillcolor=gray];
+            75 [label="Const: Int(1)" style="filled" fillcolor=gray];
+            76 [label="Exit block" style="filled" fillcolor=gray];
        }
-        79 [label="Exit function testWhileTrue" style="filled" fillcolor=red style="filled" fillcolor=gray];
+        77 [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 -> {74};
-    74 -> {75};
-    75 -> {68} [color=green style=dashed];
+    73 -> {66} [color=green style=dashed];
+    74 -> {75} [style=dotted];
+    75 -> {76} [style=dotted];
    76 -> {77} [style=dotted];
-    77 -> {78} [style=dotted];
-    78 -> {79} [style=dotted];

-    subgraph cluster_25 {
+    subgraph cluster_24 {
        color=red
-        80 [label="Enter function testWhileTrueWithBreak" style="filled" fillcolor=red];
-        subgraph cluster_26 {
+        78 [label="Enter function testWhileTrueWithBreak" style="filled" fillcolor=red];
+        subgraph cluster_25 {
            color=blue
-            81 [label="Enter block"];
-            subgraph cluster_27 {
+            79 [label="Enter block"];
+            subgraph cluster_26 {
                color=blue
-                82 [label="Enter while loop"];
+                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"];
+                }
                subgraph cluster_28 {
                    color=blue
-                    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 {
+                    84 [label="Enter loop block"];
+                    subgraph cluster_29 {
                        color=blue
-                        87 [label="Enter block"];
-                        subgraph cluster_31 {
+                        85 [label="Enter block"];
+                        subgraph cluster_30 {
                            color=blue
-                            88 [label="Enter when"];
+                            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"];
                            subgraph cluster_32 {
                                color=blue
-                                89 [label="Enter when branch condition "];
-                                90 [label="Access variable R|<local>/b|"];
-                                91 [label="Exit when branch condition"];
+                                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];
                            }
-                            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"];
+                            96 [label="Exit when branch result" style="filled" fillcolor=gray];
+                            97 [label="Exit when"];
                        }
-                        100 [label="Exit block"];
+                        98 [label="Exit block"];
                    }
-                    101 [label="Exit loop block"];
+                    99 [label="Exit loop block"];
                }
-                102 [label="Exit whileloop"];
+                100 [label="Exit whileloop"];
            }
-            103 [label="Const: Int(1)"];
-            104 [label="Exit block"];
+            101 [label="Const: Int(1)"];
+            102 [label="Exit block"];
        }
-        105 [label="Exit function testWhileTrueWithBreak" style="filled" fillcolor=red];
+        103 [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 -> {90};
-    90 -> {91};
-    91 -> {93 92};
-    92 -> {99};
-    93 -> {94};
-    94 -> {95};
-    95 -> {102};
+    89 -> {91 90};
+    90 -> {97};
+    91 -> {92};
+    92 -> {93};
+    93 -> {100};
+    93 -> {94} [style=dotted];
+    94 -> {95} [style=dotted];
    95 -> {96} [style=dotted];
    96 -> {97} [style=dotted];
-    97 -> {98} [style=dotted];
-    98 -> {99} [style=dotted];
-    99 -> {100};
+    97 -> {98};
+    98 -> {99};
+    99 -> {81} [color=green style=dashed];
    100 -> {101};
-    101 -> {83} [color=green style=dashed];
+    101 -> {102};
    102 -> {103};
-    103 -> {104};
-    104 -> {105};

-    subgraph cluster_34 {
+    subgraph cluster_33 {
        color=red
-        106 [label="Enter function testWhileFalse" style="filled" fillcolor=red];
-        subgraph cluster_35 {
+        104 [label="Enter function testWhileFalse" style="filled" fillcolor=red];
+        subgraph cluster_34 {
            color=blue
-            107 [label="Enter block"];
-            subgraph cluster_36 {
+            105 [label="Enter block"];
+            subgraph cluster_35 {
                color=blue
-                108 [label="Enter while loop"];
+                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"];
+                }
                subgraph cluster_37 {
                    color=blue
-                    109 [label="Enter loop condition"];
-                    110 [label="Const: Boolean(false)"];
-                    111 [label="Exit loop condition"];
-                }
-                subgraph cluster_38 {
-                    color=blue
-                    112 [label="Enter loop block" style="filled" fillcolor=gray];
-                    subgraph cluster_39 {
+                    110 [label="Enter loop block" style="filled" fillcolor=gray];
+                    subgraph cluster_38 {
                        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];
+                        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];
                    }
-                    116 [label="Exit loop block" style="filled" fillcolor=gray];
+                    114 [label="Exit loop block" style="filled" fillcolor=gray];
                }
-                117 [label="Exit whileloop"];
+                115 [label="Exit whileloop"];
            }
-            118 [label="Const: Int(1)"];
-            119 [label="Exit block"];
+            116 [label="Const: Int(1)"];
+            117 [label="Exit block"];
        }
-        120 [label="Exit function testWhileFalse" style="filled" fillcolor=red];
+        118 [label="Exit function testWhileFalse" style="filled" fillcolor=red];
    }
+    104 -> {105};
+    105 -> {106};
    106 -> {107};
    107 -> {108};
    108 -> {109};
-    109 -> {110};
-    110 -> {111};
-    111 -> {117};
+    109 -> {115};
+    109 -> {110} [style=dotted];
+    110 -> {111} [style=dotted];
    111 -> {112} [style=dotted];
    112 -> {113} [style=dotted];
    113 -> {114} [style=dotted];
-    114 -> {115} [style=dotted];
-    115 -> {116} [style=dotted];
-    116 -> {109} [color=green style=dotted];
+    114 -> {107} [color=green style=dotted];
+    115 -> {116};
+    116 -> {117};
    117 -> {118};
-    118 -> {119};
-    119 -> {120};

-    subgraph cluster_40 {
+    subgraph cluster_39 {
        color=red
-        121 [label="Enter function testDoWhileTrue" style="filled" fillcolor=red];
-        subgraph cluster_41 {
+        119 [label="Enter function testDoWhileTrue" style="filled" fillcolor=red];
+        subgraph cluster_40 {
            color=blue
-            122 [label="Enter block"];
-            subgraph cluster_42 {
+            120 [label="Enter block"];
+            subgraph cluster_41 {
                color=blue
-                123 [label="Enter do-while loop"];
-                subgraph cluster_43 {
+                121 [label="Enter do-while loop"];
+                subgraph cluster_42 {
                    color=blue
-                    124 [label="Enter loop block"];
-                    subgraph cluster_44 {
+                    122 [label="Enter loop block"];
+                    subgraph cluster_43 {
                        color=blue
-                        125 [label="Enter block"];
-                        126 [label="Const: Int(1)"];
-                        127 [label="Exit block"];
+                        123 [label="Enter block"];
+                        124 [label="Const: Int(1)"];
+                        125 [label="Exit block"];
                    }
-                    128 [label="Exit loop block"];
+                    126 [label="Exit loop block"];
                }
-                subgraph cluster_45 {
+                subgraph cluster_44 {
                    color=blue
-                    129 [label="Enter loop condition"];
-                    130 [label="Const: Boolean(true)"];
-                    131 [label="Exit loop condition"];
+                    127 [label="Enter loop condition"];
+                    128 [label="Const: Boolean(true)"];
+                    129 [label="Exit loop condition"];
                }
-                132 [label="Exit do-whileloop" style="filled" fillcolor=gray];
+                130 [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];
+            131 [label="Const: Int(1)" style="filled" fillcolor=gray];
+            132 [label="Exit block" style="filled" fillcolor=gray];
        }
-        135 [label="Exit function testDoWhileTrue" style="filled" fillcolor=red style="filled" fillcolor=gray];
+        133 [label="Exit function testDoWhileTrue" style="filled" fillcolor=red style="filled" fillcolor=gray];
    }
+    119 -> {120};
+    120 -> {121};
    121 -> {122};
    122 -> {123};
    123 -> {124};
@@ -411,128 +406,128 @@ digraph loops_kt {
    126 -> {127};
    127 -> {128};
    128 -> {129};
-    129 -> {130};
-    130 -> {131};
+    129 -> {130} [style=dotted];
+    129 -> {122} [color=green style=dashed];
+    130 -> {131} [style=dotted];
    131 -> {132} [style=dotted];
-    131 -> {124} [color=green style=dashed];
    132 -> {133} [style=dotted];
-    133 -> {134} [style=dotted];
-    134 -> {135} [style=dotted];

-    subgraph cluster_46 {
+    subgraph cluster_45 {
        color=red
-        136 [label="Enter function testDoWhileTrueWithBreak" style="filled" fillcolor=red];
-        subgraph cluster_47 {
+        134 [label="Enter function testDoWhileTrueWithBreak" style="filled" fillcolor=red];
+        subgraph cluster_46 {
            color=blue
-            137 [label="Enter block"];
-            subgraph cluster_48 {
+            135 [label="Enter block"];
+            subgraph cluster_47 {
                color=blue
-                138 [label="Enter do-while loop"];
-                subgraph cluster_49 {
+                136 [label="Enter do-while loop"];
+                subgraph cluster_48 {
                    color=blue
-                    139 [label="Enter loop block"];
-                    subgraph cluster_50 {
+                    137 [label="Enter loop block"];
+                    subgraph cluster_49 {
                        color=blue
-                        140 [label="Enter block"];
-                        subgraph cluster_51 {
+                        138 [label="Enter block"];
+                        subgraph cluster_50 {
                            color=blue
-                            141 [label="Enter when"];
+                            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"];
                            subgraph cluster_52 {
                                color=blue
-                                142 [label="Enter when branch condition "];
-                                143 [label="Access variable R|<local>/b|"];
-                                144 [label="Exit when branch condition"];
+                                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];
                            }
-                            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"];
+                            149 [label="Exit when branch result" style="filled" fillcolor=gray];
+                            150 [label="Exit when"];
                        }
-                        153 [label="Exit block"];
+                        151 [label="Exit block"];
                    }
-                    154 [label="Exit loop block"];
+                    152 [label="Exit loop block"];
                }
-                subgraph cluster_54 {
+                subgraph cluster_53 {
                    color=blue
-                    155 [label="Enter loop condition"];
-                    156 [label="Const: Boolean(true)"];
-                    157 [label="Exit loop condition"];
+                    153 [label="Enter loop condition"];
+                    154 [label="Const: Boolean(true)"];
+                    155 [label="Exit loop condition"];
                }
-                158 [label="Exit do-whileloop"];
+                156 [label="Exit do-whileloop"];
            }
-            159 [label="Const: Int(1)"];
-            160 [label="Exit block"];
+            157 [label="Const: Int(1)"];
+            158 [label="Exit block"];
        }
-        161 [label="Exit function testDoWhileTrueWithBreak" style="filled" fillcolor=red];
+        159 [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 -> {143};
-    143 -> {144};
-    144 -> {146 145};
-    145 -> {152};
-    146 -> {147};
-    147 -> {148};
-    148 -> {158};
+    142 -> {144 143};
+    143 -> {150};
+    144 -> {145};
+    145 -> {146};
+    146 -> {156};
+    146 -> {147} [style=dotted];
+    147 -> {148} [style=dotted];
    148 -> {149} [style=dotted];
    149 -> {150} [style=dotted];
-    150 -> {151} [style=dotted];
-    151 -> {152} [style=dotted];
+    150 -> {151};
+    151 -> {152};
    152 -> {153};
    153 -> {154};
    154 -> {155};
-    155 -> {156};
+    155 -> {156} [style=dotted];
+    155 -> {137} [color=green style=dashed];
    156 -> {157};
-    157 -> {158} [style=dotted];
-    157 -> {139} [color=green style=dashed];
+    157 -> {158};
    158 -> {159};
-    159 -> {160};
-    160 -> {161};

-    subgraph cluster_55 {
+    subgraph cluster_54 {
        color=red
-        162 [label="Enter function testDoWhileFalse" style="filled" fillcolor=red];
-        subgraph cluster_56 {
+        160 [label="Enter function testDoWhileFalse" style="filled" fillcolor=red];
+        subgraph cluster_55 {
            color=blue
-            163 [label="Enter block"];
-            subgraph cluster_57 {
+            161 [label="Enter block"];
+            subgraph cluster_56 {
                color=blue
-                164 [label="Enter do-while loop"];
-                subgraph cluster_58 {
+                162 [label="Enter do-while loop"];
+                subgraph cluster_57 {
                    color=blue
-                    165 [label="Enter loop block"];
-                    subgraph cluster_59 {
+                    163 [label="Enter loop block"];
+                    subgraph cluster_58 {
                        color=blue
-                        166 [label="Enter block"];
-                        167 [label="Const: Int(1)"];
-                        168 [label="Exit block"];
+                        164 [label="Enter block"];
+                        165 [label="Const: Int(1)"];
+                        166 [label="Exit block"];
                    }
-                    169 [label="Exit loop block"];
+                    167 [label="Exit loop block"];
                }
-                subgraph cluster_60 {
+                subgraph cluster_59 {
                    color=blue
-                    170 [label="Enter loop condition"];
-                    171 [label="Const: Boolean(false)"];
-                    172 [label="Exit loop condition"];
+                    168 [label="Enter loop condition"];
+                    169 [label="Const: Boolean(false)"];
+                    170 [label="Exit loop condition"];
                }
-                173 [label="Exit do-whileloop"];
+                171 [label="Exit do-whileloop"];
            }
-            174 [label="Const: Int(1)"];
-            175 [label="Exit block"];
+            172 [label="Const: Int(1)"];
+            173 [label="Exit block"];
        }
-        176 [label="Exit function testDoWhileFalse" style="filled" fillcolor=red];
+        174 [label="Exit function testDoWhileFalse" style="filled" fillcolor=red];
    }
+    160 -> {161};
+    161 -> {162};
    162 -> {163};
    163 -> {164};
    164 -> {165};
@@ -542,11 +537,9 @@ 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};

 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/loops.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/loops.fir.txt
@@ -14,13 +14,10 @@ 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|)
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.dot
+++ b/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 -> {27} [color=green];
-    6 -> {27} [style=dashed];
+    6 -> {29} [color=green];
+    6 -> {29} [style=dashed];

    subgraph cluster_3 {
        color=red
@@ -88,28 +88,35 @@ digraph postponedLambdaInConstructor_kt {

    subgraph cluster_8 {
        color=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 [label="Enter function getter" style="filled" fillcolor=red];
+        28 [label="Exit function getter" style="filled" fillcolor=red];
    }
    27 -> {28};
-    28 -> {29};
-    29 -> {7} [color=green];

    subgraph cluster_9 {
        color=red
-        30 [label="Enter function foo" style="filled" fillcolor=red];
-        subgraph cluster_10 {
-            color=blue
-            31 [label="Enter block"];
-            32 [label="Function call: this@R|/B|.R|/B.foo|()"];
-            33 [label="Exit block"];
-        }
-        34 [label="Exit function foo" style="filled" fillcolor=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 -> {32};
+    31 -> {7} [color=green];
+
+    subgraph cluster_10 {
+        color=red
+        32 [label="Enter function foo" style="filled" fillcolor=red];
+        subgraph cluster_11 {
+            color=blue
+            33 [label="Enter block"];
+            34 [label="Function call: this@R|/B|.R|/B.foo|()"];
+            35 [label="Exit block"];
+        }
+        36 [label="Exit function foo" style="filled" fillcolor=red];
+    }
    32 -> {33};
    33 -> {34};
+    34 -> {35};
+    35 -> {36};

 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.dot
@@ -21,298 +21,312 @@ digraph propertiesAndInitBlocks_kt {

    subgraph cluster_2 {
        color=red
-        5 [label="Enter property" style="filled" fillcolor=red];
-        6 [label="Const: Int(1)"];
-        7 [label="Exit property" style="filled" fillcolor=red];
+        5 [label="Enter function getter" style="filled" fillcolor=red];
+        6 [label="Exit function getter" style="filled" fillcolor=red];
    }
    5 -> {6};
-    6 -> {7};

    subgraph cluster_3 {
        color=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 [label="Enter property" style="filled" fillcolor=red];
+        8 [label="Const: Int(1)"];
+        9 [label="Exit property" style="filled" fillcolor=red];
    }
+    7 -> {8};
    8 -> {9};
-    9 -> {10};
-    10 -> {11};
-    11 -> {14};
-    11 -> {12} [style=dotted];
-    12 -> {13} [style=dotted];
-    13 -> {14} [style=dotted];

-    subgraph cluster_5 {
+    subgraph cluster_4 {
        color=red
-        15 [label="Enter function setter" style="filled" fillcolor=red];
-        subgraph cluster_6 {
+        10 [label="Enter function getter" style="filled" fillcolor=red];
+        subgraph cluster_5 {
            color=blue
-            16 [label="Enter block"];
-            17 [label="Const: Int(1)"];
-            18 [label="Assignment: F|/x2|"];
-            19 [label="Exit block"];
+            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];
        }
-        20 [label="Exit function setter" style="filled" fillcolor=red];
+        16 [label="Exit function getter" style="filled" fillcolor=red];
+    }
+    10 -> {11};
+    11 -> {12};
+    12 -> {13};
+    13 -> {16};
+    13 -> {14} [style=dotted];
+    14 -> {15} [style=dotted];
+    15 -> {16} [style=dotted];
+
+    subgraph cluster_6 {
+        color=red
+        17 [label="Enter function setter" style="filled" fillcolor=red];
+        subgraph cluster_7 {
+            color=blue
+            18 [label="Enter block"];
+            19 [label="Const: Int(1)"];
+            20 [label="Assignment: F|/x2|"];
+            21 [label="Exit block"];
+        }
+        22 [label="Exit function setter" style="filled" fillcolor=red];
    }
-    15 -> {16};
-    16 -> {17};
    17 -> {18};
    18 -> {19};
    19 -> {20};
-
-    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];
-    }
+    20 -> {21};
    21 -> {22};
-    22 -> {23};

    subgraph cluster_8 {
        color=red
-        35 [label="Enter function foo" style="filled" fillcolor=red];
-        subgraph cluster_9 {
-            color=blue
-            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];
-        }
-        45 [label="Exit function foo" style="filled" fillcolor=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 {
+            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];
+        }
+        47 [label="Exit function foo" style="filled" fillcolor=red];
    }
-    35 -> {36};
-    36 -> {37};
    37 -> {38};
    38 -> {39};
    39 -> {40};
    40 -> {41};
    41 -> {42};
-    42 -> {45}    [label=onUncaughtException];
-    42 -> {43} [style=dotted];
-    43 -> {44} [style=dotted];
+    42 -> {43};
+    43 -> {44};
+    44 -> {47}    [label=onUncaughtException];
    44 -> {45} [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};
+    45 -> {46} [style=dotted];
+    46 -> {47} [style=dotted];

    subgraph cluster_11 {
        color=red
-        49 [label="Enter init block" style="filled" fillcolor=red];
-        subgraph cluster_12 {
-            color=blue
-            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];
-        }
-        56 [label="Exit init block" style="filled" fillcolor=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};
-    50 -> {51};
+
+    subgraph cluster_12 {
+        color=red
+        51 [label="Enter init block" style="filled" fillcolor=red];
+        subgraph cluster_13 {
+            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];
+        }
+        58 [label="Exit init block" style="filled" fillcolor=red];
+    }
    51 -> {52};
-    52 -> {56}    [label=onUncaughtException];
-    52 -> {53} [style=dotted];
-    53 -> {54} [style=dotted];
+    52 -> {53};
+    53 -> {54};
+    54 -> {58}    [label=onUncaughtException];
    54 -> {55} [style=dotted];
    55 -> {56} [style=dotted];
-    56 -> {34} [color=green];
+    56 -> {57} [style=dotted];
+    57 -> {58} [style=dotted];
+    58 -> {36} [color=green];

-    subgraph cluster_13 {
+    subgraph cluster_14 {
        color=red
-        57 [label="Enter function getter" style="filled" fillcolor=red];
-        subgraph cluster_14 {
+        59 [label="Enter function getter" style="filled" fillcolor=red];
+        subgraph cluster_15 {
            color=blue
-            58 [label="Enter block"];
-            59 [label="Exit local class <getter>"];
-            60 [label="Exit block"];
+            60 [label="Enter block"];
+            61 [label="Exit local class <getter>"];
+            62 [label="Exit block"];
        }
-        61 [label="Exit function getter" style="filled" fillcolor=red];
+        63 [label="Exit function getter" style="filled" fillcolor=red];
    }
-    subgraph cluster_15 {
-        color=blue
-        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};
-    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];
+        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];
    }
-    65 -> {66};
-    66 -> {67};
+    59 -> {60};
+    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];

    subgraph cluster_17 {
        color=red
-        68 [label="Enter init block" style="filled" fillcolor=red];
-        subgraph cluster_18 {
-            color=blue
-            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];
-        }
-        74 [label="Exit init block" style="filled" fillcolor=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};
-    69 -> {70};
-    70 -> {71};
-    71 -> {74}    [label=onUncaughtException];
-    71 -> {72} [style=dotted];
-    72 -> {73} [style=dotted];
-    73 -> {74} [style=dotted];
-    74 -> {64} [color=green];

-    subgraph cluster_19 {
+    subgraph cluster_18 {
        color=red
-        75 [label="Enter property" style="filled" fillcolor=red];
-        76 [label="Postponed enter to lambda"];
-        subgraph cluster_20 {
+        70 [label="Enter init block" style="filled" fillcolor=red];
+        subgraph cluster_19 {
            color=blue
-            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];
-            }
+            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];
+        }
+        76 [label="Exit init block" style="filled" fillcolor=red];
+    }
+    70 -> {71};
+    71 -> {72};
+    72 -> {73};
+    73 -> {76}    [label=onUncaughtException];
+    73 -> {74} [style=dotted];
+    74 -> {75} [style=dotted];
+    75 -> {76} [style=dotted];
+    76 -> {66} [color=green];
+
+    subgraph cluster_20 {
+        color=red
+        77 [label="Enter property" style="filled" fillcolor=red];
+        78 [label="Postponed enter to lambda"];
+        subgraph cluster_21 {
+            color=blue
+            26 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
            subgraph cluster_22 {
                color=blue
-                32 [label="Enter class InitializerLocalClass" style="filled" fillcolor=red];
-                33 [label="Part of class initialization"];
-                34 [label="Exit class InitializerLocalClass" style="filled" fillcolor=red];
+                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];
            }
-            31 [label="Exit function anonymousFunction" 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 -> {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};
-    28 -> {79}    [label=onUncaughtException];
-    28 -> {29} [style=dotted];
-    29 -> {30} [style=dotted];
-    30 -> {31} [style=dotted];
-    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_23 {
-        color=red
-        80 [label="Enter property" style="filled" fillcolor=red];
-        subgraph cluster_24 {
-            color=blue
-            81 [label="Try expression enter"];
-            subgraph cluster_25 {
+            subgraph cluster_23 {
                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"];
+                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];
+        }
+        79 [label="Postponed exit from lambda"];
+        80 [label="Function call: R|/run|(...)"];
+        81 [label="Exit property" style="filled" fillcolor=red];
+    }
+    77 -> {78};
+    78 -> {26};
+    78 -> {79} [color=red];
+    78 -> {26} [style=dashed];
+    79 -> {80};
+    80 -> {81};
+    26 -> {33 27};
+    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];
+    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];
+
+    subgraph cluster_24 {
+        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 {
+            color=blue
+            85 [label="Try expression enter"];
            subgraph cluster_27 {
                color=blue
-                87 [label="Catch enter"];
+                86 [label="Try main block enter"];
                subgraph cluster_28 {
                    color=blue
-                    88 [label="Enter block"];
-                    89 [label="Const: Int(2)"];
-                    90 [label="Exit block"];
+                    87 [label="Enter block"];
+                    88 [label="Const: Int(1)"];
+                    89 [label="Exit block"];
                }
-                91 [label="Catch exit"];
+                90 [label="Try main block exit"];
            }
            subgraph cluster_29 {
                color=blue
-                92 [label="Enter finally"];
+                91 [label="Catch enter"];
                subgraph cluster_30 {
                    color=blue
-                    93 [label="Enter block"];
-                    94 [label="Const: Int(0)"];
-                    95 [label="Exit block"];
+                    92 [label="Enter block"];
+                    93 [label="Const: Int(2)"];
+                    94 [label="Exit block"];
                }
-                96 [label="Exit finally"];
+                95 [label="Catch exit"];
            }
-            97 [label="Try expression exit"];
+            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"];
        }
-        98 [label="Exit property" style="filled" fillcolor=red];
+        102 [label="Exit property" style="filled" fillcolor=red];
    }
-    80 -> {81};
-    81 -> {82 87};
-    81 -> {92}    [label=onUncaughtException];
-    82 -> {83};
-    83 -> {84};
    84 -> {85};
-    85 -> {86};
-    86 -> {92 87};
+    85 -> {86 91};
+    85 -> {96}    [label=onUncaughtException];
+    86 -> {87};
    87 -> {88};
-    87 -> {92}    [label=onUncaughtException];
    88 -> {89};
    89 -> {90};
-    90 -> {91};
+    90 -> {96 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};

 }
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.dot
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.dot
@@ -33,58 +33,72 @@ digraph safeCalls_kt {

    subgraph cluster_4 {
        color=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 [label="Enter function getter" style="filled" fillcolor=red];
+        9 [label="Exit function getter" style="filled" fillcolor=red];
    }
    8 -> {9};
-    9 -> {10};
-    10 -> {11 13};
-    11 -> {12};
-    12 -> {13};
-    13 -> {14 16};
-    14 -> {15};
-    15 -> {16};
-    16 -> {17};
-    17 -> {18};
+
+    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};

    subgraph cluster_6 {
        color=red
-        19 [label="Enter function test_2" style="filled" fillcolor=red];
+        12 [label="Enter function test_1" style="filled" fillcolor=red];
        subgraph cluster_7 {
            color=blue
-            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"];
+            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"];
        }
-        29 [label="Exit function test_2" style="filled" fillcolor=red];
+        22 [label="Exit function test_1" 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 24};
-    22 -> {23};
+    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];
+    }
    23 -> {24};
-    24 -> {25 27};
-    25 -> {26};
+    24 -> {25};
+    25 -> {26 28};
    26 -> {27};
    27 -> {28};
-    28 -> {29};
+    28 -> {29 31};
+    29 -> {30};
+    30 -> {31};
+    31 -> {32};
+    32 -> {33};

 }
--- a/compiler/fir/analysis-tests/testData/resolve/constVal/const.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/constVal/const.fir.txt
@@ -1,60 +0,0 @@
-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|
--- a/compiler/fir/analysis-tests/testData/resolve/constVal/const.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/constVal/const.kt
@@ -1,36 +0,0 @@
-// 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
--- a/compiler/fir/analysis-tests/testData/resolve/contracts/genericContract.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/contracts/genericContract.fir.txt
@@ -1,35 +0,0 @@
-FILE: genericContract.kt
-    public final inline fun <reified T> requreIsInstance(value: R|kotlin/Any|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> value is T
-        >
-     {
-        when () {
-            (R|<local>/value| !is R|T|) ->  {
-                throw R|java/lang/IllegalArgumentException.IllegalArgumentException|()
-            }
-        }
-
-    }
-    public final fun test_1(s: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/requreIsInstance|<R|kotlin/String|>(R|<local>/s|)
-        R|<local>/s|.R|kotlin/String.length|
-    }
-    public final inline fun <reified T> requreIsInstanceOf(value: R|kotlin/Any|, requiredValue: R|T|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> value is T
-        >
-     {
-        when () {
-            (R|<local>/value| !is R|T|) ->  {
-                throw R|java/lang/IllegalArgumentException.IllegalArgumentException|()
-            }
-        }
-
-    }
-    public final fun test_2(x: R|kotlin/Any|, s: R|kotlin/String|): R|kotlin/Unit| {
-        R|/requreIsInstanceOf|<R|kotlin/String|>(R|<local>/x|, R|<local>/s|)
-        R|<local>/x|.R|kotlin/String.length|
-    }
--- a/compiler/fir/analysis-tests/testData/resolve/contracts/genericContract.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/contracts/genericContract.kt
@@ -1,25 +0,0 @@
-// WITH_STDLIB
-
-import kotlin.contracts.*
-
-inline fun <reified T> requreIsInstance(value: Any) contract [
-    returns() implies (value is T)
-] {
-    if (value !is T) throw IllegalArgumentException()
-}
-
-fun test_1(s: Any) {
-    requreIsInstance<String>(s)
-    s.length
-}
-
-inline fun <reified T> requreIsInstanceOf(value: Any, requiredValue: T) contract [
-    returns() implies (value is T)
-] {
-    if (value !is T) throw IllegalArgumentException()
-}
-
-fun test_2(x: Any, s: String) {
-    requreIsInstanceOf(x, s)
-    x.length
-}
--- a/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt
@@ -11,7 +11,7 @@ interface KtLightMethod : PsiElement
 // With covariant array here we do not visit lambda (it.usage is KtLightMethod) below
 // Problem disappears if 'out' is removed
 fun <T> Array<out T>.filterNot(f: (T) -> Boolean): List<T> {
-    return <!RETURN_TYPE_MISMATCH!>this<!>
+    return this
 }

 fun <T> Array<T>.toList(): List<T>? = null
--- a/compiler/fir/analysis-tests/testData/resolve/delegates/kt41982.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegates/kt41982.fir.txt
@@ -18,7 +18,7 @@ FILE: kt41982.kt
        }

    }
-    public final fun <Type : R|Base|, Base : R|DelegateProvider<Base>|> R|Type|.long(initializer: R|(() -> kotlin/Long?)?| = Null(null)): R|Delegate<Type, kotlin/Long>| {
+    public final fun <Type : R|Base|, Base : R|DelegateProvider<Base>|> R|Type|.long(initializer: R|() -> kotlin/Long?| = Null(null)): R|Delegate<Type, kotlin/Long>| {
        ^long Null(null)!!
    }
    public final class Test : R|DelegateProvider<kotlin/Any>| {
--- a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
@@ -16,7 +16,7 @@ class B3_3 : A3("", true)
 class B3_4 : <!NONE_APPLICABLE!>A3<!>("", Unit)

 open class A4(val x: Byte)
-class B4 : A4( <!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
+class B4 : <!INAPPLICABLE_CANDIDATE!>A4<!>( 1 + 1)

 open class A5 {
    constructor(x: Byte)
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.fir.txt
@@ -50,5 +50,5 @@ FILE: annotationArgumentMustBeConst.kt
            public get(): R|kotlin/Int|

    }
-    @R|Ann1|(vararg(R|/foo|, R|/foo|.R|kotlin/String.plus|(R|/bar|), <strcat>(R|/foo|, String( ), R|/bar|), <strcat>(R|/baz|(), String( )))) @R|Ann2|(<implicitArrayOf>(R|/bar|, R|/baz|(), R|/bar|.R|kotlin/Int.plus|(R|/cnst|))) @R|Ann3|(R|/arr|) public final fun test(): R|kotlin/Unit| {
+    @R|Ann1|(vararg(R|/foo|, R|/foo|.R|kotlin/String.plus|(R|/bar|), <strcat>(R|/foo|.R|kotlin/Any.toString|(), String( ), R|/bar|.R|kotlin/Any.toString|()), <strcat>(R|/baz|().R|kotlin/Any.toString|(), String( )))) @R|Ann2|(<implicitArrayOf>(R|/bar|, R|/baz|(), R|/bar|.R|kotlin/Int.plus|(R|/cnst|))) @R|Ann3|(R|/arr|) public final fun test(): R|kotlin/Unit| {
    }
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt
@@ -38,15 +38,15 @@ fun test(z: Int, c: Char) {}

 typealias BA = A

-fun <<!CONFLICTING_UPPER_BOUNDS!>T<!>> kek(t: T) where T : (String) -> Any?, T : <!FINAL_UPPER_BOUND!>Char<!> {}
-fun <<!CONFLICTING_UPPER_BOUNDS!>T<!>> kek(t: T) where T : () -> Boolean, T : <!FINAL_UPPER_BOUND!>String<!> {}
+fun <T> kek(t: T) where T : (String) -> Any?, T : <!FINAL_UPPER_BOUND!>Char<!> {}
+fun <T> kek(t: T) where T : () -> Boolean, T : <!FINAL_UPPER_BOUND!>String<!> {}
 fun <T : <!FINAL_UPPER_BOUND!>Int<!>> kek(t: T) {}

 fun lol(a: Array<Int>) {}
 fun lol(a: Array<Boolean>) {}

-<!CONFLICTING_OVERLOADS!>fun <<!CONFLICTING_UPPER_BOUNDS!>T<!>> mem(t: T)<!> where T : () -> Boolean, T : <!FINAL_UPPER_BOUND!>String<!> {}
-<!CONFLICTING_OVERLOADS!>fun <<!CONFLICTING_UPPER_BOUNDS!>T<!>> mem(t: T)<!> where T : <!FINAL_UPPER_BOUND!>String<!>, T : () -> Boolean {}
+<!CONFLICTING_OVERLOADS!>fun <T> mem(t: T)<!> where T : () -> Boolean, T : <!FINAL_UPPER_BOUND!>String<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> mem(t: T)<!> where T : <!FINAL_UPPER_BOUND!>String<!>, T : () -> Boolean {}

 class M {
    companion <!REDECLARATION!>object<!> {}
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
@@ -25,7 +25,7 @@ class E<T> {
    // selection of the proper constructor
    // but a type mismatch for the first
    // argument
-    constructor(e: T, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 10) {}
+    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10) {}
 }

 class I<T> {
@@ -33,7 +33,7 @@ class I<T> {
    // selection of the proper constructor
    // but a type mismatch for the first
    // argument
-    constructor(e: T, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 10)
+    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10)
 }

 class J<T> {
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
@@ -7,9 +7,9 @@ class A {
 class B(other: B = <!NO_THIS!>this<!>)

 class C() {
-    constructor(x: Int) : this({
+    constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>({
        val a = 10
-        <!ARGUMENT_TYPE_MISMATCH, INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
+        <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
    }) {}
 }

--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt
@@ -2,7 +2,7 @@ fun foo() {
    <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Ann<!>

    @Ann class Local {
-        // There should also be NESTED_CLASS_NOT_ALLOWED report here.
-        <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation <!NESTED_CLASS_NOT_ALLOWED!>class Nested<!><!>
+        <!LOCAL_ANNOTATION_CLASS_ERROR{LT}!>// There should also be NESTED_CLASS_NOT_ALLOWED report here.
+        <!LOCAL_ANNOTATION_CLASS_ERROR{PSI}!>annotation <!NESTED_CLASS_NOT_ALLOWED!>class Nested<!><!><!>
    }
 }
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.fir.txt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.fir.txt
@@ -1,109 +0,0 @@
-FILE: multipleBounds.kt
-    public open class A : R|kotlin/Any| {
-        public constructor(): R|Jet87/A| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final fun foo(): R|kotlin/Int| {
-            ^foo Int(1)
-        }
-
-    }
-    public abstract interface B : R|kotlin/Any| {
-        public open fun bar(): R|kotlin/Double| {
-            ^bar Double(1.0)
-        }
-
-    }
-    public abstract interface G<X> : R|kotlin/Any| {
-        public abstract val <X : R|Jet87/A|, R|Jet87/B|> boo: R|kotlin/Double|
-            public get(): R|kotlin/Double|
-
-        public abstract val <A : R|Jet87/B|> bal: R|kotlin/Double|
-            public get(): R|kotlin/Double|
-
-        public abstract val <Y : R|Jet87/B|> bas: R|kotlin/Double|
-            public get(): R|kotlin/Double|
-
-    }
-    public final class C : R|Jet87/A|, R|Jet87/B| {
-        public constructor(): R|Jet87/C| {
-            super<R|Jet87/A|>()
-        }
-
-    }
-    public final class D : R|kotlin/Any| {
-        public constructor(): R|Jet87/D| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final companion object Companion : R|Jet87/A|, R|Jet87/B| {
-            private constructor(): R|Jet87/D.Companion| {
-                super<R|Jet87/A|>()
-            }
-
-        }
-
-    }
-    public final class Test1<T : R|Jet87/A|, R|Jet87/B|> : R|kotlin/Any| {
-        public constructor<T : R|Jet87/A|, R|Jet87/B|>(): R|Jet87/Test1<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final fun test(t: R|T|): R|kotlin/Unit| {
-            R|?|.<Unresolved name: foo>#()
-            R|?|.<Unresolved name: bar>#()
-            R|<local>/t|.R|Jet87/A.foo|()
-            R|<local>/t|.R|Jet87/B.bar|()
-        }
-
-    }
-    public final fun test(): R|kotlin/Unit| {
-        R|Jet87/Test1.Test1|<R|Jet87/B|>()
-        R|Jet87/Test1.Test1|<R|Jet87/A|>()
-        R|Jet87/Test1.Test1|<R|Jet87/C|>()
-    }
-    public final class Foo : R|kotlin/Any| {
-        public constructor(): R|Jet87/Foo| {
-            super<R|kotlin/Any|>()
-        }
-
-    }
-    public final class Bar<T : R|Jet87/Foo|> : R|kotlin/Any| {
-        public constructor<T : R|Jet87/Foo|>(): R|Jet87/Bar<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-    }
-    public final class Buzz<T : R|Jet87/Bar<kotlin/Int>|, <ERROR TYPE REF: Symbol not found for nioho>> : R|kotlin/Any| {
-        public constructor<T : R|Jet87/Bar<kotlin/Int>|, <ERROR TYPE REF: Symbol not found for nioho>>(): R|Jet87/Buzz<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-    }
-    public final class X<T : R|Jet87/Foo|> : R|kotlin/Any| {
-        public constructor<T : R|Jet87/Foo|>(): R|Jet87/X<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-    }
-    public final class Y<T : R|Jet87/Foo|, R|Jet87/Bar<Jet87/Foo>|> : R|kotlin/Any| {
-        public constructor<T : R|Jet87/Foo|, R|Jet87/Bar<Jet87/Foo>|>(): R|Jet87/Y<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-    }
-    public final fun <T : R|Jet87/A|, R|Jet87/B|> test2(t: R|T|): R|kotlin/Unit| {
-        R|?|.<Unresolved name: foo>#()
-        R|?|.<Unresolved name: bar>#()
-        R|<local>/t|.R|Jet87/A.foo|()
-        R|<local>/t|.R|Jet87/B.bar|()
-    }
-    public final val t1: R|kotlin/Unit| = <Inapplicable(INAPPLICABLE): Jet87/test2>#<R|Jet87/A|>(R|Jet87/A.A|())
-        public get(): R|kotlin/Unit|
-    public final val t2: R|kotlin/Unit| = <Inapplicable(INAPPLICABLE): Jet87/test2>#<R|Jet87/B|>(R|Jet87/C.C|())
-        public get(): R|kotlin/Unit|
-    public final val t3: R|kotlin/Unit| = R|Jet87/test2|<R|Jet87/C|>(R|Jet87/C.C|())
-        public get(): R|kotlin/Unit|
-    public final val <T, B : R|T|> x: R|kotlin/Int| = Int(0)
-        public get(): R|kotlin/Int|
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt
@@ -1,69 +0,0 @@
-package Jet87
-
-open class A() {
-  fun foo() : Int = 1
-}
-
-interface B {
-  fun bar() : Double = 1.0;
-}
-
-interface G<X> {
-    val <<!TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER!>X<!>> boo: Double  where X : A, X : B
-    val <<!TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER!>A<!>> bal: Double  where A : B
-    val <<!TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER!>Y<!>> bas: Double where Y : B, <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>X<!> : B
-}
-
-class C() : A(), B
-
-class D() {
-  companion object : A(), B {}
-}
-
-class Test1<T>()
-  where
-    T : A,
-    T : B,
-    <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T // error
-  {
-
-  fun test(t : T) {
-    <!TYPE_PARAMETER_ON_LHS_OF_DOT!>T<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
-    <!TYPE_PARAMETER_ON_LHS_OF_DOT!>T<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
-    t.foo()
-    t.bar()
-  }
-}
-
-fun test() {
-  Test1<<!UPPER_BOUND_VIOLATED!>B<!>>()
-  Test1<<!UPPER_BOUND_VIOLATED!>A<!>>()
-  Test1<C>()
-}
-
-class Foo() {}
-
-class Bar<T : <!FINAL_UPPER_BOUND!>Foo<!>>
-
-class Buzz<T> where T : <!FINAL_UPPER_BOUND!>Bar<Int><!>, T : <!UNRESOLVED_REFERENCE!>nioho<!>
-
-class X<T : <!FINAL_UPPER_BOUND!>Foo<!>>
-class Y<<!CONFLICTING_UPPER_BOUNDS!>T<!>> where T : <!FINAL_UPPER_BOUND!>Foo<!>, T : <!FINAL_UPPER_BOUND, ONLY_ONE_CLASS_BOUND_ALLOWED!>Bar<Foo><!>
-
-fun <T> test2(t : T)
-  where
-    T : A,
-    T : B,
-    <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T
-{
-  <!TYPE_PARAMETER_ON_LHS_OF_DOT!>T<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
-  <!TYPE_PARAMETER_ON_LHS_OF_DOT!>T<!>.<!UNRESOLVED_REFERENCE!>bar<!>()
-  t.foo()
-  t.bar()
-}
-
-val t1 = test2<A>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
-val t2 = test2<B>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
-val t3 = test2<C>(C())
-
-val <<!TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER!>T<!>, <!TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER!>B : T<!>> x : Int = 0
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
@@ -26,7 +26,7 @@ class G<E : <!FINAL_UPPER_BOUND!>Double<!>>(val balue: E) : F<E>(balue) {
    override var rest: E = balue
 }

-class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : F<E>(<!ARGUMENT_TYPE_MISMATCH!>balue<!>) {
+class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
    override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE
 }

--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
@@ -27,7 +27,7 @@ class G<E : <!FINAL_UPPER_BOUND!>Double<!>>(val balue: E) : F<E>(balue) {
    override fun rest(): E = balue
 }

-class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : F<E>(<!ARGUMENT_TYPE_MISMATCH!>balue<!>) {
+class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
    override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE
 }

@@ -57,7 +57,7 @@ open class J() : S() {
 }

 open class Base<T : X, Z : T> {
-    open fun kek(): Z = <!RETURN_TYPE_MISMATCH!>Z()<!>
+    open fun kek(): Z = Z()
 }

 open class GoodDerrived : Base<Y, W>() {
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
@@ -1,3 +1,3 @@
 sealed class A

-val b = <!INVISIBLE_REFERENCE!>A<!>()
+val b = <!HIDDEN!>A<!>()
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Victor Petukhov	afd7d75308	1	2021-04-08 17:39:20 +03:00
Victor Petukhov	0539093cd6	1	2021-04-08 17:39:19 +03:00
Victor Petukhov	d4d0a6284f	Support type enhancement on freshly supported module level annotations	2021-04-08 17:39:09 +03:00
Victor Petukhov	60dde7e85c	1	2021-04-08 17:39:08 +03:00
Victor Petukhov	e718887f27	1	2021-04-08 17:39:07 +03:00
Victor Petukhov	0aa5ea5e07	Support reading annotations on java 9 module on sources and binaries	2021-04-08 17:39:06 +03:00
Victor Petukhov	41b91421bc	Add binary java 9 modules properly in the tests	2021-04-08 17:39:05 +03:00
Victor Petukhov	141de1f2e6	Add directive `ALL_JAVA_AS_BINARIES` and use it explicitly for foreign annotations tests with compiled java	2021-04-08 17:39:03 +03:00
Victor Petukhov	0643f42cb6	Add extraModulepath	2021-04-08 17:39:03 +03:00
Victor Petukhov	d3694f54df	Revert abstract	2021-04-08 17:39:01 +03:00
Victor Petukhov	a076cfe5a1	Move jspecify tests	2021-04-08 17:38:51 +03:00
Victor Petukhov	de52e4b5c2	Revert abstract	2021-04-08 17:38:50 +03:00
Victor Petukhov	721abc0f93	Update some third-party annotations	2021-04-08 17:38:49 +03:00
Victor Petukhov	926217ef1c	Add basic diagnostic tests for java 9 modules	2021-04-08 17:38:48 +03:00
Victor Petukhov	800ab67861	Support java 9 modules in the diagnostic tests both in sources and binaries	2021-04-08 17:38:46 +03:00
Victor Petukhov	f63376199a	Revert tests	2021-04-08 17:38:46 +03:00
Victor Petukhov	a929fd00f2	Revert abstract	2021-04-08 17:38:44 +03:00
Victor Petukhov	242ad24463	Introduce special common directives for tests based on foreign annotation tests	2021-04-08 17:38:03 +03:00
Victor Petukhov	a63c540eb8	1	2021-04-08 17:38:02 +03:00
Victor Petukhov	98ce95ca5c	[Jspecify] Move diagnostic tests against compiled java under the new tests infrastructure	2021-04-08 17:38:01 +03:00
Victor Petukhov	73f1f5d8c7	[Jspecify] Move jspecify test runner under the new tests infrastructure	2021-04-08 17:38:00 +03:00
Victor Petukhov	df21b14cb2	Move foreign annotation tests into diagnostics folder	2021-04-08 17:37:58 +03:00
Victor Petukhov	9f12e95109	[Jspecify] Remove Kotlin use sites generator: consider manually picking changes from the jspecify repo	2021-04-08 17:37:27 +03:00
Victor Petukhov	221919aa71	1	2021-04-08 17:37:26 +03:00
Victor Petukhov	05cd06479e	Clean-up JavaModuleInfo.kt	2021-04-08 17:37:26 +03:00
				`@@ -1 +0,0 @@`
				`public final fun <T> foo(x: R\|T!!\|, y: R\|kotlin/collections/List<T!!>\|, z: R\|(T!!) -> T!!\|): R\|T!!\|`