Fix 1.4-M2 ChangeLog.md

Unfortunately there is some test data that checks that it was
dev version, not eap version, so I picked an dev version instead.

.bunch

@@ -4,4 +4,5 @@
 191_192
 as35_191_192
 as36_192
-as40
+as40
+as41_201

.idea/artifacts/dist_root.xml

@@ -1,8 +0,0 @@
-<component name="ArtifactManager">
-  <artifact build-on-make="true" name="dist_root">
-    <output-path>$PROJECT_DIR$/dist</output-path>
-    <root id="root">
-      <element id="artifact" artifact-name="dist" />
-    </root>
-  </artifact>
-</component>

build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMapping
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
@@ -476,8 +477,21 @@ open class IncrementalJvmCache(
             if (inlineFunctions.isEmpty()) return emptyMap()
 
             val result = HashMap<String, Long>()
-
+            var dummyVersion: Int = -1
             ClassReader(bytes).accept(object : ClassVisitor(Opcodes.API_VERSION) {
+
+                override fun visit(
+                    version: Int,
+                    access: Int,
+                    name: String?,
+                    signature: String?,
+                    superName: String?,
+                    interfaces: Array<out String>?
+                ) {
+                    super.visit(version, access, name, signature, superName, interfaces)
+                    dummyVersion = version
+                }
+
                 override fun visitMethod(
                     access: Int,
                     name: String,
@@ -485,7 +499,8 @@ open class IncrementalJvmCache(
                     signature: String?,
                     exceptions: Array<out String>?
                 ): MethodVisitor? {
-                    val dummyClassWriter = ClassWriter(Opcodes.API_VERSION)
+                    val dummyClassWriter = ClassWriter(0)
+                    dummyClassWriter.visit(dummyVersion, 0, "dummy", null, AsmTypes.OBJECT_TYPE.internalName, null)
 
                     return object : MethodVisitor(Opcodes.API_VERSION, dummyClassWriter.visitMethod(0, name, desc, null, exceptions)) {
                         override fun visitEnd() {
@@ -493,6 +508,7 @@ open class IncrementalJvmCache(
                             if (jvmName !in inlineFunctions) return
 
                             val dummyBytes = dummyClassWriter.toByteArray()!!
+
                             val hash = dummyBytes.md5()
                             result[jvmName] = hash
                         }

build.gradle.kts

@@ -181,7 +181,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.4-M2-dev-15123"
+    extra["versions.kotlin-native"] = "1.4-M2"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -365,7 +365,6 @@ allprojects {
         "-Xread-deserialized-contracts",
         "-Xjvm-default=compatibility",
         "-Xno-optimized-callable-references",
-        "-Xno-kotlin-nothing-value-exception",
         "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
@@ -601,7 +600,6 @@ tasks {
 //        dependsOn(":kotlin-scripting-jvm-host-test:embeddableTest")
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
-        dependsOn(":kotlin-scripting-ide-services-test:test")
     }
 
     register("compilerTest") {

buildSrc/gradle.properties.as35

@@ -1,8 +0,0 @@
-org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m -Dfile.encoding=UTF-8
-
-cacheRedirectorEnabled=true
-
-#buildSrc.kotlin.repo=https://jcenter.bintray.com
-#buildSrc.kotlin.version=1.1.50
-
-intellijUltimateEnabled=false

buildSrc/gradle.properties.as36

@@ -1,8 +0,0 @@
-org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m -Dfile.encoding=UTF-8
-
-cacheRedirectorEnabled=true
-
-#buildSrc.kotlin.repo=https://jcenter.bintray.com
-#buildSrc.kotlin.version=1.1.50
-
-intellijUltimateEnabled=false

buildSrc/gradle.properties.as40

@@ -1,8 +0,0 @@
-org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m -Dfile.encoding=UTF-8
-
-cacheRedirectorEnabled=true
-
-#buildSrc.kotlin.repo=https://jcenter.bintray.com
-#buildSrc.kotlin.version=1.1.50
-
-intellijUltimateEnabled=false

buildSrc/prepare-deps/build.gradle.kts

@@ -25,7 +25,7 @@ val androidStudioRelease = rootProject.findProperty("versions.androidStudioRelea
 val androidStudioBuild = rootProject.findProperty("versions.androidStudioBuild") as String?
 val intellijSeparateSdks: Boolean by rootProject.extra
 val installIntellijCommunity = !intellijUltimateEnabled || intellijSeparateSdks
-val installIntellijUltimate = intellijUltimateEnabled
+val installIntellijUltimate = intellijUltimateEnabled && androidStudioRelease == null
 
 val intellijVersionDelimiterIndex = intellijVersion.indexOfAny(charArrayOf('.', '-'))
 if (intellijVersionDelimiterIndex == -1) {

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -50,7 +50,8 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
 
     AS35(Platform.P183),
     AS36(Platform.P192),
-    AS40(Platform.P193);
+    AS40(Platform.P193),
+    AS41(Platform.P201);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

compiler/android-tests/android-module/build.gradle

@@ -1,7 +1,5 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
-ext {
-    isD8Enabled = project.findProperty('android.enableD8').toBoolean()
-}
+
 buildscript {
     repositories {
         google()
@@ -60,42 +58,21 @@ android {
         resultsDir = "build/test/results"
     }
 
-    if (isD8Enabled) {
-        compileOptions {
-            sourceCompatibility = 1.8
-            targetCompatibility = 1.8
-        }
-    }
 
     flavorDimensions "box"
 
     productFlavors {
-        common0 {
+        ktest0 {
             dimension "box"
         }
 
-        common1 {
+        ktest1 {
             dimension "box"
         }
 
-        common2 {
+        ktest2 {
             dimension "box"
         }
-
-        reflect0 {
-            dimension "box"
-        }
-
-
-        if (isD8Enabled) {
-            jvm80 {
-                dimension "box"
-            }
-
-            reflectjvm80 {
-                dimension "box"
-            }
-        }
     }
 
 }
@@ -103,9 +80,9 @@ android {
 task jarTestFolders() {
     println "Jar folders..."
     new File("${projectDir}/libs/").listFiles().each { File file ->
-        if (file.isDirectory()) {
+        if (file.isDirectory() && !file.name.equals("test")) {
             println "Jar '${file.name}' folder..."
-            ant.jar(basedir: "libs/${file.name}/", destfile: "libs/" +  file.name  + ".jar")
+            ant.jar(basedir: "libs/${file.name}/", destfile: "libs/test/" +  file.name  + ".jar")
         }
     }
 }
@@ -115,18 +92,11 @@ tasks.withType(JavaCompile) {
 }
 
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['kotlin-test.jar', 'kotlin-stdlib.jar'])
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
     androidTestImplementation 'junit:junit:4.12'
     androidTestImplementation 'com.android.support.test:runner:1.0.2'
 
-    android.applicationVariants.all { variant ->
-        variant.productFlavors.each {
-            def configuration = configurations.getByName(it.name + 'Implementation').name
-            add(configuration, project.fileTree(dir: 'libs', include: [it.name + ".jar"]))
-
-            if (it.name.startsWith("reflect")) {
-                add(configuration, project.fileTree(dir: 'libs', include: ['kotlin-reflect.jar']))
-            }
-        }
-    }
+    ktest0Implementation fileTree(dir: 'libs/test', include: ['libtest0.jar'])
+    ktest1Implementation fileTree(dir: 'libs/test', include: ['libtest1.jar'])
+    ktest2Implementation fileTree(dir: 'libs/test', include: ['libtest2.jar'])
 }

compiler/android-tests/android-module/gradle.properties

@@ -1,3 +1,3 @@
 #don't try to download android specific tools within gradle: licence acceptance will be required
 android.builder.sdkDownload=false
-android.enableD8=true
+android.enableD8=false

compiler/android-tests/src/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidRunner.kt

@@ -52,16 +52,16 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
             try {
                 emulator.waitEmulatorStart()
 
-                runTestsOnEmulator(gradleRunner, TestSuite("D8")).apply {
+                runTestsOnEmulator(gradleRunner, TestSuite("Dex")).apply {
                     rootSuite.addTest(this)
                 }
 
                 renameFlavorFolder()
-                enableD8(false)
-                runTestsOnEmulator(gradleRunner, TestSuite("DX")).apply {
+                enableD8(true)
+                runTestsOnEmulator(gradleRunner, TestSuite("D8")).apply {
                     (0 until this.countTestCases()).forEach {
                         val testCase = testAt(it) as TestCase
-                        testCase.name += "_DX"
+                        testCase.name += "_D8"
                     }
                     rootSuite.addTest(this)
                 }
@@ -102,14 +102,14 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
                 testCases.forEach { aCase -> suite.addTest(aCase) }
                 Assert.assertNotEquals("There is no test results in report", 0, testCases.size.toLong())
             }
-        } catch (e: Throwable) {
+        } catch (e: Exception) {
             throw RuntimeException("Can't parse test results in $reportFolder\n$resultOutput", e)
         }
     }
 
     private fun renameFlavorFolder() {
         val reportFolder = File(flavorFolder())
-        reportFolder.renameTo(File(reportFolder.parentFile, reportFolder.name + "_d8"))
+        reportFolder.renameTo(File(reportFolder.parentFile, reportFolder.name + "_dex"))
     }
 
     private fun flavorFolder() = pathManager.tmpFolder + "/build/test/results/connected/flavors"

compiler/android-tests/src/org/jetbrains/kotlin/android/tests/PathManager.java

@@ -52,8 +52,8 @@ public class PathManager {
         return getAndroidSdkRoot() + "/emulator";
     }
 
-    public String getOutputForCompiledFiles(String flavor) {
-        return tmpFolder + "/libs/" + flavor;
+    public String getOutputForCompiledFiles(int index) {
+        return tmpFolder + "/libs/libtest" + index;
     }
 
     public String getLibsFolderInAndroidTmpFolder() {

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidTestGenerator.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.android.tests
 
 import com.intellij.openapi.util.Ref
+import org.jetbrains.kotlin.codegen.CodegenTestCase
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -46,21 +47,18 @@ internal fun patchFilesAndAddTest(
 
     val newPackagePrefix = testFile.path.replace("\\\\|-|\\.|/".toRegex(), "_")
     val oldPackage = Ref<FqName>()
-    val isJvmName = Ref<Boolean>(false)
     val isSingle = testFiles.size == 1
     val resultFiles = testFiles.map {
         val fileName = if (isSingle) it.name else testFile.name.substringBeforeLast(".kt") + "/" + it.name
         TestClassInfo(
             fileName,
-            changePackage(newPackagePrefix, it.content, oldPackage, isJvmName),
+            changePackage(newPackagePrefix, it.content, oldPackage),
             oldPackage.get(),
-            isJvmName.get(),
             getGeneratedClassName(File(fileName), it.content, newPackagePrefix, oldPackage.get())
         )
     }
     val packages =
-        resultFiles.map { OldPackageAndNew(it.oldPackage, it.newPackagePartClassId.parent()) }
-            .sortedByDescending { it.oldFqName.asString().length }
+        resultFiles.map { OldPackageAndNew(it.oldPackage, it.newClassId.parent()) }.sortedByDescending { it.oldFqName.asString().length }
 
     //If files contain any val or var declaration with same name as any package name
     // then use old conservative renaming scheme, otherwise use aggressive one
@@ -97,7 +95,7 @@ internal fun patchFilesAndAddTest(
     /*replace all Class.forName*/
     resultFiles.forEach { file ->
         file.content = resultFiles.fold(file.content) { r, param ->
-            patchClassForName(param.newPackagePartClassId, param.oldPackage, r, conservativeRenameScheme)
+            patchClassForName(param.newClassId, param.oldPackage, r, conservativeRenameScheme)
         }
     }
 
@@ -106,13 +104,6 @@ internal fun patchFilesAndAddTest(
         file.content = file.content.patchSelfImports(file.newPackage)
     }
 
-    //patch root package parts usages in strings
-    resultFiles.forEach { file ->
-        file.content = resultFiles.fold(file.content) { r, param ->
-            patchRootPartNamesInStrings(param.newPackagePartClassId, param.oldPackage, param.isJvmName, r)
-        }
-    }
-
     val boxFiles = resultFiles.filter { hasBoxMethod(it.content) }
     if (boxFiles.size != 1) {
         println("Several box methods in $testFile")
@@ -120,22 +111,22 @@ internal fun patchFilesAndAddTest(
 
     filesHolder.addTest(
         resultFiles.filter { resultFile -> resultFile.name.endsWith(".kt") || resultFile.name.endsWith(".kts") },
-        TestInfo("", boxFiles.last().newPackagePartClassId, testFile)
+        TestInfo("", boxFiles.last().newClassId, testFile)
     )
 
-    return boxFiles.last().newPackagePartClassId
+    return boxFiles.last().newClassId
 }
 
 private fun hasBoxMethod(text: String): Boolean {
     return text.contains("fun box()")
 }
 
-class TestClassInfo(val name: String, var content: String, val oldPackage: FqName, val isJvmName: Boolean, val newPackagePartClassId: FqName) {
-    val newPackage = newPackagePartClassId.parent()
+class TestClassInfo(val name: String, var content: String, val oldPackage: FqName, val newClassId: FqName) {
+    val newPackage = newClassId.parent()
 }
 
 
-private fun changePackage(newPackagePrefix: String, text: String, oldPackage: Ref<FqName>, isJvmName: Ref<Boolean>): String {
+private fun changePackage(newPackagePrefix: String, text: String, oldPackage: Ref<FqName>): String {
     val matcher = packagePattern.matcher(text)
     if (matcher.find()) {
         val oldPackageName = matcher.toMatchResult().group(1)
@@ -147,7 +138,6 @@ private fun changePackage(newPackagePrefix: String, text: String, oldPackage: Re
         if (text.contains("@file:")) {
             val index = text.lastIndexOf("@file:")
             val packageDirectiveIndex = text.indexOf("\n", index)
-            isJvmName.set(true)
             return text.substring(0, packageDirectiveIndex + 1) + packageDirective + text.substring(packageDirectiveIndex + 1)
         } else {
             return packageDirective + text
@@ -180,19 +170,6 @@ private fun patchClassForName(className: FqName, oldPackage: FqName, text: Strin
     )
 }
 
-private fun patchRootPartNamesInStrings(
-    className: FqName,
-    oldPackage: FqName,
-    isJvmName: Boolean,
-    text: String
-): String {
-    if (!oldPackage.isRoot || isJvmName) return text
-    return text.replace(
-        ("\"" + oldPackage.child(className.shortName()).asString()).toRegex(),
-        "\"" + className.asString()
-    )
-}
-
 private fun patchPackages(newPackage: FqName, oldPackage: FqName, text: String): String {
     if (oldPackage.isRoot) return text
 

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.android.tests
 
-import com.intellij.openapi.Disposable
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.util.io.FileUtil
@@ -19,56 +18,35 @@ import org.jetbrains.kotlin.codegen.GenerationUtils
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.*
 import org.junit.Assert
+import org.junit.Ignore
 import java.io.File
 import java.io.FileWriter
 import java.io.IOException
-import kotlin.test.assertTrue
 
 data class ConfigurationKey(val kind: ConfigurationKind, val jdkKind: TestJdkKind, val configuration: String)
 
-class CodegenTestsOnAndroidGenerator private constructor(private val pathManager: PathManager) {
+@Ignore
+class CodegenTestsOnAndroidGenerator private constructor(private val pathManager: PathManager) : CodegenTestCase() {
+    private var writtenFilesCount = 0
+
     private var currentModuleIndex = 1
 
     private val pathFilter: String? = System.getProperties().getProperty("kotlin.test.android.path.filter")
 
-    private val pendingUnitTestGenerators = hashMapOf<String, UnitTestFileWriter>()
+    private val pendingUnitTestGenerators = hashMapOf<Int, UnitTestFileWriter>()
 
     //keep it globally to avoid test grouping on TC
     private val generatedTestNames = hashSetOf<String>()
 
-    private val COMMON = FlavorConfig("common", 3);
-    private val REFLECT = FlavorConfig("reflect", 1);
-    private val JVM8 = FlavorConfig("jvm8", 1);
-    private val JVM8REFLECT = FlavorConfig("reflectjvm8", 1);
-
-    class FlavorConfig(private val prefix: String, val limit: Int) {
-
-        private var writtenFilesCount = 0
-
-        fun printStatistics() {
-            println("FlavorTestCompiler: $prefix, generated file count: $writtenFilesCount")
-        }
-
-        fun getFlavorForNewFiles(newFilesCount: Int): String {
-            writtenFilesCount += newFilesCount
-            //2500 files per folder that would be used by flavor to avoid multidex usage,
-            // each folder would be jared by build.gradle script
-            val index = writtenFilesCount / 2500
-
-            return getFlavorName(index, prefix).also {
-                assertTrue("Please Add  new flavor in build.gradle for $it") { index < limit }
-            }
-        }
-
-        private fun getFlavorName(index: Int, prefix: String): String {
-            return prefix + index
-        }
-
+    fun getFlavorUnitTestFilePath(index: Int): String {
+        return pathManager.srcFolderInAndroidTmpFolder + "/androidTestKtest$index/java/" + testClassPackage.replace(
+            ".",
+            "/"
+        ) + "/" + testClassName + "$index.java"
     }
 
     private fun prepareAndroidModuleAndGenerateTests(skipSdkDirWriting: Boolean) {
@@ -148,15 +126,9 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         holders.values.forEach {
             it.writeFilesOnDisk()
         }
-
-        COMMON.printStatistics()
-        REFLECT.printStatistics()
-        JVM8.printStatistics()
-        JVM8REFLECT.printStatistics()
     }
 
     internal inner class FilesWriter(
-        private val flavorConfig: FlavorConfig,
         private val configuration: CompilerConfiguration
     ) {
         private val rawFiles = arrayListOf<TestClassInfo>()
@@ -171,40 +143,38 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
 
         fun writeFilesOnDisk() {
-            val disposable = Disposer.newDisposable()
+            val disposable = TestDisposable()
+
             val environment = KotlinCoreEnvironment.createForTests(
                 disposable,
                 configuration.copy().apply { put(CommonConfigurationKeys.MODULE_NAME, "android-module-" + currentModuleIndex++) },
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
             )
 
-            try {
-                writeFiles(
-                    rawFiles.map {
-                        try {
-                            CodegenTestFiles.create(it.name, it.content, environment.project).psiFile
-                        } catch (e: Throwable) {
-                            throw RuntimeException("Error on processing ${it.name}:\n${it.content}", e)
-                        }
-                    }, environment, unitTestDescriptions
-                )
-            } finally {
-                rawFiles.clear()
-                unitTestDescriptions.clear()
-                Disposer.dispose(disposable)
-            }
+            writeFiles(
+                rawFiles.map {
+                    try {
+                        CodegenTestFiles.create(it.name, it.content, environment.project).psiFile
+                    } catch (e: Throwable) {
+                        throw RuntimeException("Error on processing ${it.name}:\n${it.content}", e)
+                    }
+                }, environment
+            )
+            Disposer.dispose(disposable)
+            rawFiles.clear()
+            unitTestDescriptions.clear()
         }
 
-        private fun writeFiles(
-            filesToCompile: List<KtFile>,
-            environment: KotlinCoreEnvironment,
-            unitTestDescriptions: ArrayList<TestInfo>
-        ) {
+        private fun writeFiles(filesToCompile: List<KtFile>, environment: KotlinCoreEnvironment) {
             if (filesToCompile.isEmpty()) return
 
-            val flavorName = flavorConfig.getFlavorForNewFiles(filesToCompile.size)
+            //2500 files per folder that would be used by flavor to avoid multidex usage,
+            // each folder would be jared by build.gradle script
+            writtenFilesCount += filesToCompile.size
+            val index = writtenFilesCount / 2500
+            val outputDir = File(pathManager.getOutputForCompiledFiles(index))
+            assertTrue("Add flavors for ktest$index", index < 3)
 
-            val outputDir = File(pathManager.getOutputForCompiledFiles(flavorName))
             println("Generating ${filesToCompile.size} files into ${outputDir.name}, configuration: '${environment.configuration}'...")
 
             val outputFiles = GenerationUtils.compileFiles(filesToCompile, environment).run { destroy(); factory }
@@ -213,10 +183,10 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 outputDir.mkdirs()
             }
             Assert.assertTrue("Cannot create directory for compiled files", outputDir.exists())
-            val unitTestFileWriter = pendingUnitTestGenerators.getOrPut(flavorName) {
+            val unitTestFileWriter = pendingUnitTestGenerators.getOrPut(index) {
                 UnitTestFileWriter(
-                    getFlavorUnitTestFolder(flavorName),
-                    flavorName,
+                    getFlavorUnitTestFilePath(index),
+                    index,
                     generatedTestNames
                 )
             }
@@ -224,12 +194,6 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             outputFiles.writeAllTo(outputDir)
         }
 
-        private fun getFlavorUnitTestFolder(flavourName: String): String {
-            return pathManager.srcFolderInAndroidTmpFolder +
-                    "/androidTest${flavourName.capitalize()}/java/" +
-                    testClassPackage.replace(".", "/") + "/"
-        }
-
         fun addTest(testFiles: List<TestClassInfo>, info: TestInfo) {
             rawFiles.addAll(testFiles)
             unitTestDescriptions.add(info)
@@ -246,6 +210,9 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
 
         for (file in files) {
+            if (SpecialFiles.getExcludedFiles().contains(file.name)) {
+                continue
+            }
             if (file.isDirectory) {
                 val listFiles = file.listFiles()
                 if (listFiles != null) {
@@ -258,9 +225,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     continue
                 }
 
-                if (!InTextDirectivesUtils.isPassingTarget(TargetBackend.JVM, file) ||
-                    InTextDirectivesUtils.isIgnoredTarget(TargetBackend.ANDROID, file)
-                ) {
+                if (!InTextDirectivesUtils.isPassingTarget(TargetBackend.JVM, file)) {
                     continue
                 }
 
@@ -276,32 +241,23 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 if (fullFileText.contains("@file:JvmPackageName(")) continue
                 // TODO: Support jvm assertions
                 if (fullFileText.contains("// KOTLIN_CONFIGURATION_FLAGS: ASSERTIONS_MODE=jvm")) continue
-                val targets = InTextDirectivesUtils.findLinesWithPrefixesRemoved(fullFileText, "// JVM_TARGET:")
-                    .also { it.remove(JvmTarget.JVM_1_6.description) }
-
-                val isJvm8Target =
-                    if (targets.isEmpty()) false
-                    else if (targets.contains(JvmTarget.JVM_1_8.description) && targets.size == 1) true
-                    else continue //TODO: support other targets on Android
-
+                // TODO: support JVM 8 test with D8
+                if (fullFileText.contains("// JVM_TARGET")) continue
                 // TODO: support SKIP_JDK6 on new platforms
                 if (fullFileText.contains("// SKIP_JDK6")) continue
 
                 if (hasBoxMethod(fullFileText)) {
                     val testFiles = createTestFiles(file, fullFileText)
-                    val kind = KotlinBaseTest.extractConfigurationKind(testFiles)
-                    val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles)
+                    val kind = extractConfigurationKind(testFiles)
+                    val jdkKind = getTestJdkKind(testFiles)
                     val keyConfiguration = CompilerConfiguration()
-                    CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+                    updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
 
                     val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString())
-                    val compiler = if (isJvm8Target) {
-                        if (kind.withReflection) JVM8REFLECT else JVM8
-                    } else if (kind.withReflection) REFLECT else COMMON
                     val filesHolder = holders.getOrPut(key) {
-                        FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
+                        FilesWriter(KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
                             println("Creating new configuration by $key")
-                            CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, this)
+                            updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
                     }
 
@@ -311,8 +267,17 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
     }
 
-    private fun createTestFiles(file: File, expectedText: String): List<KotlinBaseTest.TestFile> =
-        CodegenTestCase.createTestFilesFromFile(file, expectedText, "kotlin.coroutines", false, TargetBackend.JVM)
+    private fun createTestFiles(file: File, expectedText: String): List<TestFile> =
+        TestFiles.createTestFiles(
+            file.name,
+            expectedText,
+            object : TestFiles.TestFileFactoryNoModules<TestFile>() {
+                override fun create(fileName: String, text: String, directives: Directives): TestFile {
+                    return TestFile(fileName, text, directives)
+                }
+            }, false,
+            "kotlin.coroutines"
+        )
 
     companion object {
         const val GRADLE_VERSION = "5.6.4"
@@ -349,7 +314,6 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             val rootFolder = File("")
             val pathManager = PathManager(rootFolder.absolutePath, tmpFolder.absolutePath)
             generate(pathManager, true)
-            println("Android test project is generated into " + tmpFolder.absolutePath + " folder")
         }
     }
 }

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/SpecialFiles.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.android.tests;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class SpecialFiles {
+    private static final Set<String> excludedFiles = new HashSet<>();
+
+    static {
+        fillExcludedFiles();
+    }
+
+    public static Set<String> getExcludedFiles() {
+        return excludedFiles;
+    }
+
+    private static void fillExcludedFiles() {
+        // Reflection
+        excludedFiles.add("enclosing");
+        excludedFiles.add("kt10259.kt");
+        excludedFiles.add("simpleClassLiteral.kt");
+
+        //UnsatisfiedLinkError
+        excludedFiles.add("nativePropertyAccessors.kt");
+        excludedFiles.add("topLevel.kt");
+
+        //Test with no reflection at runtime
+        excludedFiles.add("noReflectAtRuntime");
+        excludedFiles.add("noReflect");
+        excludedFiles.add("functionNtoStringNoReflect.kt");
+        excludedFiles.add("getDelegateWithoutReflection.kt");
+        excludedFiles.add("toStringNoReflect.kt");
+
+        // "IOOBE: Invalid index 4, size is 4" for java.lang.reflect.ParameterizedType on Android
+        excludedFiles.add("innerGenericTypeArgument.kt");
+
+        // Cannot change package name
+        excludedFiles.add("kt6990.kt");
+        excludedFiles.add("typeParameters.kt");
+        excludedFiles.add("kt13133.kt");
+
+        // StackOverflow with StringBuilder (escape())
+        excludedFiles.add("kt684.kt");
+
+        // Wrong enclosing info or signature after package renaming
+        excludedFiles.add("enclosingInfo");
+        excludedFiles.add("signature");
+
+        // Some classes are not visible on android
+        excludedFiles.add("classpath.kt");
+
+        // Out of memory
+        excludedFiles.add("manyNumbers.kt");
+
+        // Native methods
+        excludedFiles.add("external");
+
+        // Additional nested class in 'Thread' class on Android
+        excludedFiles.add("nestedClasses.kt");
+
+        // KT-8120
+        excludedFiles.add("closureOfInnerLocalClass.kt");
+        excludedFiles.add("closureWithSelfInstantiation.kt");
+        excludedFiles.add("quotedClassName.kt");
+
+        //wrong function resolution after package renaming
+        excludedFiles.add("apiVersionAtLeast1.kt");
+
+        //special symbols in names
+        excludedFiles.add("nameWithWhitespace.kt");
+
+        //some classes are moved from stdlib to compatibility package
+        excludedFiles.add("suspendFunction_1_2.kt");
+    }
+
+    private SpecialFiles() {
+    }
+}

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/UnitTestFileWriter.kt

@@ -15,11 +15,7 @@ import java.io.FileWriter
 
 class TestInfo(val name: String, val fqName: FqName, val file: File)
 
-class UnitTestFileWriter(
-    private val flavourFolder: String,
-    private val flavourName: String,
-    private val generatedTestNames: MutableSet<String>
-) {
+class UnitTestFileWriter(private val fileName: String, private val index: Int, private val generatedTestNames: MutableSet<String>) {
     private val infos = arrayListOf<TestInfo>()
 
     fun addTests(info: List<TestInfo>) {
@@ -27,7 +23,7 @@ class UnitTestFileWriter(
     }
 
     fun generate() {
-        FileWriter(File(flavourFolder, flavourName.capitalize() + ".java").also { it.parentFile.mkdirs() }).use { suite ->
+        FileWriter(File(fileName).also { it.parentFile.mkdirs() }).use { suite ->
             val p = Printer(suite)
             p.println(
                 """package ${CodegenTestsOnAndroidGenerator.testClassPackage};
@@ -35,7 +31,7 @@ class UnitTestFileWriter(
                 |import ${CodegenTestsOnAndroidGenerator.baseTestClassPackage}.${CodegenTestsOnAndroidGenerator.baseTestClassName};
                 |
                 |/* This class is generated by ${CodegenTestsOnAndroidGenerator.generatorName}. DO NOT MODIFY MANUALLY */
-                |public class ${flavourName.capitalize()} extends ${CodegenTestsOnAndroidGenerator.baseTestClassName} {
+                |public class ${CodegenTestsOnAndroidGenerator.testClassName}$index extends ${CodegenTestsOnAndroidGenerator.baseTestClassName} {
                 |
             """.trimMargin()
             )

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt

@@ -125,11 +125,16 @@ fun findImplementationFromInterface(descriptor: CallableMemberDescriptor): Calla
  * The returned function should be called from TImpl-bridges generated for the given fake override.
  */
 fun firstSuperMethodFromKotlin(
-        descriptor: CallableMemberDescriptor,
-        implementation: CallableMemberDescriptor
+    descriptor: CallableMemberDescriptor,
+    implementation: CallableMemberDescriptor
 ): CallableMemberDescriptor? {
     return descriptor.overriddenDescriptors.firstOrNull { overridden ->
         overridden.modality != Modality.ABSTRACT &&
-        (overridden == implementation || OverridingUtil.overrides(overridden, implementation, overridden.module.isTypeRefinementEnabled()))
+                (overridden == implementation || OverridingUtil.overrides(
+                    overridden,
+                    implementation,
+                    overridden.module.isTypeRefinementEnabled(),
+                    true
+                ))
     }
 }

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

@@ -1759,7 +1759,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         if (!endsWithReturn(expr)) {
             if (isLambdaVoidBody(expr, typeForExpression)) {
                 markLineNumber((KtFunctionLiteral) expr.getParent(), true);
-            } else if (!isLambdaBody(expr)){
+            }
+            else {
                 markLineNumber(expr, true);
             }
 
@@ -1781,14 +1782,13 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     }
 
     private static boolean isLambdaVoidBody(@NotNull KtElement bodyExpression, @NotNull Type returnType) {
-        return isLambdaBody(bodyExpression) && Type.VOID_TYPE.equals(returnType);
-    }
-
-    private static boolean isLambdaBody(@NotNull KtElement bodyExpression) {
         if (bodyExpression instanceof KtBlockExpression) {
             PsiElement parent = bodyExpression.getParent();
-            return parent instanceof KtFunctionLiteral;
+            if (parent instanceof KtFunctionLiteral) {
+                return Type.VOID_TYPE.equals(returnType);
+            }
         }
+
         return false;
     }
 
@@ -2646,7 +2646,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         KotlinType returnType = resolvedCall.getResultingDescriptor().getReturnType();
         if (returnType != null && KotlinBuiltIns.isNothing(returnType)) {
-            if (state.getUseKotlinNothingValueException()) {
+            if (state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_4) >= 0) {
                 v.anew(Type.getObjectType("kotlin/KotlinNothingValueException"));
                 v.dup();
                 v.invokespecial("kotlin/KotlinNothingValueException", "<init>", "()V", false);

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

@@ -401,6 +401,14 @@ public class PropertyCodegen {
         }
         modifiers |= getVisibilityForBackingField(propertyDescriptor, isDelegate);
 
+        // If val is initialized in EXACTLY_ONCE closure, other class from the same package initializes it
+        // so, its visibility should be package private and not final
+        if (!propertyDescriptor.isVar() &&
+            bindingContext.get(BindingContext.FIELD_CAPTURED_IN_EXACLY_ONCE_CLOSURE, propertyDescriptor) != null
+        ) {
+            modifiers &= ~(ACC_PRIVATE | ACC_FINAL);
+        }
+
         if (AsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) {
             ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
             parentBodyCodegen.addCompanionObjectPropertyToCopy(propertyDescriptor, defaultValue);

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

@@ -219,9 +219,6 @@ class GenerationState private constructor(
     val generateOptimizedCallableReferenceSuperClasses =
         languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 &&
                 !configuration.getBoolean(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES)
-    val useKotlinNothingValueException =
-        languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 &&
-                !configuration.getBoolean(JVMConfigurationKeys.NO_KOTLIN_NOTHING_VALUE_EXCEPTION)
     val samWrapperClasses: SamWrapperClasses = SamWrapperClasses(this)
     val globalInlineContext: GlobalInlineContext = GlobalInlineContext(diagnostics)
     val mappingsClassesForWhenByEnum: MappingsClassesForWhenByEnum = MappingsClassesForWhenByEnum(this)

compiler/cli/bin/kotlinc.bat

@@ -27,27 +27,9 @@ if "%_JAVACMD%"=="" set _JAVACMD=java
 rem We use the value of the JAVA_OPTS environment variable if defined
 if "%JAVA_OPTS%"=="" set JAVA_OPTS=-Xmx256M -Xms32M
 
-rem Iterate through arguments and split them into java and kotlin ones
-:loop
-set _arg=%~1
-if "%_arg%" == "" goto loopend
-
-if "%_arg:~0,2%"=="-J" (
-  set JAVA_OPTS=%JAVA_OPTS% "%_arg:~2%"
-) else (
-  if "%_arg:~0,2%"=="-D" (
-    set JAVA_OPTS=%JAVA_OPTS% "%_arg%"
-  ) else (
-    set KOTLIN_OPTS=%KOTLIN_OPTS% "%_arg%"
-  )
-)
-shift
-goto loop
-:loopend
-
-if "%_KOTLIN_RUNNER%"=="1" (
+if not "%_KOTLIN_RUNNER%"=="" (
   "%_JAVACMD%" %JAVA_OPTS% "-Dkotlin.home=%_KOTLIN_HOME%" -cp "%_KOTLIN_HOME%\lib\kotlin-runner.jar" ^
-    org.jetbrains.kotlin.runner.Main %KOTLIN_OPTS%
+    org.jetbrains.kotlin.runner.Main %*
 ) else (
   SET _ADDITIONAL_CLASSPATH=
 
@@ -57,7 +39,7 @@ if "%_KOTLIN_RUNNER%"=="1" (
 
   "%_JAVACMD%" %JAVA_OPTS% -noverify -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^
     org.jetbrains.kotlin.preloading.Preloader -cp "%_KOTLIN_HOME%\lib\kotlin-compiler.jar%_ADDITIONAL_CLASSPATH%" ^
-    %_KOTLIN_COMPILER% %KOTLIN_OPTS%
+    %_KOTLIN_COMPILER% %*
 )
 
 exit /b %ERRORLEVEL%

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

@@ -128,6 +128,13 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-Xir-only", description = "Disables pre-IR backend")
     var irOnly: Boolean by FreezableVar(false)
 
+    @Argument(
+        value = "-Xir-module-name",
+        valueDescription = "<name>",
+        description = "Specify a compilation module name for IR backend"
+    )
+    var irModuleName: String? by NullableStringFreezableVar(null)
+
     @Argument(
         value = "-Xinclude",
         valueDescription = "<path>",

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

@@ -289,7 +289,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
                                  Note that if interface delegation is used, all interface methods are delegated.
                                  The only exception are methods annotated with the deprecated @JvmDefault annotation.
 -Xjvm-default=disable            Do not generate JVM default methods and prohibit @JvmDefault annotation usage.
- The following modes are DEPRECATED:
 -Xjvm-default=enable             Allow usages of @JvmDefault; only generate the default method
                                  for annotated method in the interface
                                  (annotating an existing method can break binary compatibility)
@@ -347,12 +346,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var noOptimizedCallableReferences: Boolean by FreezableVar(false)
 
-    @Argument(
-        value = "-Xno-kotlin-nothing-value-exception",
-        description = "Do not use KotlinNothingValueException available since 1.4"
-    )
-    var noKotlinNothingValueException: Boolean by FreezableVar(false)
-
     override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics
@@ -363,12 +356,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
         result[AnalysisFlags.ignoreDataFlowInAssert] = JVMAssertionsMode.fromString(assertionsMode) != JVMAssertionsMode.LEGACY
         JvmDefaultMode.fromStringOrNull(jvmDefault)?.let {
             result[JvmAnalysisFlags.jvmDefaultMode] = it
-            if (it == JvmDefaultMode.ENABLE || it == JvmDefaultMode.ENABLE_WITH_DEFAULT_IMPLS) {
-                collector.report(
-                    CompilerMessageSeverity.WARNING,
-                    "'-Xjvm-default=$jvmDefault' mode is deprecated. Please considering to switch to new modes: 'all' and 'all-compatibility'"
-                )
-            }
         } ?: collector.report(
             CompilerMessageSeverity.ERROR,
             "Unknown @JvmDefault mode: $jvmDefault, " +

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/CompilerMessageLocation.kt

@@ -19,12 +19,10 @@ package org.jetbrains.kotlin.cli.common.messages
 import java.io.Serializable
 
 data class CompilerMessageLocation private constructor(
-    val path: String,
-    val line: Int,
-    val column: Int,
-    val lineEnd: Int,
-    val columnEnd: Int,
-    val lineContent: String?
+        val path: String,
+        val line: Int,
+        val column: Int,
+        val lineContent: String?
 ) : Serializable {
     override fun toString(): String =
             path + (if (line != -1 || column != -1) " ($line:$column)" else "")
@@ -32,23 +30,12 @@ data class CompilerMessageLocation private constructor(
     companion object {
         @JvmStatic
         fun create(path: String?): CompilerMessageLocation? =
-            create(path, -1, -1, null)
+                create(path, -1, -1, null)
 
         @JvmStatic
         fun create(path: String?, line: Int, column: Int, lineContent: String?): CompilerMessageLocation? =
-            if (path == null) null else CompilerMessageLocation(path, line, column, -1, -1, lineContent)
+                if (path == null) null else CompilerMessageLocation(path, line, column, lineContent)
 
-        @JvmStatic
-        fun create(
-            path: String?,
-            lineStart: Int,
-            columnStart: Int,
-            lineEnd: Int?,
-            columnEnd: Int?,
-            lineContent: String?
-        ): CompilerMessageLocation? =
-            if (path == null) null else CompilerMessageLocation(path, lineStart, columnStart, lineEnd ?: -1, columnEnd ?: -1, lineContent)
-
-        private val serialVersionUID: Long = 8228357579L
+        private val serialVersionUID: Long = 8228357578L
     }
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/BasicReplState.kt

@@ -24,13 +24,16 @@ import kotlin.concurrent.write
 
 data class LineId(override val no: Int, override val generation: Int, private val codeHash: Int) : ILineId, Serializable {
 
-    override fun compareTo(other: ILineId): Int = (other as? LineId)?.let { lineId ->
-        no.compareTo(lineId.no).takeIf { no -> no != 0 }
-            ?: codeHash.compareTo(lineId.codeHash)
+    constructor(codeLine: ReplCodeLine): this(codeLine.no, codeLine.generation, codeLine.code.hashCode())
+
+    override fun compareTo(other: ILineId): Int = (other as? LineId)?.let {
+        no.compareTo(it.no).takeIf { it != 0 }
+        ?: generation.compareTo(it.generation).takeIf { it != 0 }
+        ?: codeHash.compareTo(it.codeHash)
     } ?: -1 // TODO: check if it doesn't break something
 
     companion object {
-        private const val serialVersionUID: Long = 8328354000L
+        private val serialVersionUID: Long = 8328353000L
     }
 }
 

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/GenericReplCompilingEvaluator.kt

@@ -21,7 +21,7 @@ import java.util.concurrent.locks.ReentrantReadWriteLock
 import kotlin.concurrent.write
 
 open class GenericReplCompilingEvaluatorBase(
-    val compiler: ReplCompilerWithoutCheck,
+    val compiler: ReplCompiler,
     val evaluator: ReplEvaluator,
     private val fallbackScriptArgs: ScriptArgsWithTypes? = null
 ) : ReplFullEvaluator {
@@ -46,7 +46,7 @@ open class GenericReplCompilingEvaluatorBase(
                     }
                     ReplEvalResult.Error.CompileTime(compiled.message, compiled.location)
                 }
-                is ReplCompileResult.Incomplete -> ReplEvalResult.Incomplete(compiled.message)
+                is ReplCompileResult.Incomplete -> ReplEvalResult.Incomplete()
                 is ReplCompileResult.CompiledClasses -> {
                     val result = eval(state, compiled, scriptArgs, invokeWrapper)
                     when (result) {
@@ -75,6 +75,8 @@ open class GenericReplCompilingEvaluatorBase(
     override fun eval(state: IReplStageState<*>, compileResult: ReplCompileResult.CompiledClasses, scriptArgs: ScriptArgsWithTypes?, invokeWrapper: InvokeWrapper?): ReplEvalResult =
         evaluator.eval(state, compileResult, scriptArgs, invokeWrapper)
 
+    override fun check(state: IReplStageState<*>, codeLine: ReplCodeLine): ReplCheckResult = compiler.check(state, codeLine)
+
     override fun compileToEvaluable(state: IReplStageState<*>, codeLine: ReplCodeLine, defaultScriptArgs: ScriptArgsWithTypes?): Pair<ReplCompileResult, Evaluable?> {
         val compiled = compiler.compile(state, codeLine)
         return when (compiled) {
@@ -94,7 +96,7 @@ open class GenericReplCompilingEvaluatorBase(
 }
 
 class GenericReplCompilingEvaluator(
-    compiler: ReplCompilerWithoutCheck,
+    compiler: ReplCompiler,
     baseClasspath: Iterable<File>,
     baseClassloader: ClassLoader? = Thread.currentThread().contextClassLoader,
     fallbackScriptArgs: ScriptArgsWithTypes? = null,

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/KotlinJsr223JvmScriptEngineBase.kt

@@ -25,7 +25,7 @@ const val KOTLIN_SCRIPT_ENGINE_BINDINGS_KEY = "kotlin.script.engine"
 
 abstract class KotlinJsr223JvmScriptEngineBase(protected val myFactory: ScriptEngineFactory) : AbstractScriptEngine(), ScriptEngine, Compilable {
 
-    protected abstract val replCompiler: ReplCompilerWithoutCheck
+    protected abstract val replCompiler: ReplCompiler
     protected abstract val replEvaluator: ReplFullEvaluator
 
     override fun eval(script: String, context: ScriptContext): Any? = compileAndEval(script, context)
@@ -72,7 +72,7 @@ abstract class KotlinJsr223JvmScriptEngineBase(protected val myFactory: ScriptEn
         val result = replCompiler.compile(state, codeLine)
         val compiled = when (result) {
             is ReplCompileResult.Error -> throw ScriptException("Error${result.locationString()}: ${result.message}")
-            is ReplCompileResult.Incomplete -> throw ScriptException("Error: incomplete code; ${result.message}")
+            is ReplCompileResult.Incomplete -> throw ScriptException("error: incomplete code")
             is ReplCompileResult.CompiledClasses -> result
         }
         return CompiledKotlinScript(this, codeLine, compiled)
@@ -103,7 +103,7 @@ abstract class KotlinJsr223JvmScriptEngineBase(protected val myFactory: ScriptEn
                         throw ScriptException(result.message, result.location.path, result.location.line, result.location.column)
                     else -> throw ScriptException(result.message)
                 }
-            is ReplEvalResult.Incomplete -> throw ScriptException("Error: incomplete code. ${result.message}")
+            is ReplEvalResult.Incomplete -> throw ScriptException("error: incomplete code")
             is ReplEvalResult.HistoryMismatch -> throw ScriptException("Repl history mismatch at line: ${result.lineNo}")
         }
     }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/ReplApi.kt

@@ -96,7 +96,7 @@ sealed class ReplCompileResult : Serializable {
         companion object { private val serialVersionUID: Long = 2L }
     }
 
-    class Incomplete(val message: String) : ReplCompileResult() {
+    class Incomplete : ReplCompileResult() {
         companion object { private val serialVersionUID: Long = 1L }
     }
 
@@ -110,9 +110,7 @@ sealed class ReplCompileResult : Serializable {
     }
 }
 
-interface ReplCompilerWithoutCheck : ReplCompileAction, CreateReplStageStateAction
-
-interface ReplCompiler : ReplCompilerWithoutCheck, ReplCheckAction
+interface ReplCompiler : ReplCompileAction, ReplCheckAction, CreateReplStageStateAction
 
 // --- eval
 
@@ -139,7 +137,7 @@ sealed class ReplEvalResult : Serializable {
         companion object { private val serialVersionUID: Long = 1L }
     }
 
-    class Incomplete(val message: String) : ReplEvalResult() {
+    class Incomplete : ReplEvalResult() {
         companion object { private val serialVersionUID: Long = 1L }
     }
 
@@ -177,7 +175,7 @@ interface ReplAtomicEvalAction {
                        invokeWrapper: InvokeWrapper? = null): ReplEvalResult
 }
 
-interface ReplAtomicEvaluator : ReplAtomicEvalAction
+interface ReplAtomicEvaluator : ReplAtomicEvalAction, ReplCheckAction
 
 interface ReplDelayedEvalAction {
     fun compileToEvaluable(state: IReplStageState<*>,

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

@@ -149,7 +149,10 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
         val outputFile = File(outputFilePath)
 
-        configurationJs.put(CommonConfigurationKeys.MODULE_NAME, FileUtil.getNameWithoutExtension(outputFile))
+        configurationJs.put(
+            CommonConfigurationKeys.MODULE_NAME,
+            arguments.irModuleName ?: FileUtil.getNameWithoutExtension(outputFile)
+        )
 
         // TODO: in this method at least 3 different compiler configurations are used (original, env.configuration, jsConfig.configuration)
         // Such situation seems a bit buggy...

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/DefaultDiagnosticReporter.kt

@@ -31,6 +31,6 @@ interface MessageCollectorBasedReporter : DiagnosticMessageReporter {
     override fun report(diagnostic: Diagnostic, file: PsiFile, render: String) = messageCollector.report(
         AnalyzerWithCompilerReport.convertSeverity(diagnostic.severity),
         render,
-        MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumnRange(diagnostic))
+        MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumn(diagnostic))
     )
 }

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

@@ -35,20 +35,18 @@ public class MessageUtil {
     public static CompilerMessageLocation psiElementToMessageLocation(@Nullable PsiElement element) {
         if (element == null) return null;
         PsiFile file = element.getContainingFile();
-        return psiFileToMessageLocation(file, "<no path>", DiagnosticUtils.getLineAndColumnRangeInPsiFile(file, element.getTextRange()));
+        return psiFileToMessageLocation(file, "<no path>", DiagnosticUtils.getLineAndColumnInPsiFile(file, element.getTextRange()));
     }
 
     @Nullable
     public static CompilerMessageLocation psiFileToMessageLocation(
             @NotNull PsiFile file,
             @Nullable String defaultValue,
-            @NotNull PsiDiagnosticUtils.LineAndColumnRange range
+            @NotNull PsiDiagnosticUtils.LineAndColumn lineAndColumn
     ) {
         VirtualFile virtualFile = file.getVirtualFile();
         String path = virtualFile != null ? virtualFileToPath(virtualFile) : defaultValue;
-        PsiDiagnosticUtils.LineAndColumn start = range.getStart();
-        PsiDiagnosticUtils.LineAndColumn end = range.getEnd();
-        return CompilerMessageLocation.create(path, start.getLine(), start.getColumn(), end.getLine(), end.getColumn(), start.getLineContent());
+        return CompilerMessageLocation.create(path, lineAndColumn.getLine(), lineAndColumn.getColumn(), lineAndColumn.getLineContent());
     }
 
     @NotNull

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

@@ -154,7 +154,6 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
     put(JVMConfigurationKeys.DISABLE_OPTIMIZATION, arguments.noOptimize)
     put(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS, arguments.emitJvmTypeAnnotations)
     put(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES, arguments.noOptimizedCallableReferences)
-    put(JVMConfigurationKeys.NO_KOTLIN_NOTHING_VALUE_EXCEPTION, arguments.noKotlinNothingValueException)
 
     if (!JVMConstructorCallNormalizationMode.isSupportedValue(arguments.constructorCallNormalizationMode)) {
         getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(

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

@@ -123,9 +123,9 @@ private class KlibMetadataDependencyContainer(
     private class KlibModuleInfo(
         override val name: Name,
         val kotlinLibrary: KotlinLibrary,
-        private val dependOnKlibModules: List<ModuleInfo>
+        private val dependOnModules: List<ModuleInfo>
     ) : ModuleInfo {
-        override fun dependencies(): List<ModuleInfo> = dependOnKlibModules
+        override fun dependencies(): List<ModuleInfo> = dependOnModules
 
         override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns = ModuleInfo.DependencyOnBuiltIns.LAST
 
@@ -136,6 +136,12 @@ private class KlibMetadataDependencyContainer(
             get() = CommonPlatformAnalyzerServices
     }
 
+    private val mutableDependenciesForAllModuleDescriptors = mutableListOf<ModuleDescriptorImpl>().apply {
+        add(builtIns.builtInsModule)
+    }
+
+    private val mutableDependenciesForAllModules = mutableListOf<ModuleInfo>()
+
     private val moduleDescriptorsForKotlinLibraries: Map<KotlinLibrary, ModuleDescriptorImpl> =
         kotlinLibraries.keysToMap { library ->
             val moduleHeader = parseModuleHeader(library.moduleHeaderData)
@@ -145,19 +151,20 @@ private class KlibMetadataDependencyContainer(
                 moduleName, storageManager, builtIns, moduleOrigin
             )
         }.also { result ->
-            val resultValues = result.values.toList()
-            val dependenciesForModuleDescriptors = resultValues + builtIns.builtInsModule
+            val resultValues = result.values
             resultValues.forEach { module ->
-                module.setDependencies(dependenciesForModuleDescriptors)
+                module.setDependencies(mutableDependenciesForAllModuleDescriptors)
             }
+            mutableDependenciesForAllModuleDescriptors.addAll(resultValues)
         }
 
     private val moduleInfosImpl: List<KlibModuleInfo> = mutableListOf<KlibModuleInfo>().apply {
         addAll(
             moduleDescriptorsForKotlinLibraries.map { (kotlinLibrary, moduleDescriptor) ->
-                KlibModuleInfo(moduleDescriptor.name, kotlinLibrary, this@apply)
+                KlibModuleInfo(moduleDescriptor.name, kotlinLibrary, mutableDependenciesForAllModules)
             }
         )
+        mutableDependenciesForAllModules.addAll(this@apply)
     }
 
     override val moduleInfos: List<ModuleInfo> get() = moduleInfosImpl
@@ -182,6 +189,14 @@ private class KlibMetadataDependencyContainer(
         return moduleDescriptorsForKotlinLibraries.getValue(moduleInfo.kotlinLibrary)
     }
 
+    override fun registerDependencyForAllModules(
+        moduleInfo: ModuleInfo,
+        descriptorForModule: ModuleDescriptorImpl
+    ) {
+        mutableDependenciesForAllModules.add(moduleInfo)
+        mutableDependenciesForAllModuleDescriptors.add(descriptorForModule)
+    }
+
     override fun packageFragmentProviderForModuleInfo(
         moduleInfo: ModuleInfo
     ): PackageFragmentProvider? {

compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java

@@ -119,7 +119,4 @@ public class JVMConfigurationKeys {
 
     public static final CompilerConfigurationKey<Boolean> NO_OPTIMIZED_CALLABLE_REFERENCES =
             CompilerConfigurationKey.create("Do not use optimized callable reference superclasses available from 1.4");
-
-    public static final CompilerConfigurationKey<Boolean> NO_KOTLIN_NOTHING_VALUE_EXCEPTION =
-            CompilerConfigurationKey.create("Do not use KotlinNothingValueException available since 1.4");
 }

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

@@ -8,12 +8,15 @@ package org.jetbrains.kotlin.daemon.client.experimental
 import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.repl.*
+import org.jetbrains.kotlin.daemon.client.KotlinRemoteReplCompilerClient
 import org.jetbrains.kotlin.daemon.common.*
+import org.jetbrains.kotlin.daemon.common.CompileServiceClientSide
 import org.jetbrains.kotlin.daemon.common.experimental.findCallbackServerSocket
 import org.jetbrains.kotlin.daemon.common.ReportCategory
 import org.jetbrains.kotlin.daemon.common.ReportSeverity
 import java.io.File
 import java.util.concurrent.locks.ReentrantReadWriteLock
+import org.jetbrains.kotlin.daemon.client.RemoteReplCompilerState
 
 // TODO: reduce number of ports used then SOCKET_ANY_FREE_PORT is passed (same problem with other calls)
 

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

@@ -388,28 +388,29 @@ object KotlinCompilerClient {
         isEchoRead.acquire()
 
         val stdoutThread =
-                thread {
-                    try {
-                        daemon.inputStream
-                                .reader()
-                                .forEachLine {
-                                    if (it == COMPILE_DAEMON_IS_READY_MESSAGE) {
-                                        reportingTargets.report(DaemonReportCategory.DEBUG, "Received the message signalling that the daemon is ready")
-                                        isEchoRead.release()
-                                        return@forEachLine
-                                    }
-                                    else {
-                                        reportingTargets.report(DaemonReportCategory.INFO, it, "daemon")
-                                    }
-                                }
-                    }
-                    finally {
-                        daemon.inputStream.close()
-                        daemon.outputStream.close()
-                        daemon.errorStream.close()
-                        isEchoRead.release()
-                    }
+            thread {
+                try {
+                    daemon.inputStream
+                        .reader()
+                        .forEachLine {
+                            if (Thread.currentThread().isInterrupted) return@forEachLine
+                            if (it == COMPILE_DAEMON_IS_READY_MESSAGE) {
+                                reportingTargets.report(DaemonReportCategory.DEBUG, "Received the message signalling that the daemon is ready")
+                                isEchoRead.release()
+                                return@forEachLine
+                            } else {
+                                reportingTargets.report(DaemonReportCategory.INFO, it, "daemon")
+                            }
+                        }
+                } catch (_: Throwable) {
+                    // Ignore, assuming all exceptions as interrupt exceptions
+                } finally {
+                    daemon.inputStream.close()
+                    daemon.outputStream.close()
+                    daemon.errorStream.close()
+                    isEchoRead.release()
                 }
+            }
         try {
             // trying to wait for process
             val daemonStartupTimeout = System.getProperty(COMPILE_DAEMON_STARTUP_TIMEOUT_PROPERTY)?.let {
@@ -444,7 +445,7 @@ object KotlinCompilerClient {
             // assuming that all important output is already done, the rest should be routed to the log by the daemon itself
             if (stdoutThread.isAlive) {
                 // TODO: find better method to stop the thread, but seems it will require asynchronous consuming of the stream
-                stdoutThread.stop()
+                stdoutThread.interrupt()
             }
             reportingTargets.out?.flush()
         }

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

@@ -27,8 +27,8 @@ public final class Generic<T> : R|kotlin/Any| {
 public final class InnerGeneric<A, B> : R|kotlin/Any| {
     public constructor<A, B>(): R|test/InnerGeneric<A, B>|
 
-    public final inner class Inner<in C, D : R|A|, A, B> : R|kotlin/Any| {
-        public constructor<in C, D : R|A|>(): R|test/InnerGeneric.Inner<C, D, A, B>|
+    public final inner class Inner<in C, D : R|A|> : R|kotlin/Any| {
+        public constructor<in C, D : R|A|>(): R|test/InnerGeneric.Inner<C, D>|
 
     }
 
@@ -38,4 +38,3 @@ public final class Simple : R|kotlin/Any| {
     public constructor(): R|test/Simple|
 
 }
-

compiler/fir/analysis-tests/testData/loadCompiledKotlin/class/InnerTypes.txt

@@ -3,22 +3,21 @@ public final class Outer<E, F> : R|kotlin/Any| {
 
     public constructor<E, F>(): R|test/Outer<E, F>|
 
-    public final inner class Inner<G, H, E, F> : R|kotlin/Any| {
-        public constructor<G, H>(): R|test/Outer.Inner<G, H, E, F>|
+    public final inner class Inner<G, H> : R|kotlin/Any| {
+        public constructor<G, H>(): R|test/Outer.Inner<G, H>|
 
-        public final inner class Inner3<I, G, H, E, F> : R|kotlin/Any| {
+        public final inner class Inner3<I> : R|kotlin/Any| {
             public final fun foo(x: R|test/Outer.Inner<G, kotlin/Int, kotlin/String, F>|, y: R|test/Outer.Inner<E, kotlin/Double, E, F>|, z: R|test/Outer.Inner.Inner3<kotlin/Double, G, kotlin/Int, kotlin/String, F>|, w: R|test/Outer.Inner.Inner3<*, G, H, E, F>|): R|kotlin/Unit|
 
-            public constructor<I>(): R|test/Outer.Inner.Inner3<I, G, H, E, F>|
+            public constructor<I>(): R|test/Outer.Inner.Inner3<I>|
 
         }
 
     }
 
-    public final inner class Inner2<E, F> : R|kotlin/Any| {
-        public constructor(): R|test/Outer.Inner2<E, F>|
+    public final inner class Inner2 : R|kotlin/Any| {
+        public constructor(): R|test/Outer.Inner2|
 
     }
 
 }
-

compiler/fir/analysis-tests/testData/loadCompiledKotlin/nested/DeepInnerGeneric.txt

@@ -1,18 +1,18 @@
 public final class A<TA> : R|kotlin/Any| {
     public constructor<TA>(): R|test/A<TA>|
 
-    public final inner class B<TB, TA> : R|kotlin/Any| {
-        public constructor<TB>(): R|test/A.B<TB, TA>|
+    public final inner class B<TB> : R|kotlin/Any| {
+        public constructor<TB>(): R|test/A.B<TB>|
 
-        public final inner class C<TC, TB, TA> : R|kotlin/Any| {
-            public constructor<TC>(): R|test/A.B.C<TC, TB, TA>|
+        public final inner class C<TC> : R|kotlin/Any| {
+            public constructor<TC>(): R|test/A.B.C<TC>|
 
-            public final inner class D<TD, TC, TB, TA> : R|kotlin/Any| {
+            public final inner class D<TD> : R|kotlin/Any| {
                 public final fun bar(ta: R|TA|, tb: R|TB|, tc: R|TC|, td: R|TD|): R|test/A.B.C.D<TD, TC, TB, TA>|
 
                 public final fun <P1, P2, P3, P4> foo(p1: R|P1|, p2: R|P2|, p3: R|P3|, p4: R|P4|): R|kotlin/Nothing|
 
-                public constructor<TD>(): R|test/A.B.C.D<TD, TC, TB, TA>|
+                public constructor<TD>(): R|test/A.B.C.D<TD>|
 
             }
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/nested/InnerClassReferencesOuterTP.txt

@@ -1,10 +1,9 @@
 public final class InnerClassReferencesOuterTP<P> : R|kotlin/Any| {
     public constructor<P>(): R|test/InnerClassReferencesOuterTP<P>|
 
-    public final inner class Inner<Q : R|P|, P> : R|kotlin/Any| {
-        public constructor<Q : R|P|>(): R|test/InnerClassReferencesOuterTP.Inner<Q, P>|
+    public final inner class Inner<Q : R|P|> : R|kotlin/Any| {
+        public constructor<Q : R|P|>(): R|test/InnerClassReferencesOuterTP.Inner<Q>|
 
     }
 
 }
-

compiler/fir/analysis-tests/testData/loadCompiledKotlin/nested/MembersReferenceOuterTP.txt

@@ -1,7 +1,7 @@
 public final class MembersReferenceOuterTP<P> : R|kotlin/Any| {
     public constructor<P>(): R|test/MembersReferenceOuterTP<P>|
 
-    public final inner class Inner<P> : R|kotlin/Any| {
+    public final inner class Inner : R|kotlin/Any| {
         public final fun <Q : R|P|> f(): R|kotlin/Unit|
 
         public final fun g(p: R|P|): R|P|
@@ -12,9 +12,8 @@ public final class MembersReferenceOuterTP<P> : R|kotlin/Any| {
         public final val <Q : R|P|> R|Q|.w: R|Q|
             public get(): R|Q|
 
-        public constructor(): R|test/MembersReferenceOuterTP.Inner<P>|
+        public constructor(): R|test/MembersReferenceOuterTP.Inner|
 
     }
 
 }
-

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

@@ -19,11 +19,16 @@ FILE: constantValues.kt
         public final val arrayNestedness: R|kotlin/Int| = R|<local>/arrayNestedness|
             public get(): R|kotlin/Int|
 
-        public final fun component1(): R|ClassId|
+        public final fun component1(): R|ClassId| {
+            ^component1 this@R|/ClassLiteralValue|.R|/ClassLiteralValue.classId|
+        }
 
-        public final fun component2(): R|kotlin/Int|
+        public final fun component2(): R|kotlin/Int| {
+            ^component2 this@R|/ClassLiteralValue|.R|/ClassLiteralValue.arrayNestedness|
+        }
 
-        public final fun copy(classId: R|ClassId| = this@R|/ClassLiteralValue|.R|/ClassLiteralValue.classId|, arrayNestedness: R|kotlin/Int| = this@R|/ClassLiteralValue|.R|/ClassLiteralValue.arrayNestedness|): R|ClassLiteralValue|
+        public final fun copy(classId: R|ClassId| = this@R|/ClassLiteralValue|.R|/ClassLiteralValue.classId|, arrayNestedness: R|kotlin/Int| = this@R|/ClassLiteralValue|.R|/ClassLiteralValue.arrayNestedness|): R|ClassLiteralValue| {
+        }
 
     }
     public final class ClassId : R|kotlin/Any| {
@@ -62,9 +67,12 @@ FILE: constantValues.kt
                 public final val arrayDimensions: R|kotlin/Int|
                     public get(): R|kotlin/Int|
 
-                public final fun component1(): R|ClassLiteralValue|
+                public final fun component1(): R|ClassLiteralValue| {
+                    ^component1 this@R|/KClassValue.Value.NormalClass|.R|/KClassValue.Value.NormalClass.value|
+                }
 
-                public final fun copy(value: R|ClassLiteralValue| = this@R|/KClassValue.Value.NormalClass|.R|/KClassValue.Value.NormalClass.value|): R|KClassValue.Value.NormalClass|
+                public final fun copy(value: R|ClassLiteralValue| = this@R|/KClassValue.Value.NormalClass|.R|/KClassValue.Value.NormalClass.value|): R|KClassValue.Value.NormalClass| {
+                }
 
             }
 
@@ -76,9 +84,12 @@ FILE: constantValues.kt
                 public final val type: R|KotlinType| = R|<local>/type|
                     public get(): R|KotlinType|
 
-                public final fun component1(): R|KotlinType|
+                public final fun component1(): R|KotlinType| {
+                    ^component1 this@R|/KClassValue.Value.LocalClass|.R|/KClassValue.Value.LocalClass.type|
+                }
 
-                public final fun copy(type: R|KotlinType| = this@R|/KClassValue.Value.LocalClass|.R|/KClassValue.Value.LocalClass.type|): R|KClassValue.Value.LocalClass|
+                public final fun copy(type: R|KotlinType| = this@R|/KClassValue.Value.LocalClass|.R|/KClassValue.Value.LocalClass.type|): R|KClassValue.Value.LocalClass| {
+                }
 
             }
 

compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt

@@ -1,27 +0,0 @@
-// FILE: AJava.java
-
-public class AJava {
-    public AJava(String s) {}
-}
-
-// FILE: main.kt
-
-class BJava : AJava, C {
-    constructor(s: String) : super(s)
-}
-
-open class AKt(val s: String)
-
-class BKt : AKt, C {
-    constructor(s: String) : super(s)
-}
-
-interface C
-
-typealias QQQ = AKt
-
-typealias DDD = C
-
-class CKt : QQQ, DDD {
-    constructor(s: String) : super(s)
-}

compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.txt

@@ -1,32 +0,0 @@
-FILE: main.kt
-    public final class BJava : R|AJava|, R|C| {
-        public constructor(s: R|kotlin/String|): R|BJava| {
-            super<R|AJava|>(R|<local>/s|)
-        }
-
-    }
-    public open class AKt : R|kotlin/Any| {
-        public constructor(s: R|kotlin/String|): R|AKt| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final val s: R|kotlin/String| = R|<local>/s|
-            public get(): R|kotlin/String|
-
-    }
-    public final class BKt : R|AKt|, R|C| {
-        public constructor(s: R|kotlin/String|): R|BKt| {
-            super<R|AKt|>(R|<local>/s|)
-        }
-
-    }
-    public abstract interface C : R|kotlin/Any| {
-    }
-    public final typealias QQQ = R|AKt|
-    public final typealias DDD = R|C|
-    public final class CKt : R|QQQ|, R|DDD| {
-        public constructor(s: R|kotlin/String|): R|CKt| {
-            super<R|QQQ|>(R|<local>/s|)
-        }
-
-    }

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

@@ -10,11 +10,16 @@ FILE: copy.kt
         public final val y: R|kotlin/String| = R|<local>/y|
             public get(): R|kotlin/String|
 
-        public final fun component1(): R|kotlin/Int|
+        public final fun component1(): R|kotlin/Int| {
+            ^component1 this@R|/Some|.R|/Some.x|
+        }
 
-        public final fun component2(): R|kotlin/String|
+        public final fun component2(): R|kotlin/String| {
+            ^component2 this@R|/Some|.R|/Some.y|
+        }
 
-        public final fun copy(x: R|kotlin/Int| = this@R|/Some|.R|/Some.x|, y: R|kotlin/String| = this@R|/Some|.R|/Some.y|): R|Some|
+        public final fun copy(x: R|kotlin/Int| = this@R|/Some|.R|/Some.x|, y: R|kotlin/String| = this@R|/Some|.R|/Some.y|): R|Some| {
+        }
 
     }
     public final fun test(some: R|Some|): R|kotlin/Unit| {

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

@@ -8,7 +8,7 @@ FILE: LinkedList.kt
 FILE: HashSet.kt
     public final class HashSet<T> : R|java/util/HashSet<T>| {
         public constructor<T>(): R|util/HashSet<T>| {
-            super<R|java/util/HashSet<T>|>()
+            super<R|kotlin/Any|>()
         }
 
     }

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

@@ -51,9 +51,12 @@ FILE: incompatibleModifiers.kt
         public final val i: R|kotlin/Int| = R|<local>/i|
             public get(): R|kotlin/Int|
 
-        public final fun component1(): R|kotlin/Int|
+        public final fun component1(): R|kotlin/Int| {
+            ^component1 this@R|/H|.R|/H.i|
+        }
 
-        public final fun copy(i: R|kotlin/Int| = this@R|/H|.R|/H.i|): R|H|
+        public final fun copy(i: R|kotlin/Int| = this@R|/H|.R|/H.i|): R|H| {
+        }
 
     }
     public sealed data class I : R|kotlin/Any| {
@@ -64,9 +67,12 @@ FILE: incompatibleModifiers.kt
         public final val i: R|kotlin/Int| = R|<local>/i|
             public get(): R|kotlin/Int|
 
-        public final fun component1(): R|kotlin/Int|
+        public final fun component1(): R|kotlin/Int| {
+            ^component1 this@R|/I|.R|/I.i|
+        }
 
-        public final fun copy(i: R|kotlin/Int| = this@R|/I|.R|/I.i|): R|I|
+        public final fun copy(i: R|kotlin/Int| = this@R|/I|.R|/I.i|): R|I| {
+        }
 
     }
     public final data inline class J : R|kotlin/Any| {
@@ -77,9 +83,12 @@ FILE: incompatibleModifiers.kt
         public final val i: R|kotlin/Int| = R|<local>/i|
             public get(): R|kotlin/Int|
 
-        public final fun component1(): R|kotlin/Int|
+        public final fun component1(): R|kotlin/Int| {
+            ^component1 this@R|/J|.R|/J.i|
+        }
 
-        public final fun copy(i: R|kotlin/Int| = this@R|/J|.R|/J.i|): R|J|
+        public final fun copy(i: R|kotlin/Int| = this@R|/J|.R|/J.i|): R|J| {
+        }
 
     }
     public abstract class K : R|kotlin/Any| {
@@ -119,9 +128,12 @@ FILE: incompatibleModifiers.kt
             public final val i: R|kotlin/Int| = R|<local>/i|
                 public get(): R|kotlin/Int|
 
-            public final fun component1(): R|kotlin/Int|
+            public final fun component1(): R|kotlin/Int| {
+                ^component1 this@R|/X.Y|.R|/X.Y.i|
+            }
 
-            public final fun copy(i: R|kotlin/Int| = this@R|/X.Y|.R|/X.Y.i|): R|X.Y|
+            public final fun copy(i: R|kotlin/Int| = this@R|/X.Y|.R|/X.Y.i|): R|X.Y| {
+            }
 
         }
 

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

@@ -10,7 +10,7 @@ FILE: notASupertype.kt
     }
     public final class B : R|A| {
         public constructor(): R|B| {
-            super<R|A|>()
+            super<R|kotlin/Any|>()
         }
 
         public final fun g(): R|kotlin/Unit| {

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

@@ -13,7 +13,7 @@ FILE: checkArguments.kt
     }
     public final class C : R|B| {
         public constructor(): R|C| {
-            super<R|B|>()
+            super<R|kotlin/Any|>()
         }
 
     }

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

@@ -1,7 +1,7 @@
 FILE: test.kt
     public final class MyDecorator : R|Decorator<LookupElement>| {
         public constructor(): R|MyDecorator| {
-            super<R|Decorator<LookupElement>|>()
+            super<R|kotlin/Any|>()
         }
 
         public final override fun getLookupString(): R|kotlin/String| {

compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.txt

@@ -4,8 +4,8 @@ FILE: complexTypes.kt
             super<R|kotlin/Any|>()
         }
 
-        public final inner class D<R, in P, T, out S> : R|kotlin/Any| {
-            public constructor<R, in P>(): R|a/b/C.D<R, P, T, S>| {
+        public final inner class D<R, in P> : R|kotlin/Any| {
+            public constructor<R, in P>(): R|a/b/C.D<R, P>| {
                 super<R|kotlin/Any|>()
             }
 
@@ -13,7 +13,7 @@ FILE: complexTypes.kt
 
     }
     public abstract interface Test : R|kotlin/Any| {
-        public abstract val x: R|a/b/C.D<in kotlin/collections/List<*>, *, out kotlin/CharSequence, *>|
-            public get(): R|a/b/C.D<in kotlin/collections/List<*>, *, out kotlin/CharSequence, *>|
+        public abstract val x: R|a/b/C.D<out kotlin/CharSequence, *, in kotlin/collections/List<*>, *>|
+            public get(): R|a/b/C.D<out kotlin/CharSequence, *, in kotlin/collections/List<*>, *>|
 
     }

compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.txt

@@ -13,7 +13,7 @@ FILE: test.kt
 
         public final class Extra : R|test/Test| {
             public constructor(x: R|kotlin/Int|): R|test/Test.Extra| {
-                super<R|test/Test|>()
+                super<R|kotlin/Any|>()
             }
 
             public final val x: R|kotlin/Int| = R|<local>/x|

compiler/fir/analysis-tests/testData/resolve/nested/innerTypes.kt

@@ -1,21 +0,0 @@
-class Outer<T> {
-    inner class Inner<K>
-}
-
-class Boxed<Q> {
-    fun substitute() = Outer<Q>().Inner<Int>()
-}
-
-fun accept(p: Outer<String>.Inner<Int>) {}
-
-val rr = Outer<String>().Inner<Int>()
-val rrq = Boxed<String>().substitute()
-
-fun check() {
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<Int>().Inner<Int>()) // illegal
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
-    accept(Outer<String>().Inner<Int>()) // ok
-
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Boxed<Int>().substitute()) // illegal
-    accept(Boxed<String>().substitute()) // ok
-}

compiler/fir/analysis-tests/testData/resolve/nested/innerTypes.txt

@@ -1,37 +0,0 @@
-FILE: innerTypes.kt
-    public final class Outer<T> : R|kotlin/Any| {
-        public constructor<T>(): R|Outer<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final inner class Inner<K, T> : R|kotlin/Any| {
-            public constructor<K>(): R|Outer.Inner<K, T>| {
-                super<R|kotlin/Any|>()
-            }
-
-        }
-
-    }
-    public final class Boxed<Q> : R|kotlin/Any| {
-        public constructor<Q>(): R|Boxed<Q>| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final fun substitute(): R|Outer.Inner<kotlin/Int, Q>| {
-            ^substitute R|/Outer.Outer|<R|Q|>().R|/Outer.Inner.Inner|<R|kotlin/Int|>()
-        }
-
-    }
-    public final fun accept(p: R|Outer.Inner<kotlin/Int, kotlin/String>|): R|kotlin/Unit| {
-    }
-    public final val rr: R|Outer.Inner<kotlin/Int, kotlin/String>| = R|/Outer.Outer|<R|kotlin/String|>().R|/Outer.Inner.Inner|<R|kotlin/Int|>()
-        public get(): R|Outer.Inner<kotlin/Int, kotlin/String>|
-    public final val rrq: R|Outer.Inner<kotlin/Int, kotlin/String>| = R|/Boxed.Boxed|<R|kotlin/String|>().R|FakeOverride</Boxed.substitute: R|Outer.Inner<kotlin/Int, kotlin/String>|>|()
-        public get(): R|Outer.Inner<kotlin/Int, kotlin/String>|
-    public final fun check(): R|kotlin/Unit| {
-        <Inapplicable(INAPPLICABLE): [/accept]>#(R|/Outer.Outer|<R|kotlin/Int|>().R|/Outer.Inner.Inner|<R|kotlin/Int|>())
-        <Inapplicable(INAPPLICABLE): [/accept]>#(R|/Outer.Outer|<R|kotlin/String|>().R|/Outer.Inner.Inner|<R|kotlin/String|>())
-        R|/accept|(R|/Outer.Outer|<R|kotlin/String|>().R|/Outer.Inner.Inner|<R|kotlin/Int|>())
-        <Inapplicable(INAPPLICABLE): [/accept]>#(R|/Boxed.Boxed|<R|kotlin/Int|>().R|FakeOverride</Boxed.substitute: R|Outer.Inner<kotlin/Int, kotlin/Int>|>|())
-        R|/accept|(R|/Boxed.Boxed|<R|kotlin/String|>().R|FakeOverride</Boxed.substitute: R|Outer.Inner<kotlin/Int, kotlin/String>|>|())
-    }

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

@@ -42,13 +42,20 @@ FILE: problems2.kt
             public final val s: R|kotlin/String?| = R|<local>/s|
                 public get(): R|kotlin/String?|
 
-            public final fun component1(): R|kotlin/Int|
+            public final fun component1(): R|kotlin/Int| {
+                ^component1 this@R|/Some.WithPrimary|.R|/Some.WithPrimary.x|
+            }
 
-            public final fun component2(): R|kotlin/Array<kotlin/String>?|
+            public final fun component2(): R|kotlin/Array<kotlin/String>?| {
+                ^component2 this@R|/Some.WithPrimary|.R|/Some.WithPrimary.arr|
+            }
 
-            public final fun component3(): R|kotlin/String?|
+            public final fun component3(): R|kotlin/String?| {
+                ^component3 this@R|/Some.WithPrimary|.R|/Some.WithPrimary.s|
+            }
 
-            public final fun copy(x: R|kotlin/Int| = this@R|/Some.WithPrimary|.R|/Some.WithPrimary.x|, arr: R|kotlin/Array<kotlin/String>?| = this@R|/Some.WithPrimary|.R|/Some.WithPrimary.arr|, s: R|kotlin/String?| = this@R|/Some.WithPrimary|.R|/Some.WithPrimary.s|): R|Some.WithPrimary|
+            public final fun copy(x: R|kotlin/Int| = this@R|/Some.WithPrimary|.R|/Some.WithPrimary.x|, arr: R|kotlin/Array<kotlin/String>?| = this@R|/Some.WithPrimary|.R|/Some.WithPrimary.arr|, s: R|kotlin/String?| = this@R|/Some.WithPrimary|.R|/Some.WithPrimary.s|): R|Some.WithPrimary| {
+            }
 
         }
 

compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt

@@ -1,9 +0,0 @@
-fun Short.foo(): Int = 1
-fun Int.foo(): Int = 2
-
-fun testRef(f: () -> Int) {}
-
-fun test() {
-    // should resolve to Int.foo
-    testRef(1::foo)
-}

compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.txt

@@ -1,12 +0,0 @@
-FILE: integerLiteralInLhs.kt
-    public final fun R|kotlin/Short|.foo(): R|kotlin/Int| {
-        ^foo Int(1)
-    }
-    public final fun R|kotlin/Int|.foo(): R|kotlin/Int| {
-        ^foo Int(2)
-    }
-    public final fun testRef(f: R|() -> kotlin/Int|): R|kotlin/Unit| {
-    }
-    public final fun test(): R|kotlin/Unit| {
-        R|/testRef|(Int(1)::R|/foo|)
-    }

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

@@ -6,8 +6,8 @@ FILE: typeParameterVsNested.kt
             super<R|kotlin/Any|>()
         }
 
-        public final inner class T<T : R|test/Some|> : R|kotlin/Any| {
-            public constructor(): R|test/My.T<T>| {
+        public final inner class T : R|kotlin/Any| {
+            public constructor(): R|test/My.T| {
                 super<R|kotlin/Any|>()
             }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/moreSpecificAmbiguousExtensions.kt

@@ -6,14 +6,14 @@ fun IB.extFun(x: IA) {}
 
 fun test() {
     val extFun1 = IA::extFun
-    val extFun2 = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
+    val extFun2 = IB::extFun
 }
 
 fun testWithExpectedType() {
     // NB: should be resolved to kotlin/FunctionX, not kotlin/reflect/FunctionX
     val extFun_AB_A: IA.(IB) -> Unit = IA::extFun
-    val extFun_AA_B: IA.(IA) -> Unit = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
+    val extFun_AA_B: IA.(IA) -> Unit = IB::extFun
     val extFun_BB_A: IB.(IB) -> Unit = IA::extFun
     val extFun_BA_B: IB.(IA) -> Unit = IB::extFun
-    val extFun_BB_B: IB.(IB) -> Unit = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
+    val extFun_BB_B: IB.(IB) -> Unit = IB::extFun
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/moreSpecificAmbiguousExtensions.txt

@@ -9,12 +9,12 @@ FILE: moreSpecificAmbiguousExtensions.kt
     }
     public final fun test(): R|kotlin/Unit| {
         lval extFun1: R|kotlin/reflect/KFunction2<IA, IB, kotlin/Unit>| = Q|IA|::R|/extFun|
-        lval extFun2: <ERROR TYPE REF: No result type for initializer> = Q|IB|::<Unresolved reference: extFun>#
+        lval extFun2: R|kotlin/reflect/KFunction2<IB, IB, kotlin/Unit>| = Q|IB|::R|/extFun|
     }
     public final fun testWithExpectedType(): R|kotlin/Unit| {
         lval extFun_AB_A: R|IA.(IB) -> kotlin/Unit| = Q|IA|::R|/extFun|
-        lval extFun_AA_B: R|IA.(IA) -> kotlin/Unit| = Q|IB|::<Unresolved reference: extFun>#
+        lval extFun_AA_B: R|IA.(IA) -> kotlin/Unit| = Q|IB|::R|/extFun|
         lval extFun_BB_A: R|IB.(IB) -> kotlin/Unit| = Q|IA|::R|/extFun|
         lval extFun_BA_B: R|IB.(IA) -> kotlin/Unit| = Q|IB|::R|/extFun|
-        lval extFun_BB_B: R|IB.(IB) -> kotlin/Unit| = Q|IB|::<Unresolved reference: extFun>#
+        lval extFun_BB_B: R|IB.(IB) -> kotlin/Unit| = Q|IB|::R|/extFun|
     }

compiler/fir/analysis-tests/testData/resolveWithStdlib/components.txt

@@ -10,11 +10,16 @@ FILE: components.kt
         public final val y: R|kotlin/String| = R|<local>/y|
             public get(): R|kotlin/String|
 
-        public final fun component1(): R|kotlin/Int|
+        public final fun component1(): R|kotlin/Int| {
+            ^component1 this@R|/D|.R|/D.x|
+        }
 
-        public final fun component2(): R|kotlin/String|
+        public final fun component2(): R|kotlin/String| {
+            ^component2 this@R|/D|.R|/D.y|
+        }
 
-        public final fun copy(x: R|kotlin/Int| = this@R|/D|.R|/D.x|, y: R|kotlin/String| = this@R|/D|.R|/D.y|): R|D|
+        public final fun copy(x: R|kotlin/Int| = this@R|/D|.R|/D.x|, y: R|kotlin/String| = this@R|/D|.R|/D.y|): R|D| {
+        }
 
     }
     public final fun foo(list: R|kotlin/collections/List<D>|): R|kotlin/Unit| {

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atLeastOnce.dot

@@ -1,88 +0,0 @@
-digraph atLeastOnce_kt {
-    graph [nodesep=3]
-    node [shape=box penwidth=2]
-    edge [penwidth=2]
-
-    subgraph cluster_0 {
-        color=red
-        0 [label="Enter function inlineRun" style="filled" fillcolor=red];
-        2 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        1 [label="Exit function inlineRun" style="filled" fillcolor=red];
-    }
-    0 -> {2};
-    2 -> {1};
-
-    subgraph cluster_1 {
-        color=red
-        3 [label="Enter function myRun" style="filled" fillcolor=red];
-        5 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        4 [label="Exit function myRun" style="filled" fillcolor=red];
-    }
-    3 -> {5};
-    5 -> {4};
-
-    subgraph cluster_2 {
-        color=red
-        6 [label="Enter function test_1" style="filled" fillcolor=red];
-        8 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        9 [label="Postponed enter to lambda"];
-        subgraph cluster_3 {
-            color=blue
-            14 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            16 [label="Const: Int(1)"];
-            17 [label="Assignment: R|<local>/x|"];
-            15 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        10 [label="Postponed exit from lambda"];
-        11 [label="Function call: R|/inlineRun|(...)"];
-        12 [label="Access variable R|<local>/x|"];
-        13 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        7 [label="Exit function test_1" style="filled" fillcolor=red];
-    }
-    6 -> {8};
-    8 -> {9};
-    9 -> {14};
-    9 -> {10} [color=red];
-    10 -> {11};
-    11 -> {12};
-    12 -> {13};
-    13 -> {7};
-    14 -> {16};
-    15 -> {14};
-    15 -> {10} [color=green];
-    16 -> {17};
-    17 -> {15};
-
-    subgraph cluster_4 {
-        color=red
-        18 [label="Enter function test_2" style="filled" fillcolor=red];
-        20 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        21 [label="Postponed enter to lambda"];
-        subgraph cluster_5 {
-            color=blue
-            26 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            28 [label="Const: Int(1)"];
-            29 [label="Assignment: R|<local>/x|"];
-            27 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        22 [label="Postponed exit from lambda"];
-        23 [label="Function call: R|/myRun|(...)"];
-        24 [label="Access variable R|<local>/x|"];
-        25 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        19 [label="Exit function test_2" style="filled" fillcolor=red];
-    }
-    18 -> {20};
-    20 -> {21};
-    21 -> {26};
-    21 -> {22} [color=red];
-    22 -> {23};
-    23 -> {24};
-    24 -> {25};
-    25 -> {19};
-    26 -> {28};
-    27 -> {26};
-    27 -> {22} [color=green];
-    28 -> {29};
-    29 -> {27};
-
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atLeastOnce.kt

@@ -1,33 +0,0 @@
-// !DUMP_CFG
-
-import kotlin.contracts.*
-
-inline fun inlineRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.AT_LEAST_ONCE)
-    }
-    block()
-}
-
-fun myRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.AT_LEAST_ONCE)
-    }
-    block()
-}
-
-fun test_1() {
-    val x: Int
-    inlineRun {
-        x = 1
-    }
-    x.inc()
-}
-
-fun test_2() {
-    val x: Int
-    myRun {
-        x = 1
-    }
-    x.inc()
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atLeastOnce.txt

@@ -1,35 +0,0 @@
-FILE: atLeastOnce.kt
-    public final inline fun inlineRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, AT_LEAST_ONCE)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun myRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, AT_LEAST_ONCE)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun test_1(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/inlineRun|(<L> = inlineRun@fun <anonymous>(): R|kotlin/Unit| <kind=AT_LEAST_ONCE>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }
-    public final fun test_2(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/myRun|(<L> = myRun@fun <anonymous>(): R|kotlin/Unit| <kind=AT_LEAST_ONCE>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atMostOnce.dot

@@ -1,86 +0,0 @@
-digraph atMostOnce_kt {
-    graph [nodesep=3]
-    node [shape=box penwidth=2]
-    edge [penwidth=2]
-
-    subgraph cluster_0 {
-        color=red
-        0 [label="Enter function inlineRun" style="filled" fillcolor=red];
-        2 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        1 [label="Exit function inlineRun" style="filled" fillcolor=red];
-    }
-    0 -> {2};
-    2 -> {1};
-
-    subgraph cluster_1 {
-        color=red
-        3 [label="Enter function myRun" style="filled" fillcolor=red];
-        5 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        4 [label="Exit function myRun" style="filled" fillcolor=red];
-    }
-    3 -> {5};
-    5 -> {4};
-
-    subgraph cluster_2 {
-        color=red
-        6 [label="Enter function test_1" style="filled" fillcolor=red];
-        8 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        9 [label="Postponed enter to lambda"];
-        subgraph cluster_3 {
-            color=blue
-            14 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            16 [label="Const: Int(1)"];
-            17 [label="Assignment: R|<local>/x|"];
-            15 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        10 [label="Postponed exit from lambda"];
-        11 [label="Function call: R|/inlineRun|(...)"];
-        12 [label="Access variable R|<local>/x|"];
-        13 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        7 [label="Exit function test_1" style="filled" fillcolor=red];
-    }
-    6 -> {8};
-    8 -> {9};
-    9 -> {14};
-    9 -> {10} [color=red];
-    10 -> {11};
-    11 -> {12};
-    12 -> {13};
-    13 -> {7};
-    14 -> {15 16};
-    15 -> {10} [color=green];
-    16 -> {17};
-    17 -> {15};
-
-    subgraph cluster_4 {
-        color=red
-        18 [label="Enter function test_2" style="filled" fillcolor=red];
-        20 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        21 [label="Postponed enter to lambda"];
-        subgraph cluster_5 {
-            color=blue
-            26 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            28 [label="Const: Int(1)"];
-            29 [label="Assignment: R|<local>/x|"];
-            27 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        22 [label="Postponed exit from lambda"];
-        23 [label="Function call: R|/myRun|(...)"];
-        24 [label="Access variable R|<local>/x|"];
-        25 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        19 [label="Exit function test_2" style="filled" fillcolor=red];
-    }
-    18 -> {20};
-    20 -> {21};
-    21 -> {26};
-    21 -> {22} [color=red];
-    22 -> {23};
-    23 -> {24};
-    24 -> {25};
-    25 -> {19};
-    26 -> {27 28};
-    27 -> {22} [color=green];
-    28 -> {29};
-    29 -> {27};
-
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atMostOnce.kt

@@ -1,33 +0,0 @@
-// !DUMP_CFG
-
-import kotlin.contracts.*
-
-inline fun inlineRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.AT_MOST_ONCE)
-    }
-    block()
-}
-
-fun myRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.AT_MOST_ONCE)
-    }
-    block()
-}
-
-fun test_1() {
-    val x: Int
-    inlineRun {
-        x = 1
-    }
-    x.inc()
-}
-
-fun test_2() {
-    val x: Int
-    myRun {
-        x = 1
-    }
-    x.inc()
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atMostOnce.txt

@@ -1,35 +0,0 @@
-FILE: atMostOnce.kt
-    public final inline fun inlineRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, AT_MOST_ONCE)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun myRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, AT_MOST_ONCE)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun test_1(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/inlineRun|(<L> = inlineRun@fun <anonymous>(): R|kotlin/Unit| <kind=AT_MOST_ONCE>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }
-    public final fun test_2(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/myRun|(<L> = myRun@fun <anonymous>(): R|kotlin/Unit| <kind=AT_MOST_ONCE>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/exactlyOnce.dot

@@ -1,92 +0,0 @@
-digraph exactlyOnce_kt {
-    graph [nodesep=3]
-    node [shape=box penwidth=2]
-    edge [penwidth=2]
-
-    subgraph cluster_0 {
-        color=red
-        0 [label="Enter function inlineRun" style="filled" fillcolor=red];
-        2 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        1 [label="Exit function inlineRun" style="filled" fillcolor=red];
-    }
-    0 -> {2};
-    2 -> {1};
-
-    subgraph cluster_1 {
-        color=red
-        3 [label="Enter function myRun" style="filled" fillcolor=red];
-        5 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        4 [label="Exit function myRun" style="filled" fillcolor=red];
-    }
-    3 -> {5};
-    5 -> {4};
-
-    subgraph cluster_2 {
-        color=red
-        6 [label="Enter function test_1" style="filled" fillcolor=red];
-        8 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        9 [label="Postponed enter to lambda"];
-        subgraph cluster_3 {
-            color=blue
-            15 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            17 [label="Const: Int(1)"];
-            18 [label="Assignment: R|<local>/x|"];
-            16 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        12 [label="Call arguments union" style="filled" fillcolor=yellow];
-        10 [label="Postponed exit from lambda"];
-        11 [label="Function call: R|/inlineRun|(...)"];
-        13 [label="Access variable R|<local>/x|"];
-        14 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        7 [label="Exit function test_1" style="filled" fillcolor=red];
-    }
-    6 -> {8};
-    8 -> {9};
-    9 -> {15};
-    9 -> {10} [color=red];
-    10 -> {11} [color=green];
-    11 -> {13};
-    12 -> {11} [color=red];
-    13 -> {14};
-    14 -> {7};
-    15 -> {17};
-    16 -> {10} [color=green];
-    16 -> {12} [color=red];
-    17 -> {18};
-    18 -> {16};
-
-    subgraph cluster_4 {
-        color=red
-        19 [label="Enter function test_2" style="filled" fillcolor=red];
-        21 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        22 [label="Postponed enter to lambda"];
-        subgraph cluster_5 {
-            color=blue
-            28 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            30 [label="Const: Int(1)"];
-            31 [label="Assignment: R|<local>/x|"];
-            29 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        25 [label="Call arguments union" style="filled" fillcolor=yellow];
-        23 [label="Postponed exit from lambda"];
-        24 [label="Function call: R|/myRun|(...)"];
-        26 [label="Access variable R|<local>/x|"];
-        27 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        20 [label="Exit function test_2" style="filled" fillcolor=red];
-    }
-    19 -> {21};
-    21 -> {22};
-    22 -> {28};
-    22 -> {23} [color=red];
-    23 -> {24} [color=green];
-    24 -> {26};
-    25 -> {24} [color=red];
-    26 -> {27};
-    27 -> {20};
-    28 -> {30};
-    29 -> {23} [color=green];
-    29 -> {25} [color=red];
-    30 -> {31};
-    31 -> {29};
-
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/exactlyOnce.kt

@@ -1,33 +0,0 @@
-// !DUMP_CFG
-
-import kotlin.contracts.*
-
-inline fun inlineRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
-    }
-    block()
-}
-
-fun myRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
-    }
-    block()
-}
-
-fun test_1() {
-    val x: Int
-    inlineRun {
-        x = 1
-    }
-    x.inc()
-}
-
-fun test_2() {
-    val x: Int
-    myRun {
-        x = 1
-    }
-    x.inc()
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/exactlyOnce.txt

@@ -1,35 +0,0 @@
-FILE: exactlyOnce.kt
-    public final inline fun inlineRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, EXACTLY_ONCE)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun myRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, EXACTLY_ONCE)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun test_1(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/inlineRun|(<L> = inlineRun@fun <anonymous>(): R|kotlin/Unit| <kind=EXACTLY_ONCE>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }
-    public final fun test_2(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/myRun|(<L> = myRun@fun <anonymous>(): R|kotlin/Unit| <kind=EXACTLY_ONCE>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/unknown.dot

@@ -1,88 +0,0 @@
-digraph unknown_kt {
-    graph [nodesep=3]
-    node [shape=box penwidth=2]
-    edge [penwidth=2]
-
-    subgraph cluster_0 {
-        color=red
-        0 [label="Enter function inlineRun" style="filled" fillcolor=red];
-        2 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        1 [label="Exit function inlineRun" style="filled" fillcolor=red];
-    }
-    0 -> {2};
-    2 -> {1};
-
-    subgraph cluster_1 {
-        color=red
-        3 [label="Enter function myRun" style="filled" fillcolor=red];
-        5 [label="Function call: R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()"];
-        4 [label="Exit function myRun" style="filled" fillcolor=red];
-    }
-    3 -> {5};
-    5 -> {4};
-
-    subgraph cluster_2 {
-        color=red
-        6 [label="Enter function test_1" style="filled" fillcolor=red];
-        8 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        9 [label="Postponed enter to lambda"];
-        subgraph cluster_3 {
-            color=blue
-            14 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            16 [label="Const: Int(1)"];
-            17 [label="Assignment: R|<local>/x|"];
-            15 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        10 [label="Postponed exit from lambda"];
-        11 [label="Function call: R|/inlineRun|(...)"];
-        12 [label="Access variable R|<local>/x|"];
-        13 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        7 [label="Exit function test_1" style="filled" fillcolor=red];
-    }
-    6 -> {8};
-    8 -> {9};
-    9 -> {14};
-    9 -> {10} [color=red];
-    10 -> {11};
-    11 -> {12};
-    12 -> {13};
-    13 -> {7};
-    14 -> {15 16};
-    15 -> {14};
-    15 -> {10} [color=green];
-    16 -> {17};
-    17 -> {15};
-
-    subgraph cluster_4 {
-        color=red
-        18 [label="Enter function test_2" style="filled" fillcolor=red];
-        20 [label="Variable declaration: lval x: R|kotlin/Int|"];
-        21 [label="Postponed enter to lambda"];
-        subgraph cluster_5 {
-            color=blue
-            26 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-            28 [label="Const: Int(1)"];
-            29 [label="Assignment: R|<local>/x|"];
-            27 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-        }
-        22 [label="Postponed exit from lambda"];
-        23 [label="Function call: R|/myRun|(...)"];
-        24 [label="Access variable R|<local>/x|"];
-        25 [label="Function call: R|<local>/x|.R|kotlin/Int.inc|()"];
-        19 [label="Exit function test_2" style="filled" fillcolor=red];
-    }
-    18 -> {20};
-    20 -> {21};
-    21 -> {26};
-    21 -> {22} [color=red];
-    22 -> {23};
-    23 -> {24};
-    24 -> {25};
-    25 -> {19};
-    26 -> {27 28};
-    27 -> {26};
-    27 -> {22} [color=green];
-    28 -> {29};
-    29 -> {27};
-
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/unknown.kt

@@ -1,33 +0,0 @@
-// !DUMP_CFG
-
-import kotlin.contracts.*
-
-inline fun inlineRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.UNKNOWN)
-    }
-    block()
-}
-
-fun myRun(block: () -> Unit) {
-    contract {
-        callsInPlace(block, InvocationKind.UNKNOWN)
-    }
-    block()
-}
-
-fun test_1() {
-    val x: Int
-    inlineRun {
-        x = 1
-    }
-    x.inc()
-}
-
-fun test_2() {
-    val x: Int
-    myRun {
-        x = 1
-    }
-    x.inc()
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/unknown.txt

@@ -1,35 +0,0 @@
-FILE: unknown.kt
-    public final inline fun inlineRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, UNKNOWN)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun myRun(block: R|() -> kotlin/Unit|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            CallsInPlace(block, UNKNOWN)
-        >
-     {
-        [StubStatement]
-        R|<local>/block|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/Unit|>|()
-    }
-    public final fun test_1(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/inlineRun|(<L> = inlineRun@fun <anonymous>(): R|kotlin/Unit| <kind=UNKNOWN>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }
-    public final fun test_2(): R|kotlin/Unit| {
-        lval x: R|kotlin/Int|
-        R|/myRun|(<L> = myRun@fun <anonymous>(): R|kotlin/Unit| <kind=UNKNOWN>  {
-            R|<local>/x| = Int(1)
-        }
-        )
-        R|<local>/x|.R|kotlin/Int.inc|()
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt

@@ -1,69 +0,0 @@
-import kotlin.contracts.*
-
-fun myRequire(b: Boolean) {
-    contract {
-        returns() implies (b)
-    }
-    if (!b) throw IllegalStateException()
-}
-
-fun myRequireAnd(b1: Boolean, b2: Boolean) {
-    contract {
-        returns() implies (b1 && b2)
-    }
-    if (!(b1 && b2)) throw IllegalStateException()
-}
-
-fun myRequireOr(b1: Boolean, b2: Boolean) {
-    contract {
-        returns() implies (b1 || b2)
-    }
-    if (!(b1 || b2)) throw IllegalStateException()
-}
-
-fun myRequireNot(b: Boolean) {
-    contract {
-        returns() implies (!b)
-    }
-    if (b) throw IllegalStateException()
-}
-
-// ----------------------------------------------------
-
-interface A {
-    fun foo()
-}
-
-interface B : A {
-    fun bar()
-}
-
-interface C : A {
-    fun baz()
-}
-
-// ----------------------------------------------------
-
-fun test_1(x: Any) {
-    myRequire(x is A)
-    x.foo()
-}
-
-fun test_2(x: Any) {
-    myRequireAnd(x is B, x is C)
-    x.foo()
-    x.bar()
-    x.baz()
-}
-
-fun test_3(x: Any) {
-    myRequireOr(x is B, x is C)
-    x.foo() // OK
-    x.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
-    x.<!UNRESOLVED_REFERENCE!>baz<!>() // Error
-}
-
-fun test_4(x: Any) {
-    myRequireNot(x !is A)
-    x.foo()
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.txt

@@ -1,89 +0,0 @@
-FILE: booleanOperators.kt
-    public final fun myRequire(b: R|kotlin/Boolean|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> b
-        >
-     {
-        [StubStatement]
-        when () {
-            R|<local>/b|.R|kotlin/Boolean.not|() ->  {
-                throw R|java/lang/IllegalStateException.IllegalStateException|()
-            }
-        }
-
-    }
-    public final fun myRequireAnd(b1: R|kotlin/Boolean|, b2: R|kotlin/Boolean|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> (b1) && (b2)
-        >
-     {
-        [StubStatement]
-        when () {
-            R|<local>/b1| && R|<local>/b2|.R|kotlin/Boolean.not|() ->  {
-                throw R|java/lang/IllegalStateException.IllegalStateException|()
-            }
-        }
-
-    }
-    public final fun myRequireOr(b1: R|kotlin/Boolean|, b2: R|kotlin/Boolean|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> (b1) || (b2)
-        >
-     {
-        [StubStatement]
-        when () {
-            R|<local>/b1| || R|<local>/b2|.R|kotlin/Boolean.not|() ->  {
-                throw R|java/lang/IllegalStateException.IllegalStateException|()
-            }
-        }
-
-    }
-    public final fun myRequireNot(b: R|kotlin/Boolean|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> (!)b
-        >
-     {
-        [StubStatement]
-        when () {
-            R|<local>/b| ->  {
-                throw R|java/lang/IllegalStateException.IllegalStateException|()
-            }
-        }
-
-    }
-    public abstract interface A : R|kotlin/Any| {
-        public abstract fun foo(): R|kotlin/Unit|
-
-    }
-    public abstract interface B : R|A| {
-        public abstract fun bar(): R|kotlin/Unit|
-
-    }
-    public abstract interface C : R|A| {
-        public abstract fun baz(): R|kotlin/Unit|
-
-    }
-    public final fun test_1(x: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/myRequire|((R|<local>/x| is R|A|))
-        R|<local>/x|.R|/A.foo|()
-    }
-    public final fun test_2(x: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/myRequireAnd|((R|<local>/x| is R|B|), (R|<local>/x| is R|C|))
-        R|<local>/x|.R|/A.foo|()
-        R|<local>/x|.R|/B.bar|()
-        R|<local>/x|.R|/C.baz|()
-    }
-    public final fun test_3(x: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/myRequireOr|((R|<local>/x| is R|B|), (R|<local>/x| is R|C|))
-        R|<local>/x|.R|/A.foo|()
-        R|<local>/x|.<Unresolved name: bar>#()
-        R|<local>/x|.<Unresolved name: baz>#()
-    }
-    public final fun test_4(x: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/myRequireNot|((R|<local>/x| !is R|A|))
-        R|<local>/x|.R|/A.foo|()
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/eqNotEq.kt

@@ -1,31 +0,0 @@
-import kotlin.contracts.*
-
-fun checkNotNull(x: Any?) {
-    contract {
-        returns(true) implies (x != null)
-        returns(false) implies (x == null)
-    }
-    return x != null
-}
-
-fun trickyRequireNotNull(x: Any?) {
-    contract {
-        returns() implies (!(x == null))
-    }
-    if (x == null) {
-        throw IllegalStateException()
-    }
-}
-
-fun test_1(x: String?) {
-    if (checkNotNull(x)) {
-        x.length // OK
-    } else {
-        x.<!INAPPLICABLE_CANDIDATE!>length<!> // Error
-    }
-}
-
-fun test_2(x: String?) {
-    trickyRequireNotNull(x)
-    x.length
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/eqNotEq.txt

@@ -1,40 +0,0 @@
-FILE: eqNotEq.kt
-    public final fun checkNotNull(x: R|kotlin/Any?|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(TRUE) -> x != null
-            Returns(FALSE) -> x == null
-        >
-     {
-        [StubStatement]
-        ^checkNotNull !=(R|<local>/x|, Null(null))
-    }
-    public final fun trickyRequireNotNull(x: R|kotlin/Any?|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> !x == null
-        >
-     {
-        [StubStatement]
-        when () {
-            ==(R|<local>/x|, Null(null)) ->  {
-                throw R|java/lang/IllegalStateException.IllegalStateException|()
-            }
-        }
-
-    }
-    public final fun test_1(x: R|kotlin/String?|): R|kotlin/Unit| {
-        when () {
-            R|/checkNotNull|(R|<local>/x|) ->  {
-                R|<local>/x|.R|kotlin/String.length|
-            }
-            else ->  {
-                R|<local>/x|.<Inapplicable(WRONG_RECEIVER): [kotlin/String.length]>#
-            }
-        }
-
-    }
-    public final fun test_2(x: R|kotlin/String?|): R|kotlin/Unit| {
-        R|/trickyRequireNotNull|(R|<local>/x|)
-        R|<local>/x|.R|kotlin/String.length|
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/namedArguments.kt

@@ -1,29 +0,0 @@
-import kotlin.contracts.*
-
-fun foo(x: Any, y: Any) {
-    contract {
-        returns() implies (x is Int && y is String)
-    }
-    if (x !is Int || y !is String) {
-        throw IllegalStateException()
-    }
-}
-
-fun test_1(x: Any, y: Any) {
-    foo(x = x, y = y)
-    x.inc()
-    y.length
-}
-
-fun test_2(x: Any, y: Any) {
-    foo(x, y = y)
-    x.inc()
-    y.length
-}
-
-fun test_3(x: Any, y: Any) {
-    foo(y = y, x = x)
-    x.inc()
-    y.length
-}
-

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/namedArguments.txt

@@ -1,30 +0,0 @@
-FILE: namedArguments.kt
-    public final fun foo(x: R|kotlin/Any|, y: R|kotlin/Any|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> x is kotlin/Int && y is kotlin/String
-        >
-     {
-        [StubStatement]
-        when () {
-            (R|<local>/x| !is R|kotlin/Int|) || (R|<local>/y| !is R|kotlin/String|) ->  {
-                throw R|java/lang/IllegalStateException.IllegalStateException|()
-            }
-        }
-
-    }
-    public final fun test_1(x: R|kotlin/Any|, y: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/foo|(x = R|<local>/x|, y = R|<local>/y|)
-        R|<local>/x|.R|kotlin/Int.inc|()
-        R|<local>/y|.R|kotlin/String.length|
-    }
-    public final fun test_2(x: R|kotlin/Any|, y: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/foo|(R|<local>/x|, y = R|<local>/y|)
-        R|<local>/x|.R|kotlin/Int.inc|()
-        R|<local>/y|.R|kotlin/String.length|
-    }
-    public final fun test_3(x: R|kotlin/Any|, y: R|kotlin/Any|): R|kotlin/Unit| {
-        R|/foo|(y = R|<local>/y|, x = R|<local>/x|)
-        R|<local>/x|.R|kotlin/Int.inc|()
-        R|<local>/y|.R|kotlin/String.length|
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/propertyAccessors.kt

@@ -1,30 +0,0 @@
-import kotlin.contracts.*
-
-interface A {
-    fun foo()
-}
-
-var Any?.isNotNull: Boolean
-    get() {
-        contract {
-            returns(true) implies (this@isNotNull != null)
-        }
-        return this != null
-    }
-    set(value) {
-        contract {
-            returns() implies (this@isNotNull != null)
-            require(this != null)
-        }
-    }
-
-fun test_1(a: A?) {
-    if (a.isNotNull) {
-        a.foo()
-    }
-}
-
-fun test_2(a: A?) {
-    a.isNotNull = true
-    a.foo()
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/propertyAccessors.txt

@@ -1,35 +0,0 @@
-FILE: propertyAccessors.kt
-    public abstract interface A : R|kotlin/Any| {
-        public abstract fun foo(): R|kotlin/Unit|
-
-    }
-    public final var R|kotlin/Any?|.isNotNull: R|kotlin/Boolean|
-        public get(): R|kotlin/Boolean|
-            [R|Contract description]
-             <
-                Returns(TRUE) -> this != null
-            >
-         {
-            [StubStatement]
-            ^ !=(this@R|/isNotNull|, Null(null))
-        }
-        public set(value: R|kotlin/Boolean|): R|kotlin/Unit|
-            [R|Contract description]
-             <
-                Returns(WILDCARD) -> this != null
-            >
-         {
-            [StubStatement]
-        }
-    public final fun test_1(a: R|A?|): R|kotlin/Unit| {
-        when () {
-            R|<local>/a|.R|/isNotNull| ->  {
-                R|<local>/a|.R|/A.foo|()
-            }
-        }
-
-    }
-    public final fun test_2(a: R|A?|): R|kotlin/Unit| {
-        R|<local>/a|.R|/isNotNull| = Boolean(true)
-        R|<local>/a|.R|/A.foo|()
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/receivers.kt

@@ -1,43 +0,0 @@
-import kotlin.contracts.*
-
-interface A
-
-fun A.foo() {}
-
-fun Any?.myRequireNotNull() {
-    contract {
-        returns() implies (this@myRequireNotNull != null)
-    }
-    if (this == null) throw IllegalStateException()
-}
-
-fun test_1(x: A?) {
-    x.myRequireNotNull()
-    x.foo()
-}
-
-fun test_2(x: A?) {
-    x.myRequireNotNull()
-    with(x) {
-        foo()
-    }
-}
-
-fun test_3(x: A?) {
-    with(x) {
-        myRequireNotNull()
-    }
-    x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-}
-
-fun test_4(x: A?) {
-    with(x) {
-        myRequireNotNull()
-        foo()
-    }
-}
-
-fun A?.test_5() {
-    myRequireNotNull()
-    foo()
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/receivers.txt

@@ -1,48 +0,0 @@
-FILE: receivers.kt
-    public abstract interface A : R|kotlin/Any| {
-    }
-    public final fun R|A|.foo(): R|kotlin/Unit| {
-    }
-    public final fun R|kotlin/Any?|.myRequireNotNull(): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(WILDCARD) -> this != null
-        >
-     {
-        [StubStatement]
-        when () {
-            ==(this@R|/myRequireNotNull|, Null(null)) ->  {
-                throw R|java/lang/IllegalStateException.IllegalStateException|()
-            }
-        }
-
-    }
-    public final fun test_1(x: R|A?|): R|kotlin/Unit| {
-        R|<local>/x|.R|/myRequireNotNull|()
-        R|<local>/x|.R|/foo|()
-    }
-    public final fun test_2(x: R|A?|): R|kotlin/Unit| {
-        R|<local>/x|.R|/myRequireNotNull|()
-        R|kotlin/with|<R|A|, R|kotlin/Unit|>(R|<local>/x|, <L> = with@fun R|A|.<anonymous>(): R|kotlin/Unit| <kind=EXACTLY_ONCE>  {
-            this@R|special/anonymous|.R|/foo|()
-        }
-        )
-    }
-    public final fun test_3(x: R|A?|): R|kotlin/Unit| {
-        R|kotlin/with|<R|A?|, R|kotlin/Unit|>(R|<local>/x|, <L> = with@fun R|A?|.<anonymous>(): R|kotlin/Unit| <kind=EXACTLY_ONCE>  {
-            this@R|special/anonymous|.R|/myRequireNotNull|()
-        }
-        )
-        R|<local>/x|.<Inapplicable(WRONG_RECEIVER): [/foo]>#()
-    }
-    public final fun test_4(x: R|A?|): R|kotlin/Unit| {
-        R|kotlin/with|<R|A?|, R|kotlin/Unit|>(R|<local>/x|, <L> = with@fun R|A?|.<anonymous>(): R|kotlin/Unit| <kind=EXACTLY_ONCE>  {
-            this@R|special/anonymous|.R|/myRequireNotNull|()
-            this@R|special/anonymous|.R|/foo|()
-        }
-        )
-    }
-    public final fun R|A?|.test_5(): R|kotlin/Unit| {
-        this@R|/test_5|.R|/myRequireNotNull|()
-        this@R|/test_5|.R|/foo|()
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/typePredicate.kt

@@ -1,17 +0,0 @@
-import kotlin.contracts.*
-
-fun checkIsString(x: Any) {
-    contract {
-        returns(true) implies (x is String)
-        returns(false) implies (x !is String)
-    }
-    return x is String
-}
-
-fun test(x: Any) {
-    if (checkIsString(x)) {
-        x.length // OK
-    } else {
-        x.<!UNRESOLVED_REFERENCE!>length<!> // Error
-    }
-}

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/typePredicate.txt

@@ -1,22 +0,0 @@
-FILE: typePredicate.kt
-    public final fun checkIsString(x: R|kotlin/Any|): R|kotlin/Unit|
-        [R|Contract description]
-         <
-            Returns(TRUE) -> x is kotlin/String
-            Returns(FALSE) -> x !is kotlin/String
-        >
-     {
-        [StubStatement]
-        ^checkIsString (R|<local>/x| is R|kotlin/String|)
-    }
-    public final fun test(x: R|kotlin/Any|): R|kotlin/Unit| {
-        when () {
-            R|/checkIsString|(R|<local>/x|) ->  {
-                R|<local>/x|.R|kotlin/String.length|
-            }
-            else ->  {
-                R|<local>/x|.<Unresolved name: length>#
-            }
-        }
-
-    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt

@@ -5,9 +5,9 @@ fun main(k: KSub, vString: SuperClass<String>.NestedInSuperClass, vInt: SuperCla
     k.getImpl().nestedI(vString)
 
     // TODO: Support parametrisized inner classes
-    k.getImpl().<!INAPPLICABLE_CANDIDATE!>nestedI<!>(vInt)
-    k.getNestedSubClass().nested("")
-    k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE!>nested<!>(1)
+    k.getImpl().nestedI(vInt)
+    k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE!>nested<!>("")
+    k.getNestedSubClass().nested(1)
 }
 
 // FILE: J1.java

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.txt

@@ -7,9 +7,9 @@ FILE: K1.kt
     }
     public final fun main(k: R|KSub|, vString: R|SuperClass.NestedInSuperClass<kotlin/String>|, vInt: R|SuperClass.NestedInSuperClass<kotlin/Int>|): R|kotlin/Unit| {
         R|<local>/k|.R|/J1.getImpl|().R|FakeOverride</J1.NestedIImpl.nestedI: R|kotlin/Unit|>|(R|<local>/vString|)
-        R|<local>/k|.R|/J1.getImpl|().<Inapplicable(INAPPLICABLE): [/J1.NestedIImpl.nestedI]>#(R|<local>/vInt|)
-        R|<local>/k|.R|/J1.getNestedSubClass|().R|FakeOverride</J1.NestedSubClass.nested: R|kotlin/Unit|>|(String())
-        R|<local>/k|.R|/J1.getNestedSubClass|().<Inapplicable(INAPPLICABLE): [/J1.NestedSubClass.nested]>#(Int(1))
+        R|<local>/k|.R|/J1.getImpl|().R|FakeOverride</J1.NestedIImpl.nestedI: R|kotlin/Unit|>|(R|<local>/vInt|)
+        R|<local>/k|.R|/J1.getNestedSubClass|().<Inapplicable(INAPPLICABLE): [/SuperClass.NestedInSuperClass.nested]>#(String())
+        R|<local>/k|.R|/J1.getNestedSubClass|().R|/SuperClass.NestedInSuperClass.nested|(Int(1))
     }
 FILE: K2.kt
     public open class KFirst : R|SuperClass<kotlin/String>|, R|SuperI<kotlin/Int>| {
@@ -24,8 +24,8 @@ FILE: K3.kt
             super<R|kotlin/Any|>()
         }
 
-        public open inner class NestedInSuperClass<T> : R|kotlin/Any| {
-            public constructor(): R|SuperClass.NestedInSuperClass<T>| {
+        public open inner class NestedInSuperClass : R|kotlin/Any| {
+            public constructor(): R|SuperClass.NestedInSuperClass| {
                 super<R|kotlin/Any|>()
             }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/MapCompute.txt

@@ -1,6 +1,6 @@
 FILE: MapCompute.kt
     public final fun <D> R|kotlin/collections/MutableMap<kotlin/String, kotlin/collections/MutableSet<D>>|.initAndAdd(key: R|kotlin/String|, value: R|D|): R|kotlin/Unit| {
-        this@R|/initAndAdd|.R|FakeOverride<kotlin/collections/MutableMap.compute: R|kotlin/collections/MutableSet<D>?|>|(R|<local>/key|, <L> = compute@fun <anonymous>(_: R|ft<kotlin/String, kotlin/String?>!|, maybeValues: R|ft<kotlin/collections/MutableSet<D>, kotlin/collections/MutableSet<D>?>!|): R|ft<kotlin/collections/MutableSet<D>, kotlin/collections/MutableSet<D>?>!| {
+        this@R|/initAndAdd|.R|FakeOverride<java/util/Map.compute: R|kotlin/collections/MutableSet<D>?|>|(R|<local>/key|, <L> = compute@fun <anonymous>(_: R|ft<kotlin/String, kotlin/String?>!|, maybeValues: R|ft<kotlin/collections/MutableSet<D>, kotlin/collections/MutableSet<D>?>!|): R|ft<kotlin/collections/MutableSet<D>, kotlin/collections/MutableSet<D>?>!| {
             lval setOfValues: R|kotlin/collections/MutableSet<D>| = when (lval <elvis>: R|ft<kotlin/collections/MutableSet<D>, kotlin/collections/MutableSet<D>?>!| = R|<local>/maybeValues|) {
                 ==($subj$, Null(null)) ->  {
                     R|kotlin/collections/mutableSetOf|<R|D|>()