FIR IDE: Use write lock in KtFirOverrideInfoProvider implementation

`withFir` takes read lock, but checking visibility or implementation
status actually requires resolving declaration to `STATUS` phase. But
resolve cannot be done in `withFir` function, since resolve requires
write lock, and you cannot take both read and write lock

Now we use `withFirWithPossibleResolveInside`, which takes write lock
and allows to perform resolve in it

This should fix failing `FirOverrideImplementTest` tests
in Kotlin IDE plugin

.bunch

@@ -1,2 +1,3 @@
-203
-202
+202
+203_202
+as42

.gitignore

@@ -12,7 +12,7 @@
 /android-studio/sdk
 out/
 /tmp
-/intellij
+kotlin-ide/
 workspace.xml
 *.versionsBackup
 /idea/testData/debugger/tinyApp/classes*

.idea/dictionaries/igor.xml

@@ -1,7 +1,6 @@
 <component name="ProjectDictionaryState">
   <dictionary name="igor">
     <words>
-      <w>addr</w>
       <w>descr</w>
       <w>exprs</w>
     </words>

.idea/kotlinc.xml

@@ -13,6 +13,6 @@
     </option>
   </component>
   <component name="KotlinCompilerSettings">
-    <option name="additionalArguments" value="-version -Xallow-kotlin-package -Xskip-metadata-version-check" />
+    <option name="additionalArguments" value="-version -Xallow-kotlin-package -Xskip-metadata-version-check -Xread-deserialized-contracts" />
   </component>
 </project>

.idea/runConfigurations/IDEA.xml

@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="IDEA" type="GradleRunConfiguration" factoryName="Gradle" singleton="true" folderName="IDEA">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="runIde" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <method />
+  </configuration>
+</component>

.idea/runConfigurations/IDEA_Ultimate.xml

@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="IDEA Ultimate" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="-P intellijUltimateEnabled" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="runUltimate" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <method />
+  </configuration>
+</component>

.idea/runConfigurations/IDEA_Ultimate__No_ProcessCanceledException__.xml

@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="IDEA Ultimate (No ProcessCanceledException) " type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="-PnoPCE" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="runUltimate" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <method />
+  </configuration>
+</component>

.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml

@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="IDEA (No ProcessCanceledException)" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="-PnoPCE" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="runIde" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <method />
+  </configuration>
+</component>

.idea/runConfigurations/IDEA__Not_Internal_.xml

@@ -0,0 +1,19 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="IDEA (Not Internal)" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="-Pidea.is.internal=false" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="runIde" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+  </configuration>
+</component>

.idea/runConfigurations/Test__Commonizer.xml

@@ -4,7 +4,7 @@
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.gradle.CommonizerHierarchicalIT&quot; --tests &quot;org.jetbrains.kotlin.gradle.CommonizerIT&quot; --tests &quot;org.jetbrains.kotlin.commonizer.**&quot; --tests &quot;org.jetbrains.kotlin.gradle.native.CocoaPodsIT.testCinteropCommonization*&quot;" />
+      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.gradle.CommonizerHierarchicalIT&quot; --tests &quot;org.jetbrains.kotlin.gradle.CommonizerIT&quot; --tests &quot;org.jetbrains.kotlin.commonizer.**&quot;" />
       <option name="taskDescriptions">
         <list />
       </option>

ReadMe.md

@@ -56,7 +56,7 @@ Alternatively, it is still possible to only provide required JDKs via environmen
 from environmental variables - disable Gradle toolchain auto-detection by passing `-Porg.gradle.java.installations.auto-detect=false` option
 (or put it into `$GRADLE_USER_HOME/gradle.properties`).
 
-For local development, if you're not working on the standard library, it's OK to avoid installing JDK 1.6 and JDK 1.7.
+For local development, if you're not working on bytecode generation or the standard library, it's OK to avoid installing JDK 1.6 and JDK 1.7.
 Add `kotlin.build.isObsoleteJdkOverrideEnabled=true` to the `local.properties` file, so build will only use JDK 1.8+. Note, that in this
 case, build will have Gradle remote build cache misses for some tasks. 
 

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

@@ -39,11 +39,12 @@ import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
 import java.security.MessageDigest
+import java.util.*
 
 val KOTLIN_CACHE_DIRECTORY_NAME = "kotlin"
 
 open class IncrementalJvmCache(
-    targetDataRoot: File,
+    private val targetDataRoot: File,
     targetOutputDir: File?,
     pathConverter: FileToPathConverter
 ) : AbstractIncrementalCache<JvmClassName>(
@@ -113,43 +114,32 @@ open class IncrementalJvmCache(
     }
 
     open fun saveFileToCache(generatedClass: GeneratedJvmClass, changesCollector: ChangesCollector) {
-        saveClassToCache(KotlinClassInfo(generatedClass.outputClass), generatedClass.sourceFiles, changesCollector)
-    }
-
-    /**
-     * Saves information about the given (kotlinc-generated) class to this cache, and stores changes between this class and its previous
-     * version into the given [ChangesCollector].
-     *
-     * @param kotlinClassInfo A kotlin-generated class
-     * @param sourceFiles The source files that the given class was generated from, or `null` if this information is not available
-     * @param changesCollector A [ChangesCollector]
-     */
-    fun saveClassToCache(kotlinClassInfo: KotlinClassInfo, sourceFiles: List<File>?, changesCollector: ChangesCollector) {
-        val className = kotlinClassInfo.className
+        val sourceFiles: Collection<File> = generatedClass.sourceFiles
+        val kotlinClass: LocalFileKotlinClass = generatedClass.outputClass
+        val className = kotlinClass.className
 
         dirtyOutputClassesMap.notDirty(className)
-        sourceFiles?.forEach {
+        sourceFiles.forEach {
             sourceToClassesMap.add(it, className)
         }
 
-        sourceFiles?.let { internalNameToSource[className.internalName] = it }
+        internalNameToSource[className.internalName] = sourceFiles
 
-        if (kotlinClassInfo.classId.isLocal) return
+        if (kotlinClass.classId.isLocal) return
 
-        when (kotlinClassInfo.classKind) {
+        val header = kotlinClass.classHeader
+        when (header.kind) {
             KotlinClassHeader.Kind.FILE_FACADE -> {
-                if (sourceFiles != null) {
-                    assert(sourceFiles.size == 1) { "Package part from several source files: $sourceFiles" }
-                }
+                assert(sourceFiles.size == 1) { "Package part from several source files: $sourceFiles" }
                 packagePartMap.addPackagePart(className)
 
-                protoMap.process(kotlinClassInfo, changesCollector)
-                constantsMap.process(kotlinClassInfo, changesCollector)
-                inlineFunctionsMap.process(kotlinClassInfo, changesCollector)
+                protoMap.process(kotlinClass, changesCollector)
+                constantsMap.process(kotlinClass, changesCollector)
+                inlineFunctionsMap.process(kotlinClass, changesCollector)
             }
             KotlinClassHeader.Kind.MULTIFILE_CLASS -> {
-                val partNames = kotlinClassInfo.classHeaderData?.toList()
-                    ?: throw AssertionError("Multifile class has no parts: $className")
+                val partNames = kotlinClass.classHeader.data?.toList()
+                    ?: throw AssertionError("Multifile class has no parts: ${kotlinClass.className}")
                 multifileFacadeToParts[className] = partNames
                 // When a class is replaced with a facade with the same name,
                 // the class' proto wouldn't ever be deleted,
@@ -164,29 +154,25 @@ open class IncrementalJvmCache(
                 internalNameToSource.remove(className.internalName)
 
                 // TODO NO_CHANGES? (delegates only)
-                constantsMap.process(kotlinClassInfo, changesCollector)
-                inlineFunctionsMap.process(kotlinClassInfo, changesCollector)
+                constantsMap.process(kotlinClass, changesCollector)
+                inlineFunctionsMap.process(kotlinClass, changesCollector)
             }
             KotlinClassHeader.Kind.MULTIFILE_CLASS_PART -> {
-                if (sourceFiles != null) {
-                    assert(sourceFiles.size == 1) { "Multifile class part from several source files: $sourceFiles" }
-                }
+                assert(sourceFiles.size == 1) { "Multifile class part from several source files: $sourceFiles" }
                 packagePartMap.addPackagePart(className)
-                partToMultifileFacade.set(className.internalName, kotlinClassInfo.multifileClassName!!)
+                partToMultifileFacade.set(className.internalName, header.multifileClassName!!)
 
-                protoMap.process(kotlinClassInfo, changesCollector)
-                constantsMap.process(kotlinClassInfo, changesCollector)
-                inlineFunctionsMap.process(kotlinClassInfo, changesCollector)
+                protoMap.process(kotlinClass, changesCollector)
+                constantsMap.process(kotlinClass, changesCollector)
+                inlineFunctionsMap.process(kotlinClass, changesCollector)
             }
             KotlinClassHeader.Kind.CLASS -> {
-                if (sourceFiles != null) {
-                    assert(sourceFiles.size == 1) { "Class is expected to have only one source file: $sourceFiles" }
-                    addToClassStorage(kotlinClassInfo, sourceFiles.first())
-                }
+                assert(sourceFiles.size == 1) { "Class is expected to have only one source file: $sourceFiles" }
+                addToClassStorage(kotlinClass, sourceFiles.first())
 
-                protoMap.process(kotlinClassInfo, changesCollector)
-                constantsMap.process(kotlinClassInfo, changesCollector)
-                inlineFunctionsMap.process(kotlinClassInfo, changesCollector)
+                protoMap.process(kotlinClass, changesCollector)
+                constantsMap.process(kotlinClass, changesCollector)
+                inlineFunctionsMap.process(kotlinClass, changesCollector)
             }
             KotlinClassHeader.Kind.UNKNOWN, KotlinClassHeader.Kind.SYNTHETIC_CLASS -> {
             }
@@ -292,8 +278,8 @@ open class IncrementalJvmCache(
     private inner class ProtoMap(storageFile: File) : BasicStringMap<ProtoMapValue>(storageFile, ProtoMapValueExternalizer) {
 
         @Synchronized
-        fun process(kotlinClassInfo: KotlinClassInfo, changesCollector: ChangesCollector) {
-            return put(kotlinClassInfo, changesCollector)
+        fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
+            return put(kotlinClass, changesCollector)
         }
 
         // A module mapping (.kotlin_module file) is stored in a cache,
@@ -309,17 +295,19 @@ open class IncrementalJvmCache(
         }
 
         @Synchronized
-        private fun put(kotlinClassInfo: KotlinClassInfo, changesCollector: ChangesCollector) {
-            val key = kotlinClassInfo.className.internalName
+        private fun put(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
+            val header = kotlinClass.classHeader
+
+            val key = kotlinClass.className.internalName
             val oldData = storage[key]
             val newData = ProtoMapValue(
-                kotlinClassInfo.classKind != KotlinClassHeader.Kind.CLASS,
-                BitEncoding.decodeBytes(kotlinClassInfo.classHeaderData!!),
-                kotlinClassInfo.classHeaderStrings!!
+                header.kind != KotlinClassHeader.Kind.CLASS,
+                BitEncoding.decodeBytes(header.data!!),
+                header.strings!!
             )
             storage[key] = newData
 
-            val packageFqName = kotlinClassInfo.className.packageFqName
+            val packageFqName = kotlinClass.className.packageFqName
             changesCollector.collectProtoChanges(oldData?.toProtoData(packageFqName), newData.toProtoData(packageFqName), packageProtoKey = key)
         }
 
@@ -380,16 +368,31 @@ open class IncrementalJvmCache(
 
     // todo: reuse code with InlineFunctionsMap?
     private inner class ConstantsMap(storageFile: File) : BasicStringMap<Map<String, Any>>(storageFile, ConstantsMapExternalizer) {
+        private fun getConstantsMap(bytes: ByteArray): Map<String, Any> {
+            val result = HashMap<String, Any>()
+
+            ClassReader(bytes).accept(object : ClassVisitor(Opcodes.API_VERSION) {
+                override fun visitField(access: Int, name: String, desc: String, signature: String?, value: Any?): FieldVisitor? {
+                    val staticFinal = Opcodes.ACC_STATIC or Opcodes.ACC_FINAL or Opcodes.ACC_PRIVATE
+                    if (value != null && access and staticFinal == Opcodes.ACC_STATIC or Opcodes.ACC_FINAL) {
+                        result[name] = value
+                    }
+                    return null
+                }
+            }, ClassReader.SKIP_CODE or ClassReader.SKIP_DEBUG or ClassReader.SKIP_FRAMES)
+
+            return result
+        }
 
         operator fun contains(className: JvmClassName): Boolean =
             className.internalName in storage
 
         @Synchronized
-        fun process(kotlinClassInfo: KotlinClassInfo, changesCollector: ChangesCollector) {
-            val key = kotlinClassInfo.className.internalName
+        fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
+            val key = kotlinClass.className.internalName
             val oldMap = storage[key] ?: emptyMap()
 
-            val newMap = kotlinClassInfo.constantsMap
+            val newMap = getConstantsMap(kotlinClass.fileContents)
             if (newMap.isNotEmpty()) {
                 storage[key] = newMap
             } else {
@@ -398,18 +401,8 @@ open class IncrementalJvmCache(
 
             for (const in oldMap.keys + newMap.keys) {
                 //Constant can be declared via companion object or via const field declaration
-                changesCollector.collectMemberIfValueWasChanged(
-                    kotlinClassInfo.scopeFqName(companion = true),
-                    const,
-                    oldMap[const],
-                    newMap[const]
-                )
-                changesCollector.collectMemberIfValueWasChanged(
-                    kotlinClassInfo.scopeFqName(companion = false),
-                    const,
-                    oldMap[const],
-                    newMap[const]
-                )
+                changesCollector.collectMemberIfValueWasChanged(kotlinClass.scopeFqName(companion = true), const, oldMap[const], newMap[const])
+                changesCollector.collectMemberIfValueWasChanged(kotlinClass.scopeFqName(companion = false), const, oldMap[const], newMap[const])
             }
         }
 
@@ -497,20 +490,67 @@ open class IncrementalJvmCache(
             value.dumpCollection()
     }
 
-    private fun addToClassStorage(classInfo: KotlinClassInfo, srcFile: File) {
-        val (nameResolver, proto) = JvmProtoBufUtil.readClassDataFrom(classInfo.classHeaderData!!, classInfo.classHeaderStrings!!)
+    private fun addToClassStorage(kotlinClass: LocalFileKotlinClass, srcFile: File) {
+        val (nameResolver, proto) = JvmProtoBufUtil.readClassDataFrom(kotlinClass.classHeader.data!!, kotlinClass.classHeader.strings!!)
         addToClassStorage(proto, nameResolver, srcFile)
     }
 
     private inner class InlineFunctionsMap(storageFile: File) :
         BasicStringMap<Map<String, Long>>(storageFile, StringToLongMapExternalizer) {
+        private fun getInlineFunctionsMap(header: KotlinClassHeader, bytes: ByteArray): Map<String, Long> {
+            val inlineFunctions = inlineFunctionsJvmNames(header)
+            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,
+                    desc: String,
+                    signature: String?,
+                    exceptions: Array<out String>?
+                ): MethodVisitor? {
+                    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() {
+                            val jvmName = name + desc
+                            if (jvmName !in inlineFunctions) return
+
+                            val dummyBytes = dummyClassWriter.toByteArray()!!
+
+                            val hash = dummyBytes.md5()
+                            result[jvmName] = hash
+                        }
+                    }
+                }
+
+            }, 0)
+
+            return result
+        }
 
         @Synchronized
-        fun process(kotlinClassInfo: KotlinClassInfo, changesCollector: ChangesCollector) {
-            val key = kotlinClassInfo.className.internalName
+        fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
+            val key = kotlinClass.className.internalName
             val oldMap = storage[key] ?: emptyMap()
 
-            val newMap = kotlinClassInfo.inlineFunctionsMap
+            val newMap = getInlineFunctionsMap(kotlinClass.classHeader, kotlinClass.fileContents)
             if (newMap.isNotEmpty()) {
                 storage[key] = newMap
             } else {
@@ -519,7 +559,7 @@ open class IncrementalJvmCache(
 
             for (fn in oldMap.keys + newMap.keys) {
                 changesCollector.collectMemberIfValueWasChanged(
-                    kotlinClassInfo.scopeFqName(),
+                    kotlinClass.scopeFqName(),
                     functionNameBySignature(fn),
                     oldMap[fn],
                     newMap[fn]
@@ -562,6 +602,13 @@ sealed class ChangeInfo(val fqName: FqName) {
     }
 }
 
+private fun LocalFileKotlinClass.scopeFqName(companion: Boolean = false) = when (classHeader.kind) {
+    KotlinClassHeader.Kind.CLASS -> {
+        className.fqNameForClassNameWithoutDollars.let { if (companion) it.child(DEFAULT_NAME_FOR_COMPANION_OBJECT) else it }
+    }
+    else -> className.packageFqName
+}
+
 fun ByteArray.md5(): Long {
     val d = MessageDigest.getInstance("MD5").digest(this)!!
     return ((d[0].toLong() and 0xFFL)
@@ -593,105 +640,3 @@ fun <K : Comparable<K>, V> Map<K, V>.dumpMap(dumpValue: (V) -> String): String =
 @TestOnly
 fun <T : Comparable<T>> Collection<T>.dumpCollection(): String =
     "[${sorted().joinToString(", ", transform = Any::toString)}]"
-
-/**
- * Minimal information about a kotlinc-generated class that will be used to compute recompilation-triggered changes to support incremental
- * compilation (see [IncrementalJvmCache.saveClassToCache]).
- *
- * It's important that this class contain only the minimal required information, as it will be part of the classpath snapshot of the
- * `KotlinCompile` task and the task needs to support compile avoidance. For example, this class should contain public method signatures,
- * and should not contain private method signatures, or method implementations.
- */
-class KotlinClassInfo private constructor(
-    val classId: ClassId,
-    val classKind: KotlinClassHeader.Kind,
-    val classHeaderData: Array<String>?,
-    val classHeaderStrings: Array<String>?,
-    @Suppress("SpellCheckingInspection") val multifileClassName: String?,
-    val constantsMap: LinkedHashMap<String, Any>,
-    val inlineFunctionsMap: LinkedHashMap<String, Long>
-) {
-
-    constructor(kotlinClass: LocalFileKotlinClass) : this(
-        kotlinClass.classId,
-        kotlinClass.classHeader.kind,
-        kotlinClass.classHeader.data,
-        kotlinClass.classHeader.strings,
-        kotlinClass.classHeader.multifileClassName,
-        getConstantsMap(kotlinClass.fileContents),
-        getInlineFunctionsMap(kotlinClass.classHeader, kotlinClass.fileContents)
-    )
-
-    val className: JvmClassName by lazy { JvmClassName.byClassId(classId) }
-
-    fun scopeFqName(companion: Boolean = false) = when (classKind) {
-        KotlinClassHeader.Kind.CLASS -> {
-            className.fqNameForClassNameWithoutDollars.let { if (companion) it.child(DEFAULT_NAME_FOR_COMPANION_OBJECT) else it }
-        }
-        else -> className.packageFqName
-    }
-}
-
-private fun getConstantsMap(bytes: ByteArray): LinkedHashMap<String, Any> {
-    val result = LinkedHashMap<String, Any>()
-
-    ClassReader(bytes).accept(object : ClassVisitor(Opcodes.API_VERSION) {
-        override fun visitField(access: Int, name: String, desc: String, signature: String?, value: Any?): FieldVisitor? {
-            val staticFinal = Opcodes.ACC_STATIC or Opcodes.ACC_FINAL or Opcodes.ACC_PRIVATE
-            if (value != null && access and staticFinal == Opcodes.ACC_STATIC or Opcodes.ACC_FINAL) {
-                result[name] = value
-            }
-            return null
-        }
-    }, ClassReader.SKIP_CODE or ClassReader.SKIP_DEBUG or ClassReader.SKIP_FRAMES)
-
-    return result
-}
-
-private fun getInlineFunctionsMap(header: KotlinClassHeader, bytes: ByteArray): LinkedHashMap<String, Long> {
-    val inlineFunctions = inlineFunctionsJvmNames(header)
-    if (inlineFunctions.isEmpty()) return LinkedHashMap()
-
-    val result = LinkedHashMap<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,
-            desc: String,
-            signature: String?,
-            exceptions: Array<out String>?
-        ): MethodVisitor {
-            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() {
-                    val jvmName = name + desc
-                    if (jvmName !in inlineFunctions) return
-
-                    val dummyBytes = dummyClassWriter.toByteArray()!!
-
-                    val hash = dummyBytes.md5()
-                    result[jvmName] = hash
-                }
-            }
-        }
-
-    }, 0)
-
-    return result
-}

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

@@ -48,18 +48,13 @@ open class LookupStorage(
 
     @Volatile
     private var size: Int = 0
-    private var oldSize: Int = 0
 
     init {
         try {
             if (countersFile.exists()) {
                 val lines = countersFile.readLines()
-                size = lines.firstOrNull()?.toIntOrNull() ?: throw IOException("$countersFile exists, but it is empty. " +
-                                                                                       "Counters file is corrupted")
-                oldSize = size
+                size = lines[0].toInt()
             }
-        } catch (e: IOException) {
-            throw e
         } catch (e: Exception) {
             throw IOException("Could not read $countersFile", e)
         }
@@ -125,15 +120,13 @@ open class LookupStorage(
     @Synchronized
     override fun flush(memoryCachesOnly: Boolean) {
         try {
-            if (size != oldSize) {
-                if (size > 0) {
-                    if (!countersFile.exists()) {
-                        countersFile.parentFile.mkdirs()
-                        countersFile.createNewFile()
-                    }
-
-                    countersFile.writeText("$size\n0")
+            if (size > 0) {
+                if (!countersFile.exists()) {
+                    countersFile.parentFile.mkdirs()
+                    countersFile.createNewFile()
                 }
+
+                countersFile.writeText("$size\n")
             }
         } finally {
             super.flush(memoryCachesOnly)

build-common/src/org/jetbrains/kotlin/incremental/storage/CachingLazyStorage.kt

@@ -33,19 +33,15 @@ class CachingLazyStorage<K, V>(
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
     private var storage: PersistentHashMap<K, V>? = null
-    private var isStorageFileExist = true
 
     private fun getStorageIfExists(): PersistentHashMap<K, V>? {
         if (storage != null) return storage
 
-        if (!isStorageFileExist) return null
-
         if (storageFile.exists()) {
             storage = createMap()
             return storage
         }
 
-        isStorageFileExist = false
         return null
     }
 

build-common/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.openapi.util.io.FileUtil
-import com.intellij.openapi.util.text.StringUtil
 import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.EnumeratorStringDescriptor
 import com.intellij.util.io.IOUtil
@@ -27,6 +26,7 @@ import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import java.io.DataInput
 import java.io.DataInputStream
 import java.io.DataOutput
+import java.io.File
 import java.util.*
 
 /**
@@ -162,7 +162,7 @@ object ConstantsMapExternalizer : DataExternalizer<Map<String, Any>> {
         }
     }
 
-    override fun read(input: DataInput): Map<String, Any> {
+    override fun read(input: DataInput): Map<String, Any>? {
         val size = input.readInt()
         val map = HashMap<String, Any>(size)
 
@@ -197,33 +197,15 @@ object IntExternalizer : DataExternalizer<Int> {
     }
 }
 
-
-// Should be consistent with org.jetbrains.jps.incremental.storage.PathStringDescriptor for correct work of portable caches
 object PathStringDescriptor : EnumeratorStringDescriptor() {
-    private const val PORTABLE_CACHES_PROPERTY = "org.jetbrains.jps.portable.caches"
-    private val PORTABLE_CACHES = java.lang.Boolean.getBoolean(PORTABLE_CACHES_PROPERTY)
+    override fun getHashCode(value: String) = FileUtil.pathHashCode(value)
 
-    override fun getHashCode(path: String): Int {
-        if (!PORTABLE_CACHES) return FileUtil.pathHashCode(path)
-        // On case insensitive OS hash calculated from value converted to lower case
-        return if (StringUtil.isEmpty(path)) 0 else FileUtil.toCanonicalPath(path).hashCode()
-    }
-
-    override fun isEqual(val1: String, val2: String?): Boolean {
-        if (!PORTABLE_CACHES) return FileUtil.pathsEqual(val1, val2)
-        // On case insensitive OS hash calculated from path converted to lower case
-        if (val1 == val2) return true
-        if (val2 == null) return false
-
-        val path1 = FileUtil.toCanonicalPath(val1)
-        val path2 = FileUtil.toCanonicalPath(val2)
-        return path1 == path2
-    }
+    override fun isEqual(val1: String, val2: String?) = FileUtil.pathsEqual(val1, val2)
 }
 
 open class CollectionExternalizer<T>(
-    private val elementExternalizer: DataExternalizer<T>,
-    private val newCollection: () -> MutableCollection<T>
+        private val elementExternalizer: DataExternalizer<T>,
+        private val newCollection: () -> MutableCollection<T>
 ) : DataExternalizer<Collection<T>> {
     override fun read(input: DataInput): Collection<T> {
         val result = newCollection()

build.gradle.kts

@@ -29,7 +29,7 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.32")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.31")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath(kotlin("serialization", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
@@ -148,9 +148,11 @@ 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.6.0-dev-1728"
+    extra["versions.kotlin-native"] = "1.6.0-dev-248"
 }
 
+val effectSystemEnabled by extra(project.getBooleanProperty("kotlin.compiler.effectSystemEnabled") ?: false)
+val newInferenceEnabled by extra(project.getBooleanProperty("kotlin.compiler.newInferenceEnabled") ?: false)
 val useJvmFir by extra(project.kotlinBuildProperties.useFir)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
@@ -159,7 +161,11 @@ extra["intellijSeparateSdks"] = intellijSeparateSdks
 
 extra["IntellijCoreDependencies"] =
     listOf(
-        "asm-all-9.0",
+        when {
+            Platform[203].orHigher() -> "asm-all-9.0"
+            Platform[202].orHigher() -> "asm-all-8.0.1"
+            else -> "asm-all-7.0.1"
+        },
         "guava",
         "jdom",
         "jna",
@@ -443,14 +449,9 @@ allprojects {
         project.configureShadowJarSubstitutionInCompileClasspath()
     }
 
-    tasks.withType<JavaCompile> {
-        options.compilerArgs.add("-Xlint:deprecation")
-        options.compilerArgs.add("-Xlint:unchecked")
-        options.compilerArgs.add("-Werror")
-    }
-
     val commonCompilerArgs = listOfNotNull(
         "-Xopt-in=kotlin.RequiresOptIn",
+        "-Xread-deserialized-contracts",
         "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
@@ -466,8 +467,7 @@ allprojects {
         "-Xjvm-default=compatibility",
         "-Xno-optimized-callable-references",
         "-Xno-kotlin-nothing-value-exception",
-        "-Xskip-runtime-version-check",
-        "-Xsuppress-deprecated-jvm-target-warning" // Remove as soon as there are no modules for JDK 1.6 & 1.7
+        "-Xnormalize-constructor-calls=enable"
     )
 
     tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
@@ -481,7 +481,7 @@ allprojects {
         }
     }
 
-    if (!kotlinBuildProperties.disableWerror) {
+    if (!kotlinBuildProperties.isInJpsBuildIdeaSync && !kotlinBuildProperties.useFir && !kotlinBuildProperties.disableWerror) {
         // For compiler and stdlib, allWarningsAsErrors is configured in the corresponding "root" projects
         // (compiler/build.gradle.kts and libraries/commonConfiguration.gradle).
         val projectsWithWarningsAsErrors = listOf("core", "plugins").map { File(it).absoluteFile }
@@ -734,8 +734,14 @@ tasks {
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
         dependsOn(":kotlin-main-kts-test:testWithIr")
-        dependsOn(":kotlin-scripting-ide-services-test:test")
-        dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
+
+        if (kotlinBuildProperties.getOrNull("attachedIntellijVersion") == null &&
+            !kotlinBuildProperties.getBoolean("disableKotlinPluginModules", false)
+        ) {
+            dependsOn(":kotlin-scripting-ide-services-test:test")
+            dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
+        }
+
         dependsOn(":kotlin-scripting-js-test:test")
     }
 
@@ -1139,4 +1145,4 @@ afterEvaluate {
                 "https://cache-redirector.jetbrains.com/github.com/yarnpkg/yarn/releases/download"
         }
     }
-}
+}

buildSrc/build.gradle.kts

@@ -22,7 +22,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.32")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.31")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -143,7 +143,7 @@ java {
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.32")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.31")
     implementation("com.gradle.publish:plugin-publish-plugin:0.14.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")

buildSrc/src/main/kotlin/BuildPropertiesExt.kt

@@ -19,17 +19,7 @@ val KotlinBuildProperties.jarCompression: Boolean get() = getBoolean("kotlin.bui
 
 val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignoreTestFailures", isTeamcityBuild)
 
-val KotlinBuildProperties.disableWerror: Boolean
-    get() = getBoolean("kotlin.build.disable.werror") || useFir || isInJpsBuildIdeaSync || getBoolean("test.progressive.mode")
-
-val KotlinBuildProperties.pathToKotlinModularizedTestData: String?
-    get() = getOrNull("kotlin.fir.modularized.testdata.kotlin") as? String
-
-val KotlinBuildProperties.pathToIntellijModularizedTestData: String?
-    get() = getOrNull("kotlin.fir.modularized.testdata.intellij") as? String
-
-val KotlinBuildProperties.pathToYoutrackModularizedTestData: String?
-    get() = getOrNull("kotlin.fir.modularized.testdata.youtrack") as? String
+val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)
 
 val KotlinBuildProperties.isObsoleteJdkOverrideEnabled: Boolean
     get() = getBoolean("kotlin.build.isObsoleteJdkOverrideEnabled", false)

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -89,4 +89,4 @@ val Project.isIdeaActive
     get() = providers.systemProperty("idea.active").forUseAtConfigurationTime().isPresent
 
 val Project.intellijCommunityDir: File
-    get() = rootDir.resolve("intellij/community").takeIf { it.isDirectory } ?: rootDir.resolve("intellij")
+    get() = rootDir.resolve("kotlin-ide/intellij/community").takeIf { it.isDirectory } ?: rootDir.resolve("kotlin-ide/intellij")

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,7 +26,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P203;
+    P202, P203;
 
     val version: Int = name.drop(1).toInt()
 
@@ -43,7 +43,10 @@ enum class Platform : CompatibilityPredicate {
 }
 
 enum class Ide(val platform: Platform) : CompatibilityPredicate {
-    IJ203(Platform.P203);
+    IJ202(Platform.P202),
+    IJ203(Platform.P203),
+
+    AS42(Platform.P202);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

buildSrc/src/main/kotlin/JvmToolchain.kt

@@ -22,8 +22,7 @@ enum class JdkMajorVersion(
     JDK_10(10, mandatory = false, overrideMajorVersion = 11),
     JDK_11(11, mandatory = false),
     JDK_15(15, mandatory = false),
-    JDK_16(16, mandatory = false),
-    JDK_17(17, mandatory = false);
+    JDK_16(16, mandatory = false);
 
     fun isMandatory(): Boolean = mandatory
 
@@ -181,4 +180,4 @@ fun Project.getJdkVersionWithOverride(jdkVersion: JdkMajorVersion): JdkMajorVers
     } else {
         jdkVersion
     }
-}
+}

buildSrc/src/main/kotlin/LibrariesCommon.kt

@@ -9,8 +9,12 @@ import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.provideDelegate
+import org.gradle.kotlin.dsl.withType
 import org.gradle.process.CommandLineArgumentProvider
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 @JvmOverloads
 fun Project.configureJava9Compilation(
@@ -55,3 +59,17 @@ private class Java9AdditionalArgumentsProvider(
         "-Xlint:-requires-transitive-automatic" // suppress automatic module transitive dependencies in kotlin.test
     )
 }
+
+fun Project.disableDeprecatedJvmTargetWarning() {
+    if (!kotlinBuildProperties.useFir && !kotlinBuildProperties.disableWerror) {
+        val tasksWithWarnings: List<String> by rootProject.extra
+        tasks.withType<KotlinCompile>().configureEach {
+            if (!tasksWithWarnings.contains(path)) {
+                kotlinOptions {
+                    allWarningsAsErrors = true
+                    freeCompilerArgs += "-Xsuppress-deprecated-jvm-target-warning"
+                }
+            }
+        }
+    }
+}

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

@@ -37,10 +37,11 @@ configurations {
 }
 
 tasks.withType<KotlinCompile> {
-    kotlinOptions.languageVersion = "1.4"
-    kotlinOptions.apiVersion = "1.4"
+    kotlinOptions.languageVersion = "1.3"
+    kotlinOptions.apiVersion = "1.3"
     kotlinOptions.freeCompilerArgs += listOf(
         "-Xskip-prerelease-check",
+        "-Xskip-runtime-version-check",
         "-Xsuppress-version-warnings",
         "-Xuse-ir" // Needed as long as languageVersion is less than 1.5.
     )

buildSrc/src/main/kotlin/localDependencies.kt

@@ -17,11 +17,16 @@
 // usages in build scripts are not tracked properly
 @file:Suppress("unused")
 
+import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ModuleDependency
 import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.IvyArtifactRepository
+import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.kotlin.dsl.DependencyHandlerScope
 import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.register
 import java.io.File
 
 private fun Project.kotlinBuildLocalDependenciesDir(): File =
@@ -141,4 +146,70 @@ fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFi
         rootProject = project.rootProject
     )
 
-fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)
+fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)
+
+fun DependencyHandlerScope.excludeInAndroidStudio(rootProject: Project, block: DependencyHandlerScope.() -> Unit) {
+    if (!rootProject.extra.has("versions.androidStudioRelease")) {
+        block()
+    }
+}
+
+fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File, body: JavaExec.() -> Unit): TaskProvider<JavaExec> {
+
+    return tasks.register<JavaExec>(name) {
+        val ideaSandboxConfigDir = File(ideaSandboxDir, "config")
+
+        classpath = mainSourceSet.runtimeClasspath
+
+        mainClass.set("com.intellij.idea.Main")
+
+        workingDir = File(intellijRootDir(), "bin")
+
+        jvmArgs(
+            "-Xmx1250m",
+            "-XX:ReservedCodeCacheSize=240m",
+            "-XX:+HeapDumpOnOutOfMemoryError",
+            "-ea",
+            "-Didea.debug.mode=true",
+            "-Didea.system.path=$ideaSandboxDir",
+            "-Didea.config.path=$ideaSandboxConfigDir",
+            "-Didea.tooling.debug=true",
+            "-Dfus.internal.test.mode=true",
+            "-Dapple.laf.useScreenMenuBar=true",
+            "-Dapple.awt.graphics.UseQuartz=true",
+            "-Dsun.io.useCanonCaches=false",
+            "-Dplugin.path=${ideaPluginDir.absolutePath}"
+        )
+
+        jvmArgs("-Didea.platform.prefix=Idea")
+
+        if (rootProject.findProperty("versions.androidStudioRelease") != null) {
+            jvmArgs("-Didea.platform.prefix=AndroidStudio")
+        }
+
+        if (project.hasProperty("noPCE")) {
+            jvmArgs("-Didea.ProcessCanceledException=disabled")
+        }
+
+        jvmArgs("-Didea.is.internal=${project.findProperty("idea.is.internal") ?: true}")
+
+        project.findProperty("idea.args")?.let { arguments ->
+            jvmArgs(arguments.toString().split(" "))
+        }
+
+        args()
+
+        doFirst {
+            val disabledPluginsFile = File(ideaSandboxConfigDir, "disabled_plugins.txt")
+            val disabledPluginsContents = disabledPluginsFile.takeIf { it.isFile }?.readLines()
+            val filteredContents = disabledPluginsContents?.filterNot { it.contains("org.jetbrains.kotlin") }
+            if (filteredContents != null && filteredContents.size != disabledPluginsContents.size) {
+                with(disabledPluginsFile.printWriter()) {
+                    filteredContents.forEach(this::println)
+                }
+            }
+        }
+
+        body()
+    }
+}

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

@@ -171,18 +171,16 @@ fun Project.configureDefaultPublishing() {
         .all { configureRepository() }
 }
 
-private fun Project.getSensitiveProperty(name: String): String? {
-    return project.findProperty(name) as? String ?: System.getenv(name)
-}
-
 private fun Project.configureSigning() {
     configure<SigningExtension> {
         sign(extensions.getByType<PublishingExtension>().publications) // all publications
 
-        val signKeyId = project.getSensitiveProperty("signKeyId")
+        val signKeyId = project.findProperty("signKeyId") as? String
         if (!signKeyId.isNullOrBlank()) {
-            val signKeyPrivate = project.getSensitiveProperty("signKeyPrivate") ?: error("Parameter `signKeyPrivate` not found")
-            val signKeyPassphrase = project.getSensitiveProperty("signKeyPassphrase") ?: error("Parameter `signKeyPassphrase` not found")
+            val signKeyPrivate = project.findProperty("signKeyPrivate") as? String
+                ?: error("Parameter `signKeyPrivate` not found")
+            val signKeyPassphrase = project.findProperty("signKeyPassphrase") as? String
+                ?: error("Parameter `signKeyPassphrase` not found")
             useInMemoryPgpKeys(signKeyId, signKeyPrivate, signKeyPassphrase)
         } else {
             useGpgCmd()

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

@@ -15,10 +15,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.CodegenTestFiles
 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.config.languageVersionSettings
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
@@ -26,11 +23,11 @@ import org.jetbrains.kotlin.test.*
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.model.DependencyKind
 import org.jetbrains.kotlin.test.model.FrontendKinds
-import org.jetbrains.kotlin.test.model.ResultingArtifact
 import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
 import org.jetbrains.kotlin.test.services.*
 import org.jetbrains.kotlin.test.services.configuration.CommonEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator
+import org.jetbrains.kotlin.test.services.impl.BackendKindExtractorImpl
 import org.jetbrains.kotlin.test.services.impl.TemporaryDirectoryManagerImpl
 import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsSourceFilesProvider
 import org.jetbrains.kotlin.test.services.sourceProviders.CodegenHelpersSourceFilesProvider
@@ -385,7 +382,6 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 "test${testDataFile.nameWithoutExtension.replaceFirstChar(Char::uppercaseChar)}",
                 emptySet()
             )
-            startingArtifactFactory = { ResultingArtifact.Source() }
         }.build(testDataFile.path)
     }
 
@@ -410,6 +406,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
 
         assertions = JUnit5Assertions
         useAdditionalService<TemporaryDirectoryManager>(::TemporaryDirectoryManagerImpl)
+        useAdditionalService<BackendKindExtractor>(::BackendKindExtractorImpl)
         useSourcePreprocessor(*AbstractKotlinCompilerTest.defaultPreprocessors.toTypedArray())
         useDirectives(*AbstractKotlinCompilerTest.defaultDirectiveContainers.toTypedArray())
     }

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

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.name.SpecialNames
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 
@@ -26,7 +26,7 @@ class AccessorForConstructorDescriptor(
     containingDeclaration: DeclarationDescriptor,
     override val superCallTarget: ClassDescriptor?,
     override val accessorKind: AccessorKind
-) : AbstractAccessorForFunctionDescriptor(containingDeclaration, SpecialNames.INIT),
+) : AbstractAccessorForFunctionDescriptor(containingDeclaration, Name.special("<init>")),
     ClassConstructorDescriptor,
     AccessorForCallableDescriptor<ConstructorDescriptor> {
 

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

@@ -87,7 +87,7 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
             paramTypes.add(type)
             paramSlots += type.size
             template.append("\u0001")
-            if (paramSlots >= 199) {
+            if (paramSlots >= 200) {
                 // Concatenate current arguments into string
                 // because of `StringConcatFactory` limitation add use it as new argument for further processing:
                 // "The number of parameter slots in {@code concatType} is less than or equal to 200"
@@ -166,4 +166,4 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
             StringConcatGenerator(state.runtimeStringConcat, mv)
 
     }
-}
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.stubs.KotlinFileStub;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -299,7 +298,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
 
     private String getName(ClassDescriptor classDescriptor) {
         String base = peekFromStack(nameStack);
-        Name descriptorName = SpecialNames.safeIdentifier(classDescriptor.getName());
+        Name descriptorName = safeIdentifier(classDescriptor.getName());
         if (DescriptorUtils.isTopLevelDeclaration(classDescriptor)) {
             return base.isEmpty() ? descriptorName.asString() : base + '/' + descriptorName;
         }

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

@@ -1288,8 +1288,8 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
     fun nextLabel(node: AbstractInsnNode?): LabelNode? {
         var current = node
         while (current != null) {
-            if (current is LabelNode) return current as LabelNode
-            current = current!!.next
+            if (current is LabelNode) return current
+            current = current.next
         }
         return null
     }
@@ -1302,8 +1302,6 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
         oldLvt += record
     }
     method.localVariables.clear()
-
-    val oldLvtNodeToLatestNewLvtNode = mutableMapOf<LocalVariableNode, LocalVariableNode>()
     // Skip `this` for suspend lambda
     val start = if (isForNamedFunction) 0 else 1
     for (variableIndex in start until method.maxLocals) {
@@ -1343,41 +1341,33 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
                 val endLabel = nextLabel(insn.next)?.let { min(lvtRecord.end, it) } ?: lvtRecord.end
                 // startLabel can be null in case of parameters
                 @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
-
-                // Attempt to extend existing local variable node corresponding to the record in
-                // the original local variable table, if there is no back-edge
-                val recordToExtend: LocalVariableNode? = oldLvtNodeToLatestNewLvtNode[lvtRecord]
-                var recordExtended = false
-                if (recordToExtend != null) {
-                    var hasBackEdgeOrStore = false
-                    var current: AbstractInsnNode? = recordToExtend.end
-                    while (current != null && current != endLabel) {
-                        if (current is JumpInsnNode) {
-                            if (method.instructions.indexOf((current as JumpInsnNode).label) < method.instructions.indexOf(current)) {
-                                hasBackEdgeOrStore = true
-                                break
-                            }
-                        }
-                        if (current!!.isStoreOperation() && (current as VarInsnNode).`var` == recordToExtend.index) {
-                            hasBackEdgeOrStore = true
-                            break
-                        }
-                        current = current!!.next
-                    }
-                    if (!hasBackEdgeOrStore) {
-                        recordToExtend.end = endLabel
-                        recordExtended = true
-                    }
-                }
-                if (!recordExtended) {
-                    val node = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
-                    method.localVariables.add(node)
-                    oldLvtNodeToLatestNewLvtNode[lvtRecord] = node
-                }
+                val node = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
+                method.localVariables.add(node)
             }
         }
     }
 
+    // Merge consequent LVT records, otherwise, atomicfu goes crazy (KT-47749)
+    val toRemove = arrayListOf<LocalVariableNode>()
+    val sortedLVT = method.localVariables.sortedBy { method.instructions.indexOf(it.start) }
+    for (i in sortedLVT.indices) {
+        var endIndex = method.instructions.indexOf(sortedLVT[i].end)
+        for (j in (i + 1) until sortedLVT.size) {
+            val startIndex = method.instructions.indexOf(sortedLVT[j].start)
+            if (endIndex < startIndex) break
+            if (endIndex != startIndex ||
+                sortedLVT[i].index != sortedLVT[j].index ||
+                sortedLVT[i].name != sortedLVT[j].name ||
+                sortedLVT[i].desc != sortedLVT[j].desc
+            ) continue
+            sortedLVT[i].end = sortedLVT[j].end
+            endIndex = method.instructions.indexOf(sortedLVT[j].end)
+            toRemove += sortedLVT[j]
+        }
+    }
+
+    method.localVariables.removeAll(toRemove)
+
     for (variable in oldLvt) {
         // $continuation and $result are dead, but they are used by debugger, as well as fake inliner variables
         // For example, $continuation is used to create async stack trace

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

@@ -73,8 +73,8 @@ import kotlin.math.max
  *   - restore constructor arguments
  */
 class UninitializedStoresProcessor(
-    private val methodNode: MethodNode,
-    private val shouldPreserveClassInitialization: Boolean
+        private val methodNode: MethodNode,
+        private val shouldPreserveClassInitialization: Boolean
 ) {
     // <init> method is "special", because it will invoke <init> from this class or from a base class for #0
     //
@@ -87,10 +87,10 @@ class UninitializedStoresProcessor(
     fun run() {
         val interpreter = UninitializedNewValueMarkerInterpreter(methodNode.instructions)
 
-        if (methodNode.instructions.toArray().none { it.opcode == Opcodes.NEW })
-            return
-
-        val frames = CustomFramesMethodAnalyzer("fake", methodNode, interpreter, this::UninitializedNewValueFrame).analyze()
+        val frames = CustomFramesMethodAnalyzer(
+                "fake", methodNode, interpreter,
+                this::UninitializedNewValueFrame
+        ).analyze()
 
         interpreter.analyzePopInstructions(frames)
 
@@ -115,12 +115,12 @@ class UninitializedStoresProcessor(
                     //      POP
                     val typeNameForClass = newInsn.desc.replace('/', '.')
                     insertBefore(newInsn, LdcInsnNode(typeNameForClass))
-                    insertBefore(
-                        newInsn,
-                        MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false)
-                    )
+                    insertBefore(newInsn, MethodInsnNode(
+                            Opcodes.INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false
+                    ))
                     set(newInsn, InsnNode(Opcodes.POP))
-                } else {
+                }
+                else {
                     remove(newInsn)
                 }
             }
@@ -138,7 +138,10 @@ class UninitializedStoresProcessor(
             }
             methodNode.maxLocals = max(methodNode.maxLocals, nextVarIndex)
 
-            methodNode.instructions.insertBefore(insn, insnListOf(TypeInsnNode(Opcodes.NEW, newInsn.desc), InsnNode(Opcodes.DUP)))
+            methodNode.instructions.insertBefore(insn, insnListOf(
+                    TypeInsnNode(Opcodes.NEW, newInsn.desc),
+                    InsnNode(Opcodes.DUP)
+            ))
 
             for (type in storedTypes.reversed()) {
                 nextVarIndex -= type.size
@@ -171,11 +174,11 @@ class UninitializedStoresProcessor(
 
         assert(insn.opcode == Opcodes.INVOKESPECIAL) { "Expected opcode Opcodes.INVOKESPECIAL for <init>, but ${insn.opcode} found" }
         val paramsCountIncludingReceiver = Type.getArgumentTypes((insn as MethodInsnNode).desc).size + 1
-        val newValue = peek(paramsCountIncludingReceiver) as? UninitializedNewValue
-            ?: if (isInSpecialMethod)
-                return null
-            else
-                error("Expected value generated with NEW")
+        val newValue = peek(paramsCountIncludingReceiver) as? UninitializedNewValue ?:
+                       if (isInSpecialMethod)
+                           return null
+                       else
+                           error("Expected value generated with NEW")
 
         assert(peek(paramsCountIncludingReceiver - 1) is UninitializedNewValue) {
             "Next value after NEW should be one generated by DUP"
@@ -185,8 +188,8 @@ class UninitializedStoresProcessor(
     }
 
     private class UninitializedNewValue(
-        val newInsn: TypeInsnNode,
-        val internalName: String
+            val newInsn: TypeInsnNode,
+            val internalName: String
     ) : StrictBasicValue(Type.getObjectType(internalName)) {
         override fun toString() = "UninitializedNewValue(internalName='$internalName')"
     }
@@ -233,8 +236,7 @@ class UninitializedStoresProcessor(
 
         private fun checkUninitializedObjectCopy(newInsn: TypeInsnNode, usageInsn: AbstractInsnNode) {
             when (usageInsn.opcode) {
-                Opcodes.DUP, Opcodes.ASTORE, Opcodes.ALOAD -> {
-                }
+                Opcodes.DUP, Opcodes.ASTORE, Opcodes.ALOAD -> {}
                 else -> error("Unexpected copy instruction for ${newInsn.debugText}: ${usageInsn.debugText}")
             }
         }

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

@@ -320,8 +320,7 @@ class AnonymousObjectTransformer(
                 inliningContext.callSiteInfo.isInlineOrInsideInline,
                 inliningContext.callSiteInfo.file,
                 inliningContext.callSiteInfo.lineNumber
-            ),
-            null
+            ), null
         ).doInline(deferringVisitor, LocalVarRemapper(parameters, 0), false, mapOf())
         reifiedTypeParametersUsages?.let(result.reifiedTypeParametersUsages::mergeAll)
         deferringVisitor.visitMaxs(-1, -1)

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

@@ -187,9 +187,6 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
                 val splitBy = SimpleInterval(start.info as LabelNode, extension.finallyIntervalEnd)
                 processor.tryBlocksMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true)
                 processor.localVarsMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true)
-                finallyNode.localVariables.forEach {
-                    processor.localVarsMetaInfo.addNewInterval(LocalVarNodeWrapper(it))
-                }
             }
 
             curInstr = curInstr.next

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

@@ -13,8 +13,12 @@ import org.jetbrains.kotlin.codegen.inline.coroutines.markNoinlineLambdaIfSuspen
 import org.jetbrains.kotlin.codegen.inline.coroutines.surroundInvokesWithSuspendMarkersIfNeeded
 import org.jetbrains.kotlin.codegen.optimization.ApiVersionCallsPreprocessingMethodTransformer
 import org.jetbrains.kotlin.codegen.optimization.FixStackWithLabelNormalizationMethodTransformer
-import org.jetbrains.kotlin.codegen.optimization.common.*
-import org.jetbrains.kotlin.codegen.optimization.fixStack.*
+import org.jetbrains.kotlin.codegen.optimization.common.ControlFlowGraph
+import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
+import org.jetbrains.kotlin.codegen.optimization.common.asSequence
+import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
+import org.jetbrains.kotlin.codegen.optimization.fixStack.peek
+import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
 import org.jetbrains.kotlin.config.LanguageFeature
@@ -32,6 +36,8 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.commons.LocalVariablesSorter
 import org.jetbrains.org.objectweb.asm.commons.MethodRemapper
 import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.util.Printer
 import java.util.*
@@ -51,10 +57,8 @@ class MethodInliner(
 ) {
     private val languageVersionSettings = inliningContext.state.languageVersionSettings
     private val invokeCalls = ArrayList<InvokeCall>()
-
     //keeps order
     private val transformations = ArrayList<TransformationInfo>()
-
     //current state
     private val currentTypeMapping = HashMap<String, String?>()
     private val result = InlineResult.create()
@@ -269,8 +273,7 @@ class MethodInliner(
 
                     val varRemapper = LocalVarRemapper(lambdaParameters, valueParamShift)
                     //TODO add skipped this and receiver
-                    val lambdaResult =
-                        inliner.doInline(localVariablesSorter, varRemapper, true, info.returnLabels, invokeCall.finallyDepthShift)
+                    val lambdaResult = inliner.doInline(localVariablesSorter, varRemapper, true, info.returnLabels, invokeCall.finallyDepthShift)
                     result.mergeWithNotChangeInfo(lambdaResult)
                     result.reifiedTypeParametersUsages.mergeAll(lambdaResult.reifiedTypeParametersUsages)
                     result.reifiedTypeParametersUsages.mergeAll(info.reifiedTypeParametersUsages)
@@ -300,7 +303,7 @@ class MethodInliner(
                             } else capturedParamDesc
                             visitFieldInsn(
                                 Opcodes.GETSTATIC, realDesc.containingLambdaName,
-                                foldName(realDesc.fieldName), realDesc.type.descriptor
+                                FieldRemapper.foldName(realDesc.fieldName), realDesc.type.descriptor
                             )
                         }
                         super.visitMethodInsn(opcode, info.newClassName, name, info.newConstructorDescriptor, itf)
@@ -438,7 +441,7 @@ class MethodInliner(
                         else -> ""
                     }
 
-                    val varName = if (varSuffix.isNotEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
+                    val varName = if (!varSuffix.isEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
                     super.visitLocalVariable(varName + varSuffix, desc, signature, start, end, getNewIndex(index))
                 }
             }
@@ -530,37 +533,33 @@ class MethodInliner(
                     cur.opcode == Opcodes.GETSTATIC -> {
                         val fieldInsnNode = cur as FieldInsnNode?
                         val className = fieldInsnNode!!.owner
-                        when {
-                            isAnonymousSingletonLoad(className, fieldInsnNode.name) -> {
-                                recordTransformation(
-                                    AnonymousObjectTransformationInfo(
-                                        className, awaitClassReification, isAlreadyRegenerated(className), true,
-                                        inliningContext.nameGenerator
-                                    )
+                        if (isAnonymousSingletonLoad(className, fieldInsnNode.name)) {
+                            recordTransformation(
+                                AnonymousObjectTransformationInfo(
+                                    className, awaitClassReification, isAlreadyRegenerated(className), true,
+                                    inliningContext.nameGenerator
                                 )
-                                awaitClassReification = false
-                            }
-                            isWhenMappingAccess(className, fieldInsnNode.name) -> {
-                                recordTransformation(
-                                    WhenMappingTransformationInfo(
-                                        className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
-                                    )
+                            )
+                            awaitClassReification = false
+                        } else if (isWhenMappingAccess(className, fieldInsnNode.name)) {
+                            recordTransformation(
+                                WhenMappingTransformationInfo(
+                                    className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
                                 )
-                            }
-                            fieldInsnNode.isCheckAssertionsStatus() -> {
-                                fieldInsnNode.owner = inlineCallSiteInfo.ownerClassName
-                                when {
-                                    // In inline function itself:
-                                    inliningContext.parent == null -> inliningContext
-                                    // In method of regenerated object - field should already exist:
-                                    inliningContext.parent is RegeneratedClassContext -> inliningContext.parent
-                                    // In lambda inlined into the root function:
-                                    inliningContext.parent.parent == null -> inliningContext.parent
-                                    // In lambda inlined into a method of a regenerated object:
-                                    else -> inliningContext.parent.parent as? RegeneratedClassContext
-                                        ?: throw AssertionError("couldn't find class for \$assertionsDisabled (context = $inliningContext)")
-                                }.generateAssertField = true
-                            }
+                            )
+                        } else if (fieldInsnNode.isCheckAssertionsStatus()) {
+                            fieldInsnNode.owner = inlineCallSiteInfo.ownerClassName
+                            when {
+                                // In inline function itself:
+                                inliningContext.parent == null -> inliningContext
+                                // In method of regenerated object - field should already exist:
+                                inliningContext.parent is RegeneratedClassContext -> inliningContext.parent
+                                // In lambda inlined into the root function:
+                                inliningContext.parent.parent == null -> inliningContext.parent
+                                // In lambda inlined into a method of a regenerated object:
+                                else -> inliningContext.parent.parent as? RegeneratedClassContext
+                                    ?: throw AssertionError("couldn't find class for \$assertionsDisabled (context = $inliningContext)")
+                            }.generateAssertField = true
                         }
                     }
 
@@ -589,7 +588,7 @@ class MethodInliner(
                                 assert(lambdaInfo.lambdaClassType.internalName == nodeRemapper.originalLambdaInternalName) {
                                     "Wrong bytecode template for contract template: ${lambdaInfo.lambdaClassType.internalName} != ${nodeRemapper.originalLambdaInternalName}"
                                 }
-                                fieldInsn.name = foldName(fieldInsn.name)
+                                fieldInsn.name = FieldRemapper.foldName(fieldInsn.name)
                                 fieldInsn.opcode = Opcodes.PUTSTATIC
                                 toDelete.addAll(stackTransformations)
                             }
@@ -743,9 +742,7 @@ class MethodInliner(
             ApiVersionCallsPreprocessingMethodTransformer(targetApiVersion).transform("fake", node)
         }
 
-        removeFakeVariablesInitializationIfPresent(node)
-
-        val frames = FastStackAnalyzer("<fake>", node, FixStackInterpreter()).analyze()
+        val frames = analyzeMethodNodeWithInterpreter(node, BasicInterpreter())
 
         val localReturnsNormalizer = LocalReturnsNormalizer()
 
@@ -767,73 +764,6 @@ class MethodInliner(
         localReturnsNormalizer.transform(node)
     }
 
-    private fun removeFakeVariablesInitializationIfPresent(node: MethodNode) {
-        // Before 1.6, we generated fake variable initialization instructions
-        //      ICONST_0
-        //      ISTORE x
-        // for all inline functions. Original intent was to mark inline function body for the debugger with corresponding LVT entry.
-        // However, for @InlineOnly functions corresponding LVT entries were not copied (assuming that nobody is actually debugging
-        // @InlineOnly functions).
-        // Since 1.6, we no longer generate fake variables for @InlineOnly functions
-        // Here we erase fake variable initialization for @InlineOnly functions inlined into existing bytecode (e.g., inline function
-        // inside third-party library).
-        // We consider a sequence of instructions 'ICONST_0; ISTORE x' a fake variable initialization if the corresponding variable 'x'
-        // is not used in the bytecode (see below).
-
-        val insnArray = node.instructions.toArray()
-
-        // Very conservative variable usage check.
-        // Here we look at integer variables only (this includes integral primitive types: byte, char, short, boolean).
-        // Variable is considered "used" if:
-        //  - it's loaded with ILOAD instruction
-        //  - it's incremented with IINC instruction
-        //  - there's a local variable table entry for this variable
-        val usedIntegerVar = BooleanArray(node.maxLocals)
-        for (insn in insnArray) {
-            if (insn.type == AbstractInsnNode.VAR_INSN && insn.opcode == Opcodes.ILOAD) {
-                usedIntegerVar[(insn as VarInsnNode).`var`] = true
-            } else if (insn.type == AbstractInsnNode.IINC_INSN) {
-                usedIntegerVar[(insn as IincInsnNode).`var`] = true
-            }
-        }
-        for (localVariable in node.localVariables) {
-            val d0 = localVariable.desc[0]
-            // byte || char || short || int || boolean
-            if (d0 == 'B' || d0 == 'C' || d0 == 'S' || d0 == 'I' || d0 == 'Z') {
-                usedIntegerVar[localVariable.index] = true
-            }
-        }
-
-        // Looking for sequences of instructions:
-        //  p0: ICONST_0
-        //  p1: ISTORE x
-        //  p2: <label>
-        // If variable 'x' is not "used" (see above), remove p0 and p1 instructions.
-        var changes = false
-        for (p0 in insnArray) {
-            if (p0.opcode != Opcodes.ICONST_0) continue
-
-            val p1 = p0.next ?: break
-            if (p1.opcode != Opcodes.ISTORE) continue
-
-            val p2 = p1.next ?: break
-            if (p2.type != AbstractInsnNode.LABEL) continue
-
-            val varIndex = (p1 as VarInsnNode).`var`
-            if (!usedIntegerVar[varIndex]) {
-                changes = true
-                node.instructions.remove(p0)
-                node.instructions.remove(p1)
-            }
-        }
-
-        if (changes) {
-            // If we removed some instructions, some TCBs could (in theory) become empty.
-            // Remove empty TCBs if there are any.
-            node.removeEmptyCatchBlocks()
-        }
-    }
-
     private fun isAnonymousClassThatMustBeRegenerated(type: Type?): Boolean {
         if (type == null || type.sort != Type.OBJECT) return false
         return inliningContext.isRegeneratedAnonymousObject(type.internalName)
@@ -901,9 +831,9 @@ class MethodInliner(
         if (inliningContext.isInliningLambda && inliningContext.lambdaInfo is IrExpressionLambda && !inliningContext.parent!!.isInliningLambda) {
             val capturedVars = inliningContext.lambdaInfo.capturedVars
             var offset = parameters.realParametersSizeOnStack
-            val map = capturedVars.associate {
+            val map = capturedVars.map {
                 offset to it.also { offset += it.type.size }
-            }
+            }.toMap()
 
             var cur: AbstractInsnNode? = node.instructions.first
             while (cur != null) {
@@ -948,7 +878,6 @@ class MethodInliner(
         }
     }
 
-    @Suppress("SameParameterValue")
     private fun wrapException(originalException: Throwable, node: MethodNode, errorSuffix: String): RuntimeException {
         return if (originalException is InlineException) {
             InlineException("$errorPrefix: $errorSuffix", originalException)
@@ -961,7 +890,7 @@ class MethodInliner(
         private class LocalReturn(
             private val returnInsn: AbstractInsnNode,
             private val insertBeforeInsn: AbstractInsnNode,
-            private val frame: Frame<FixStackValue>
+            private val frame: Frame<BasicValue>
         ) {
 
             fun transform(insnList: InsnList, returnVariableIndex: Int) {
@@ -972,19 +901,22 @@ class MethodInliner(
                 if (expectedStackSize == actualStackSize) return
 
                 var stackSize = actualStackSize
-                val topValue = frame.getStack(stackSize - 1)
                 if (isReturnWithValue) {
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.storeOpcode, returnVariableIndex))
+                    val storeOpcode = Opcodes.ISTORE + returnInsn.opcode - Opcodes.IRETURN
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(storeOpcode, returnVariableIndex))
                     stackSize--
                 }
 
                 while (stackSize > 0) {
-                    insnList.insertBefore(insertBeforeInsn, InsnNode(frame.getStack(stackSize - 1).popOpcode))
+                    val stackElementSize = frame.getStack(stackSize - 1).size
+                    val popOpcode = if (stackElementSize == 1) Opcodes.POP else Opcodes.POP2
+                    insnList.insertBefore(insertBeforeInsn, InsnNode(popOpcode))
                     stackSize--
                 }
 
                 if (isReturnWithValue) {
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.loadOpcode, returnVariableIndex))
+                    val loadOpcode = Opcodes.ILOAD + returnInsn.opcode - Opcodes.IRETURN
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(loadOpcode, returnVariableIndex))
                 }
             }
         }
@@ -994,10 +926,10 @@ class MethodInliner(
         private var returnVariableSize = 0
         private var returnOpcode = -1
 
-        fun addLocalReturnToTransform(
+        internal fun addLocalReturnToTransform(
             returnInsn: AbstractInsnNode,
             insertBeforeInsn: AbstractInsnNode,
-            sourceValueFrame: Frame<FixStackValue>
+            sourceValueFrame: Frame<BasicValue>
         ) {
             assert(isReturnOpcode(returnInsn.opcode)) { "return instruction expected" }
             assert(returnOpcode < 0 || returnOpcode == returnInsn.opcode) { "Return op should be " + Printer.OPCODES[returnOpcode] + ", got " + Printer.OPCODES[returnInsn.opcode] }
@@ -1006,7 +938,11 @@ class MethodInliner(
             localReturns.add(LocalReturn(returnInsn, insertBeforeInsn, sourceValueFrame))
 
             if (returnInsn.opcode != Opcodes.RETURN) {
-                returnVariableSize = if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) 2 else 1
+                returnVariableSize = if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) {
+                    2
+                } else {
+                    1
+                }
             }
         }
 

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
-import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -13,12 +12,12 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.*
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.TYPEOF_SUSPEND_TYPE
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.model.TypeParameterMarker
 import org.jetbrains.org.objectweb.asm.Type
@@ -73,14 +72,6 @@ class PsiInlineIntrinsicsSupport(
 
     override fun toKotlinType(type: KotlinType): KotlinType = type
 
-    override fun checkAnnotatedType(type: KotlinType) {
-        if (type.annotations.hasAnnotation(StandardNames.FqNames.extensionFunctionType)) {
-            state.diagnostics.report(TYPEOF_EXTENSION_FUNCTION_TYPE.on(reportErrorsOn))
-        } else if (type.annotations.any { it.fqName != JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION }) {
-            state.diagnostics.report(TYPEOF_ANNOTATED_TYPE.on(reportErrorsOn))
-        }
-    }
-
     override fun reportSuspendTypeUnsupported() {
         state.diagnostics.report(TYPEOF_SUSPEND_TYPE.on(reportErrorsOn))
     }

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

@@ -23,11 +23,13 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.ImportedFromObjectCallableDescriptor
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.isInlineClass
 import org.jetbrains.kotlin.resolve.jvm.annotations.isCallableMemberCompiledToJvmDefault
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
+import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import org.jetbrains.kotlin.types.expressions.LabelResolver
 import org.jetbrains.kotlin.utils.addIfNotNull

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

@@ -75,7 +75,6 @@ class ReifiedTypeInliner<KT : KotlinTypeMarker>(
 
         fun toKotlinType(type: KT): KotlinType
 
-        fun checkAnnotatedType(type: KT)
         fun reportSuspendTypeUnsupported()
         fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name)
     }

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

@@ -95,8 +95,6 @@ fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateTypeOf(
         intrinsicsSupport.reportSuspendTypeUnsupported()
     }
 
-    intrinsicsSupport.checkAnnotatedType(type)
-
     if (intrinsicsSupport.state.stableTypeOf) {
         if (intrinsicsSupport.isMutableCollectionType(type)) {
             v.invokestatic(REFLECTION, "mutableCollectionType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false)

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

@@ -17,13 +17,11 @@
 package org.jetbrains.kotlin.codegen.optimization
 
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicVerifier
 
-class MethodVerifier(private val checkPoint: String, private val generationState: GenerationState) : MethodTransformer() {
+class MethodVerifier(private val checkPoint: String) : MethodTransformer() {
     override fun transform(internalClassName: String, methodNode: MethodNode) {
-        if (!generationState.shouldValidateBytecode) return
         try {
             analyze(internalClassName, methodNode, BasicVerifier())
         } catch (e: Throwable) {

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

@@ -41,7 +41,7 @@ class OptimizationMethodVisitor(
 
     val normalizationMethodTransformer = CompositeMethodTransformer(
         FixStackWithLabelNormalizationMethodTransformer(),
-        MethodVerifier("AFTER mandatory stack transformations", generationState)
+        MethodVerifier("AFTER mandatory stack transformations")
     )
 
     val optimizationTransformer = CompositeMethodTransformer(
@@ -55,7 +55,7 @@ class OptimizationMethodVisitor(
         DeadCodeEliminationMethodTransformer(),
         RedundantGotoMethodTransformer(),
         RedundantNopsCleanupMethodTransformer(),
-        MethodVerifier("AFTER optimizations", generationState)
+        MethodVerifier("AFTER optimizations")
     )
 
     override fun performTransformations(methodNode: MethodNode) {
@@ -73,29 +73,24 @@ class OptimizationMethodVisitor(
 
     companion object {
         private const val MEMORY_LIMIT_BY_METHOD_MB = 50
-        private const val TRY_CATCH_BLOCKS_SOFT_LIMIT = 16
+        private const val TRY_CATCH_BLOCKS_LIMIT = 512
 
         fun canBeOptimized(node: MethodNode): Boolean {
-            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_SOFT_LIMIT) {
-                if (getTotalFramesWeight(getTotalTcbSize(node), node) > MEMORY_LIMIT_BY_METHOD_MB)
-                    return false
-            }
-            return getTotalFramesWeight(node.instructions.size(), node) < MEMORY_LIMIT_BY_METHOD_MB
+            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_LIMIT)
+                return false
+
+            val totalFramesSizeMb = node.instructions.size() * (node.maxLocals + node.maxStack) / (1024 * 1024)
+            return totalFramesSizeMb < MEMORY_LIMIT_BY_METHOD_MB
         }
 
         fun canBeOptimizedUsingSourceInterpreter(node: MethodNode): Boolean {
-            val methodSize = node.instructions.size()
-            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_SOFT_LIMIT) {
-                if (getTotalFramesWeight(getTotalTcbSize(node) * methodSize, node) > MEMORY_LIMIT_BY_METHOD_MB)
-                    return false
-            }
-            return getTotalFramesWeight(methodSize * methodSize, node) < MEMORY_LIMIT_BY_METHOD_MB
+            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_LIMIT)
+                return false
+
+            val frameSize = node.maxLocals + node.maxStack
+            val methodSize = node.instructions.size().toLong()
+            val totalFramesSizeMb = methodSize * methodSize * frameSize / (1024 * 1024)
+            return totalFramesSizeMb < MEMORY_LIMIT_BY_METHOD_MB
         }
-
-        private fun getTotalFramesWeight(size: Int, node: MethodNode) =
-            size.toLong() * (node.maxLocals + node.maxStack) / (1024 * 1024)
-
-        private fun getTotalTcbSize(node: MethodNode) =
-            node.tryCatchBlocks.sumOf { node.instructions.indexOf(it.end) - node.instructions.indexOf(it.start) }
     }
 }

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

@@ -56,7 +56,7 @@ class TaintedBoxedValue(private val boxedBasicValue: CleanBoxedValue) : BoxedBas
 
 
 class BoxedValueDescriptor(
-    boxedType: Type,
+    private val boxedType: Type,
     val boxingInsn: AbstractInsnNode,
     val progressionIterator: ProgressionIteratorBasicValue?,
     val generationState: GenerationState

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

@@ -38,10 +38,6 @@ import java.util.*
 class RedundantBoxingMethodTransformer(private val generationState: GenerationState) : MethodTransformer() {
 
     override fun transform(internalClassName: String, node: MethodNode) {
-        val insns = node.instructions.toArray()
-        if (insns.none { it.isBoxing(generationState) || it.isMethodInsnWith(Opcodes.INVOKEINTERFACE) { name == "next" } })
-            return
-
         val interpreter = RedundantBoxingInterpreter(node.instructions, generationState)
         val frames = analyze(internalClassName, node, interpreter)
 

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

@@ -33,6 +33,7 @@
 
 package org.jetbrains.kotlin.codegen.optimization.common
 
+import org.jetbrains.kotlin.codegen.inline.insnOpcodeText
 import org.jetbrains.kotlin.codegen.inline.insnText
 import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -44,7 +45,7 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.Value
 
 /**
- * @see org.jetbrains.kotlin.codegen.optimization.fixStack.FastStackAnalyzer
+ * @see FlexibleMethodAnalyzer
  */
 @Suppress("DuplicatedCode")
 open class FastMethodAnalyzer<V : Value>(
@@ -55,9 +56,34 @@ open class FastMethodAnalyzer<V : Value>(
     private val insnsArray = method.instructions.toArray()
     private val nInsns = method.instructions.size()
 
-    private val isMergeNode = BooleanArray(nInsns)
+    // Single Predecessor Block (SPB) is a continuous sequence of instructions { I1, ... In } such that
+    //  if I=insns[i] and J=insns[i+1] both belong to SPB,
+    //  then I is a single immediate predecessor of J in a complete method control flow graph
+    //  (including exception edges).
+    //
+    // Note that classic basic blocks are SPBs, but the opposite is not true:
+    // SPBs have single entry point, but can have multiple exit points
+    // (which lead to instructions not belonging to the given SPB).
+    // Example:
+    //      aload 1
+    //      dup
+    //      ifnull LA
+    //      invokevirtual foo()
+    //      dup
+    //      ifnull LB
+    //      invokevirtual bar()
+    //      goto LC
+    // is SPB (but not a basic block).
+    //
+    // For each J=insns[i+1] such that I=insns[i] belongs to the same SPB,
+    // data flow transfer function
+    //      Execute( J, Merge( { Out(K) | K <- Pred(J) } ) )
+    // is effectively
+    //      Execute( J, Out(I) ) )
+    // so, we don't need to merge frames for such I->J edges.
+    private val singlePredBlock = IntArray(nInsns)
 
-    private val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
+    val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
 
     private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
     private val queued = BooleanArray(nInsns)
@@ -71,13 +97,14 @@ open class FastMethodAnalyzer<V : Value>(
         if (nInsns == 0) return frames
 
         checkAssertions()
+
         computeExceptionHandlersForEachInsn(method)
-        initMergeNodes()
+
+        initSinglePredBlocks()
 
         val current = newFrame(method.maxLocals, method.maxStack)
         val handler = newFrame(method.maxLocals, method.maxStack)
-        initLocals(current)
-        mergeControlFlowEdge(0, current)
+        initControlFlowAnalysis(current, method, owner)
 
         while (top > 0) {
             val insn = queue[--top]
@@ -90,16 +117,16 @@ open class FastMethodAnalyzer<V : Value>(
                 val insnType = insnNode.type
 
                 if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) {
-                    mergeControlFlowEdge(insn + 1, f)
+                    visitNopInsn(f, insn)
                 } else {
                     current.init(f).execute(insnNode, interpreter)
                     when {
-                        insnType == AbstractInsnNode.JUMP_INSN ->
-                            visitJumpInsnNode(insnNode as JumpInsnNode, current, insn, insnOpcode)
-                        insnType == AbstractInsnNode.LOOKUPSWITCH_INSN ->
-                            visitLookupSwitchInsnNode(insnNode as LookupSwitchInsnNode, current)
-                        insnType == AbstractInsnNode.TABLESWITCH_INSN ->
-                            visitTableSwitchInsnNode(insnNode as TableSwitchInsnNode, current)
+                        insnNode is JumpInsnNode ->
+                            visitJumpInsnNode(insnNode, current, insn, insnOpcode)
+                        insnNode is LookupSwitchInsnNode ->
+                            visitLookupSwitchInsnNode(insnNode, current, insn)
+                        insnNode is TableSwitchInsnNode ->
+                            visitTableSwitchInsnNode(insnNode, current, insn)
                         insnOpcode != Opcodes.ATHROW && (insnOpcode < Opcodes.IRETURN || insnOpcode > Opcodes.RETURN) ->
                             visitOpInsn(current, insn)
                         else -> {
@@ -114,7 +141,7 @@ open class FastMethodAnalyzer<V : Value>(
                     handler.init(f)
                     handler.clearStack()
                     handler.push(interpreter.newValue(exnType))
-                    mergeControlFlowEdge(jump, handler)
+                    mergeControlFlowEdge(insn, jump, handler)
                 }
 
             } catch (e: AnalyzerException) {
@@ -128,56 +155,87 @@ open class FastMethodAnalyzer<V : Value>(
         return frames
     }
 
-    internal fun initLocals(current: Frame<V>) {
-        current.setReturn(interpreter.newValue(Type.getReturnType(method.desc)))
-        val args = Type.getArgumentTypes(method.desc)
-        var local = 0
-        if ((method.access and Opcodes.ACC_STATIC) == 0) {
-            val ctype = Type.getObjectType(owner)
-            current.setLocal(local++, interpreter.newValue(ctype))
-        }
-        for (arg in args) {
-            current.setLocal(local++, interpreter.newValue(arg))
-            if (arg.size == 2) {
-                current.setLocal(local++, interpreter.newValue(null))
-            }
-        }
-        while (local < method.maxLocals) {
-            current.setLocal(local++, interpreter.newValue(null))
-        }
-    }
-
     private fun AbstractInsnNode.indexOf() =
         method.instructions.indexOf(this)
 
-    private fun initMergeNodes() {
+    private fun initSinglePredBlocks() {
+        markSinglePredBlockEntries()
+        markSinglePredBlockBodies()
+    }
+
+    private fun markSinglePredBlockEntries() {
+        // Method entry point is SPB entry point.
+        var blockId = 0
+        singlePredBlock[0] = ++blockId
+
+        // Every jump target is SPB entry point.
         for (insn in insnsArray) {
-            when (insn.type) {
-                AbstractInsnNode.JUMP_INSN -> {
-                    val jumpInsn = insn as JumpInsnNode
-                    isMergeNode[jumpInsn.label.indexOf()] = true
-                }
-                AbstractInsnNode.LOOKUPSWITCH_INSN -> {
-                    val switchInsn = insn as LookupSwitchInsnNode
-                    isMergeNode[switchInsn.dflt.indexOf()] = true
-                    for (label in switchInsn.labels) {
-                        isMergeNode[label.indexOf()] = true
+            when (insn) {
+                is JumpInsnNode -> {
+                    val labelIndex = insn.label.indexOf()
+                    if (singlePredBlock[labelIndex] == 0) {
+                        singlePredBlock[labelIndex] = ++blockId
                     }
                 }
-                AbstractInsnNode.TABLESWITCH_INSN -> {
-                    val switchInsn = insn as TableSwitchInsnNode
-                    isMergeNode[switchInsn.dflt.indexOf()] = true
-                    for (label in switchInsn.labels) {
-                        isMergeNode[label.indexOf()] = true
+                is LookupSwitchInsnNode -> {
+                    insn.dflt?.let { dfltLabel ->
+                        val dfltIndex = dfltLabel.indexOf()
+                        if (singlePredBlock[dfltIndex] == 0) {
+                            singlePredBlock[dfltIndex] = ++blockId
+                        }
+                    }
+                    for (label in insn.labels) {
+                        val labelIndex = label.indexOf()
+                        if (singlePredBlock[labelIndex] == 0) {
+                            singlePredBlock[labelIndex] = ++blockId
+                        }
+                    }
+                }
+                is TableSwitchInsnNode -> {
+                    insn.dflt?.let { dfltLabel ->
+                        val dfltIndex = dfltLabel.indexOf()
+                        if (singlePredBlock[dfltIndex] == 0) {
+                            singlePredBlock[dfltIndex] = ++blockId
+                        }
+                    }
+                    for (label in insn.labels) {
+                        val labelIndex = label.indexOf()
+                        if (singlePredBlock[labelIndex] == 0) {
+                            singlePredBlock[labelIndex] = ++blockId
+                        }
                     }
                 }
             }
         }
+
+        // Every try-catch block handler entry point is SPB entry point
         for (tcb in method.tryCatchBlocks) {
-            isMergeNode[tcb.handler.indexOf()] = true
+            val handlerIndex = tcb.handler.indexOf()
+            if (singlePredBlock[handlerIndex] == 0) {
+                singlePredBlock[handlerIndex] = ++blockId
+            }
         }
     }
 
+    private fun markSinglePredBlockBodies() {
+        var current = 0
+        for ((i, insn) in insnsArray.withIndex()) {
+            if (singlePredBlock[i] == 0) {
+                singlePredBlock[i] = current
+            } else {
+                // Entered a new SPB.
+                current = singlePredBlock[i]
+            }
+
+            // GOTO, ATHROW, *RETURN instructions terminate current SPB.
+            when (insn.opcode) {
+                Opcodes.GOTO,
+                Opcodes.ATHROW,
+                in Opcodes.IRETURN..Opcodes.RETURN ->
+                    current = 0
+            }
+        }
+    }
 
     fun getFrame(insn: AbstractInsnNode): Frame<V>? =
         frames[insn.indexOf()]
@@ -188,33 +246,62 @@ open class FastMethodAnalyzer<V : Value>(
     }
 
     private fun visitOpInsn(current: Frame<V>, insn: Int) {
-        mergeControlFlowEdge(insn + 1, current)
+        mergeControlFlowEdge(insn, insn + 1, current)
     }
 
-    private fun visitTableSwitchInsnNode(insnNode: TableSwitchInsnNode, current: Frame<V>) {
-        mergeControlFlowEdge(insnNode.dflt.indexOf(), current)
+    private fun visitTableSwitchInsnNode(insnNode: TableSwitchInsnNode, current: Frame<V>, insn: Int) {
+        var jump = insnNode.dflt.indexOf()
+        mergeControlFlowEdge(insn, jump, current)
         // In most cases order of visiting switch labels should not matter
         // The only one is a tableswitch being added in the beginning of coroutine method, these switch' labels may lead
         // in the middle of try/catch block, and FixStackAnalyzer is not ready for this (trying to restore stack before it was saved)
         // So we just fix the order of labels being traversed: the first one should be one at the method beginning
         // Using 'reversed' is because nodes are processed in LIFO order
-        for (label in insnNode.labels.asReversed()) {
-            mergeControlFlowEdge(label.indexOf(), current)
+        for (label in insnNode.labels.reversed()) {
+            jump = label.indexOf()
+            mergeControlFlowEdge(insn, jump, current)
         }
     }
 
-    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>) {
-        mergeControlFlowEdge(insnNode.dflt.indexOf(), current)
+    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
+        var jump = insnNode.dflt.indexOf()
+        mergeControlFlowEdge(insn, jump, current)
         for (label in insnNode.labels) {
-            mergeControlFlowEdge(label.indexOf(), current)
+            jump = label.indexOf()
+            mergeControlFlowEdge(insn, jump, current)
         }
     }
 
     private fun visitJumpInsnNode(insnNode: JumpInsnNode, current: Frame<V>, insn: Int, insnOpcode: Int) {
         if (insnOpcode != Opcodes.GOTO) {
-            mergeControlFlowEdge(insn + 1, current)
+            mergeControlFlowEdge(insn, insn + 1, current)
         }
-        mergeControlFlowEdge(insnNode.label.indexOf(), current)
+        val jump = insnNode.label.indexOf()
+        mergeControlFlowEdge(insn, jump, current)
+    }
+
+    private fun visitNopInsn(f: Frame<V>, insn: Int) {
+        mergeControlFlowEdge(insn, insn + 1, f)
+    }
+
+    private fun initControlFlowAnalysis(current: Frame<V>, m: MethodNode, owner: String) {
+        current.setReturn(interpreter.newValue(Type.getReturnType(m.desc)))
+        val args = Type.getArgumentTypes(m.desc)
+        var local = 0
+        if ((m.access and Opcodes.ACC_STATIC) == 0) {
+            val ctype = Type.getObjectType(owner)
+            current.setLocal(local++, interpreter.newValue(ctype))
+        }
+        for (arg in args) {
+            current.setLocal(local++, interpreter.newValue(arg))
+            if (arg.size == 2) {
+                current.setLocal(local++, interpreter.newValue(null))
+            }
+        }
+        while (local < m.maxLocals) {
+            current.setLocal(local++, interpreter.newValue(null))
+        }
+        mergeControlFlowEdge(0, 0, current)
     }
 
     private fun computeExceptionHandlersForEachInsn(m: MethodNode) {
@@ -233,14 +320,15 @@ open class FastMethodAnalyzer<V : Value>(
         }
     }
 
-    private fun mergeControlFlowEdge(dest: Int, frame: Frame<V>) {
+    private fun mergeControlFlowEdge(src: Int, dest: Int, frame: Frame<V>) {
         val oldFrame = frames[dest]
         val changes = when {
             oldFrame == null -> {
                 frames[dest] = newFrame(frame.locals, frame.maxStackSize).apply { init(frame) }
                 true
             }
-            !isMergeNode[dest] -> {
+            dest == src + 1 && singlePredBlock[src] == singlePredBlock[dest] -> {
+                // Forward jump within a single predecessor block, no need to merge.
                 oldFrame.init(frame)
                 true
             }
@@ -252,4 +340,35 @@ open class FastMethodAnalyzer<V : Value>(
             queue[top++] = dest
         }
     }
+
+    @Suppress("unused")
+    private fun dumpBlocksInfo() {
+        fun LabelNode?.labelText() =
+            if (this != null) "L#${indexOf()}" else "L<null>"
+
+        println("===== ${method.name} ${method.signature} ======")
+        for ((i, insn) in insnsArray.withIndex()) {
+            val insnText = when (insn) {
+                is LabelNode ->
+                    "L#$i"
+                is JumpInsnNode ->
+                    "${insn.insnOpcodeText} ${insn.label.labelText()}"
+                is TableSwitchInsnNode ->
+                    "${insn.insnOpcodeText} min=${insn.min} max=${insn.max} \n\t\t\t" +
+                            "[${insn.labels.joinToString { it.labelText() }}] \n\t\t\t" +
+                            "dflt:${insn.dflt.labelText()}"
+                is LookupSwitchInsnNode ->
+                    "${insn.insnOpcodeText} \n\t\t\t" +
+                            "[${insn.keys.zip(insn.labels).joinToString { (key, label) -> "$key: ${label.labelText()}"}}] \n\t\t\t" +
+                            "dflt:${insn.dflt.labelText()}"
+                else ->
+                    insn.insnText
+            }
+            println("$i\t${singlePredBlock[i]}\t$insnText")
+        }
+        for (tcb in method.tryCatchBlocks) {
+            println("\tTCB start:${tcb.start.labelText()} end:${tcb.end.labelText()} handler:${tcb.handler.labelText()}")
+        }
+        println()
+    }
 }

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

@@ -0,0 +1,346 @@
+/*
+ * Copyright 2010-2015 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.
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+package org.jetbrains.kotlin.codegen.optimization.common
+
+import org.jetbrains.kotlin.codegen.inline.insnText
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
+import org.jetbrains.org.objectweb.asm.tree.analysis.Value
+
+/**
+ * This class is a modified version of `org.objectweb.asm.tree.analysis.Analyzer`
+ *
+ * @see FastMethodAnalyzer
+ *
+ * @author Eric Bruneton
+ * @author Dmitry Petrov
+ */
+@Suppress("DuplicatedCode")
+open class FlexibleMethodAnalyzer<V : Value>(
+    private val owner: String,
+    val method: MethodNode,
+    protected val interpreter: Interpreter<V>
+) {
+    protected val insnsArray: Array<AbstractInsnNode> = method.instructions.toArray()
+    private val nInsns = insnsArray.size
+
+    val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
+
+    private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
+    private val queued = BooleanArray(nInsns)
+    private val queue = IntArray(nInsns)
+    private var top = 0
+
+    private val singlePredBlock = IntArray(nInsns)
+
+    protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
+
+    protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
+
+    protected open fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean = true
+
+    fun analyze(): Array<Frame<V>?> {
+        if (nInsns == 0) return frames
+
+        checkAssertions()
+
+        computeExceptionHandlersForEachInsn()
+
+        initSinglePredBlocks()
+
+        val current = newFrame(method.maxLocals, method.maxStack)
+        val handler = newFrame(method.maxLocals, method.maxStack)
+        initControlFlowAnalysis(current, method, owner)
+
+        while (top > 0) {
+            val insn = queue[--top]
+            val f = frames[insn]!!
+            queued[insn] = false
+
+            val insnNode = method.instructions[insn]
+            try {
+                val insnOpcode = insnNode.opcode
+                val insnType = insnNode.type
+
+                if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) {
+                    visitNopInsn(f, insn)
+                } else {
+                    current.init(f).execute(insnNode, interpreter)
+
+                    when {
+                        insnNode is JumpInsnNode ->
+                            visitJumpInsnNode(insnNode, current, insn, insnOpcode)
+                        insnNode is LookupSwitchInsnNode ->
+                            visitLookupSwitchInsnNode(insnNode, current, insn)
+                        insnNode is TableSwitchInsnNode ->
+                            visitTableSwitchInsnNode(insnNode, current, insn)
+                        insnOpcode != Opcodes.ATHROW && (insnOpcode < Opcodes.IRETURN || insnOpcode > Opcodes.RETURN) ->
+                            visitOpInsn(current, insn)
+                        else -> {
+                        }
+                    }
+                }
+
+                handlers[insn]?.forEach { tcb ->
+                    val exnType = Type.getObjectType(tcb.type ?: "java/lang/Throwable")
+                    val jump = tcb.handler.indexOf()
+                    if (visitControlFlowExceptionEdge(insn, tcb.handler.indexOf())) {
+                        handler.init(f)
+                        handler.clearStack()
+                        handler.push(interpreter.newValue(exnType))
+                        mergeControlFlowEdge(insn, jump, handler)
+                    }
+                }
+
+            } catch (e: AnalyzerException) {
+                throw AnalyzerException(e.node, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
+            } catch (e: Exception) {
+                throw AnalyzerException(insnNode, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
+            }
+
+        }
+
+        return frames
+    }
+
+    private fun initSinglePredBlocks() {
+        markSinglePredBlockEntries()
+        markSinglePredBlockBodies()
+    }
+
+    private fun markSinglePredBlockEntries() {
+        // Method entry point is SPB entry point.
+        var blockId = 0
+        singlePredBlock[0] = ++blockId
+
+        // Every jump target is SPB entry point.
+        for (insn in insnsArray) {
+            when (insn) {
+                is JumpInsnNode -> {
+                    val labelIndex = insn.label.indexOf()
+                    if (singlePredBlock[labelIndex] == 0) {
+                        singlePredBlock[labelIndex] = ++blockId
+                    }
+                }
+                is LookupSwitchInsnNode -> {
+                    insn.dflt?.let { dfltLabel ->
+                        val dfltIndex = dfltLabel.indexOf()
+                        if (singlePredBlock[dfltIndex] == 0) {
+                            singlePredBlock[dfltIndex] = ++blockId
+                        }
+                    }
+                    for (label in insn.labels) {
+                        val labelIndex = label.indexOf()
+                        if (singlePredBlock[labelIndex] == 0) {
+                            singlePredBlock[labelIndex] = ++blockId
+                        }
+                    }
+                }
+                is TableSwitchInsnNode -> {
+                    insn.dflt?.let { dfltLabel ->
+                        val dfltIndex = dfltLabel.indexOf()
+                        if (singlePredBlock[dfltIndex] == 0) {
+                            singlePredBlock[dfltIndex] = ++blockId
+                        }
+                    }
+                    for (label in insn.labels) {
+                        val labelIndex = label.indexOf()
+                        if (singlePredBlock[labelIndex] == 0) {
+                            singlePredBlock[labelIndex] = ++blockId
+                        }
+                    }
+                }
+            }
+        }
+
+        // Every try-catch block handler entry point is SPB entry point
+        for (tcb in method.tryCatchBlocks) {
+            val handlerIndex = tcb.handler.indexOf()
+            if (singlePredBlock[handlerIndex] == 0) {
+                singlePredBlock[handlerIndex] = ++blockId
+            }
+        }
+    }
+
+    private fun markSinglePredBlockBodies() {
+        var current = 0
+        for ((i, insn) in insnsArray.withIndex()) {
+            if (singlePredBlock[i] == 0) {
+                singlePredBlock[i] = current
+            } else {
+                // Entered a new SPB.
+                current = singlePredBlock[i]
+            }
+
+            // GOTO, ATHROW, *RETURN instructions terminate current SPB.
+            when (insn.opcode) {
+                Opcodes.GOTO,
+                Opcodes.ATHROW,
+                in Opcodes.IRETURN..Opcodes.RETURN ->
+                    current = 0
+            }
+        }
+    }
+
+    private fun AbstractInsnNode.indexOf() = method.instructions.indexOf(this)
+
+    fun getFrame(insn: AbstractInsnNode): Frame<V>? =
+        frames[insn.indexOf()]
+
+    private fun checkAssertions() {
+        if (insnsArray.any { it.opcode == Opcodes.JSR || it.opcode == Opcodes.RET })
+            throw AssertionError("Subroutines are deprecated since Java 6")
+    }
+
+    private fun visitOpInsn(current: Frame<V>, insn: Int) {
+        processControlFlowEdge(current, insn, insn + 1)
+    }
+
+    private fun visitTableSwitchInsnNode(insnNode: TableSwitchInsnNode, current: Frame<V>, insn: Int) {
+        var jump = insnNode.dflt.indexOf()
+        processControlFlowEdge(current, insn, jump)
+        // In most cases order of visiting switch labels should not matter
+        // The only one is a tableswitch being added in the beginning of coroutine method, these switch' labels may lead
+        // in the middle of try/catch block, and FixStackAnalyzer is not ready for this (trying to restore stack before it was saved)
+        // So we just fix the order of labels being traversed: the first one should be one at the method beginning
+        // Using 'reversed' is because nodes are processed in LIFO order
+        for (label in insnNode.labels.reversed()) {
+            jump = label.indexOf()
+            processControlFlowEdge(current, insn, jump)
+        }
+    }
+
+    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
+        var jump = insnNode.dflt.indexOf()
+        processControlFlowEdge(current, insn, jump)
+        for (label in insnNode.labels) {
+            jump = label.indexOf()
+            processControlFlowEdge(current, insn, jump)
+        }
+    }
+
+    private fun visitJumpInsnNode(insnNode: JumpInsnNode, current: Frame<V>, insn: Int, insnOpcode: Int) {
+        if (insnOpcode != Opcodes.GOTO && insnOpcode != Opcodes.JSR) {
+            processControlFlowEdge(current, insn, insn + 1)
+        }
+        val jump = insnNode.label.indexOf()
+        processControlFlowEdge(current, insn, jump)
+    }
+
+    private fun visitNopInsn(f: Frame<V>, insn: Int) {
+        processControlFlowEdge(f, insn, insn + 1)
+    }
+
+    private fun processControlFlowEdge(current: Frame<V>, insn: Int, jump: Int) {
+        if (visitControlFlowEdge(insn, jump)) {
+            mergeControlFlowEdge(insn, jump, current)
+        }
+    }
+
+    private fun initControlFlowAnalysis(current: Frame<V>, m: MethodNode, owner: String) {
+        current.setReturn(interpreter.newValue(Type.getReturnType(m.desc)))
+        val args = Type.getArgumentTypes(m.desc)
+        var local = 0
+        if ((m.access and Opcodes.ACC_STATIC) == 0) {
+            val ctype = Type.getObjectType(owner)
+            current.setLocal(local++, interpreter.newValue(ctype))
+        }
+        for (arg in args) {
+            current.setLocal(local++, interpreter.newValue(arg))
+            if (arg.size == 2) {
+                current.setLocal(local++, interpreter.newValue(null))
+            }
+        }
+        while (local < m.maxLocals) {
+            current.setLocal(local++, interpreter.newValue(null))
+        }
+        mergeControlFlowEdge(0, 0, current)
+    }
+
+    private fun computeExceptionHandlersForEachInsn() {
+        for (tcb in method.tryCatchBlocks) {
+            val begin = tcb.start.indexOf()
+            val end = tcb.end.indexOf()
+            for (j in begin until end) {
+                val insn = insnsArray[j]
+                if (!insn.isMeaningful) continue
+                var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[j]
+                if (insnHandlers == null) {
+                    insnHandlers = ArrayList<TryCatchBlockNode>()
+                    handlers[j] = insnHandlers
+                }
+                insnHandlers.add(tcb)
+            }
+        }
+    }
+
+    private fun mergeControlFlowEdge(src: Int, dest: Int, frame: Frame<V>) {
+        val oldFrame = frames[dest]
+        val changes = when {
+            oldFrame == null -> {
+                frames[dest] = newFrame(frame.locals, frame.maxStackSize).apply { init(frame) }
+                true
+            }
+            dest == src + 1 && singlePredBlock[src] == singlePredBlock[dest] -> {
+                // Forward jump within a single predecessor block, no need to merge.
+                oldFrame.init(frame)
+                true
+            }
+            else ->
+                oldFrame.merge(frame, interpreter)
+        }
+        if (changes && !queued[dest]) {
+            queued[dest] = true
+            queue[top++] = dest
+        }
+    }
+
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FastStackAnalyzer.kt

@@ -1,239 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- *
- * ASM: a very small and fast Java bytecode manipulation framework
- * Copyright (c) 2000-2011 INRIA, France Telecom
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the copyright holders nor the names of its
- *    contributors may be used to endorse or promote products derived from
- *    this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package org.jetbrains.kotlin.codegen.optimization.fixStack
-
-import org.jetbrains.kotlin.codegen.inline.insnText
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
-import org.jetbrains.org.objectweb.asm.tree.analysis.Value
-
-/**
- * @see org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
- */
-@Suppress("DuplicatedCode")
-internal open class FastStackAnalyzer<V : Value>(
-    private val owner: String,
-    val method: MethodNode,
-    protected val interpreter: Interpreter<V>
-) {
-    protected val insnsArray: Array<AbstractInsnNode> = method.instructions.toArray()
-    private val nInsns = insnsArray.size
-
-    private val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
-
-    private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
-    private val queued = BooleanArray(nInsns)
-    private val queue = IntArray(nInsns)
-    private var top = 0
-
-    protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
-
-    protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
-
-    protected open fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean = true
-
-    fun analyze(): Array<Frame<V>?> {
-        if (nInsns == 0) return frames
-
-        // This is a very specific version of method bytecode analyzer that doesn't perform any DFA,
-        // but infers stack types for reachable instructions instead.
-
-        checkAssertions()
-
-        computeExceptionEdges()
-
-        val current = newFrame(method.maxLocals, method.maxStack)
-        val handler = newFrame(method.maxLocals, method.maxStack)
-        initControlFlowAnalysis(current, method, owner)
-
-        while (top > 0) {
-            val insn = queue[--top]
-            val f = frames[insn]!!
-            queued[insn] = false
-
-            val insnNode = method.instructions[insn]
-            val insnOpcode = insnNode.opcode
-            val insnType = insnNode.type
-
-            try {
-                if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) {
-                    visitNopInsn(f, insn)
-                } else {
-                    current.init(f)
-                    if (insnOpcode != Opcodes.RETURN) {
-                        // Don't care about possibly incompatible return type
-                        current.execute(insnNode, interpreter)
-                    }
-
-                    when {
-                        insnType == AbstractInsnNode.JUMP_INSN ->
-                            visitJumpInsnNode(insnNode as JumpInsnNode, current, insn, insnOpcode)
-                        insnType == AbstractInsnNode.LOOKUPSWITCH_INSN ->
-                            visitLookupSwitchInsnNode(insnNode as LookupSwitchInsnNode, current, insn)
-                        insnType == AbstractInsnNode.TABLESWITCH_INSN ->
-                            visitTableSwitchInsnNode(insnNode as TableSwitchInsnNode, current, insn)
-                        insnOpcode != Opcodes.ATHROW && (insnOpcode < Opcodes.IRETURN || insnOpcode > Opcodes.RETURN) ->
-                            visitOpInsn(current, insn)
-                        else -> {
-                        }
-                    }
-                }
-
-                handlers[insn]?.forEach { tcb ->
-                    val exnType = Type.getObjectType(tcb.type ?: "java/lang/Throwable")
-                    val jump = tcb.handler.indexOf()
-                    if (visitControlFlowExceptionEdge(insn, tcb.handler.indexOf())) {
-                        handler.init(f)
-                        handler.clearStack()
-                        handler.push(interpreter.newValue(exnType))
-                        mergeControlFlowEdge(jump, handler)
-                    }
-                }
-
-            } catch (e: AnalyzerException) {
-                throw AnalyzerException(e.node, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
-            } catch (e: Exception) {
-                throw AnalyzerException(insnNode, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
-            }
-
-        }
-
-        return frames
-    }
-
-    private fun AbstractInsnNode.indexOf() = method.instructions.indexOf(this)
-
-    fun getFrame(insn: AbstractInsnNode): Frame<V>? =
-        frames[insn.indexOf()]
-
-    private fun checkAssertions() {
-        if (insnsArray.any { it.opcode == Opcodes.JSR || it.opcode == Opcodes.RET })
-            throw AssertionError("Subroutines are deprecated since Java 6")
-    }
-
-    private fun visitOpInsn(current: Frame<V>, insn: Int) {
-        processControlFlowEdge(current, insn, insn + 1)
-    }
-
-    private fun visitTableSwitchInsnNode(insnNode: TableSwitchInsnNode, current: Frame<V>, insn: Int) {
-        var jump = insnNode.dflt.indexOf()
-        processControlFlowEdge(current, insn, jump)
-        // In most cases order of visiting switch labels should not matter
-        // The only one is a tableswitch being added in the beginning of coroutine method, these switch' labels may lead
-        // in the middle of try/catch block, and FixStackAnalyzer is not ready for this (trying to restore stack before it was saved)
-        // So we just fix the order of labels being traversed: the first one should be one at the method beginning
-        // Using 'reversed' is because nodes are processed in LIFO order
-        for (label in insnNode.labels.reversed()) {
-            jump = label.indexOf()
-            processControlFlowEdge(current, insn, jump)
-        }
-    }
-
-    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
-        var jump = insnNode.dflt.indexOf()
-        processControlFlowEdge(current, insn, jump)
-        for (label in insnNode.labels) {
-            jump = label.indexOf()
-            processControlFlowEdge(current, insn, jump)
-        }
-    }
-
-    private fun visitJumpInsnNode(insnNode: JumpInsnNode, current: Frame<V>, insn: Int, insnOpcode: Int) {
-        if (insnOpcode != Opcodes.GOTO) {
-            processControlFlowEdge(current, insn, insn + 1)
-        }
-        val jump = insnNode.label.indexOf()
-        processControlFlowEdge(current, insn, jump)
-    }
-
-    private fun visitNopInsn(f: Frame<V>, insn: Int) {
-        processControlFlowEdge(f, insn, insn + 1)
-    }
-
-    private fun processControlFlowEdge(current: Frame<V>, insn: Int, jump: Int) {
-        if (visitControlFlowEdge(insn, jump)) {
-            mergeControlFlowEdge(jump, current)
-        }
-    }
-
-    private fun initControlFlowAnalysis(current: Frame<V>, m: MethodNode, owner: String) {
-        current.setReturn(interpreter.newValue(Type.getReturnType(m.desc)))
-        val args = Type.getArgumentTypes(m.desc)
-        var local = 0
-        if ((m.access and Opcodes.ACC_STATIC) == 0) {
-            val ctype = Type.getObjectType(owner)
-            current.setLocal(local++, interpreter.newValue(ctype))
-        }
-        for (arg in args) {
-            current.setLocal(local++, interpreter.newValue(arg))
-            if (arg.size == 2) {
-                current.setLocal(local++, interpreter.newValue(null))
-            }
-        }
-        while (local < m.maxLocals) {
-            current.setLocal(local++, interpreter.newValue(null))
-        }
-        mergeControlFlowEdge(0, current)
-    }
-
-    private fun computeExceptionEdges() {
-        for (tcb in method.tryCatchBlocks) {
-            // Don't have to visit same exception handler multiple times - we care only about stack state at TCB start.
-            val start = tcb.start.indexOf()
-            var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[start]
-            if (insnHandlers == null) {
-                insnHandlers = ArrayList()
-                handlers[start] = insnHandlers
-            }
-            insnHandlers.add(tcb)
-        }
-    }
-
-    private fun mergeControlFlowEdge(dest: Int, frame: Frame<V>) {
-        val destFrame = frames[dest]
-        if (destFrame == null) {
-            // Don't have to visit same instruction multiple times - we care only about "initial" stack state.
-            frames[dest] = newFrame(frame.locals, frame.maxStackSize).apply { init(frame) }
-            if (!queued[dest]) {
-                queued[dest] = true
-                queue[top++] = dest
-            }
-        }
-    }
-
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt

@@ -19,6 +19,9 @@ package org.jetbrains.kotlin.codegen.optimization.fixStack
 import com.intellij.util.containers.Stack
 import org.jetbrains.kotlin.codegen.inline.isAfterInlineMarker
 import org.jetbrains.kotlin.codegen.inline.isBeforeInlineMarker
+import org.jetbrains.kotlin.codegen.inline.isMarkedReturn
+import org.jetbrains.kotlin.codegen.optimization.common.FlexibleMethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
 import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -26,6 +29,8 @@ import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.JumpInsnNode
 import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
 import kotlin.math.max
@@ -45,14 +50,9 @@ internal class FixStackAnalyzer(
 
     val maxExtraStackSize: Int get() = analyzer.maxExtraStackSize
 
-    fun getStackToSpill(location: AbstractInsnNode): List<FixStackValue>? =
-        analyzer.spilledStacks[location]
-
-    fun getActualStack(location: AbstractInsnNode): List<FixStackValue>? =
-        getFrame(location)?.getStackContent()
-
-    fun getActualStackSize(location: AbstractInsnNode): Int =
-        getFrame(location)?.stackSizeWithExtra ?: DEAD_CODE_STACK_SIZE
+    fun getStackToSpill(location: AbstractInsnNode) = analyzer.spilledStacks[location]
+    fun getActualStack(location: AbstractInsnNode) = getFrame(location)?.getStackContent()
+    fun getActualStackSize(location: AbstractInsnNode) = getFrame(location)?.stackSizeWithExtra ?: DEAD_CODE_STACK_SIZE
 
     fun getExpectedStackSize(location: AbstractInsnNode): Int {
         // We should look for expected stack size at loop entry point markers if available,
@@ -90,9 +90,9 @@ internal class FixStackAnalyzer(
     private val analyzer = InternalAnalyzer(owner)
 
     private inner class InternalAnalyzer(owner: String) :
-        FastStackAnalyzer<FixStackValue>(owner, method, FixStackInterpreter()) {
+        FlexibleMethodAnalyzer<BasicValue>(owner, method, OptimizationBasicInterpreter()) {
 
-        val spilledStacks = hashMapOf<AbstractInsnNode, List<FixStackValue>>()
+        val spilledStacks = hashMapOf<AbstractInsnNode, List<BasicValue>>()
         var maxExtraStackSize = 0; private set
 
         override fun visitControlFlowEdge(insn: Int, successor: Int): Boolean {
@@ -101,15 +101,15 @@ internal class FixStackAnalyzer(
             return !(insnNode is JumpInsnNode && context.breakContinueGotoNodes.contains(insnNode))
         }
 
-        override fun newFrame(nLocals: Int, nStack: Int): Frame<FixStackValue> =
+        override fun newFrame(nLocals: Int, nStack: Int): Frame<BasicValue> =
             FixStackFrame(nLocals, nStack)
 
         private fun indexOf(node: AbstractInsnNode) = method.instructions.indexOf(node)
 
-        inner class FixStackFrame(nLocals: Int, nStack: Int) : Frame<FixStackValue>(nLocals, nStack) {
-            val extraStack = Stack<FixStackValue>()
+        inner class FixStackFrame(nLocals: Int, nStack: Int) : Frame<BasicValue>(nLocals, nStack) {
+            val extraStack = Stack<BasicValue>()
 
-            override fun init(src: Frame<out FixStackValue>): Frame<FixStackValue> {
+            override fun init(src: Frame<out BasicValue>): Frame<BasicValue> {
                 extraStack.clear()
                 extraStack.addAll((src as FixStackFrame).extraStack)
                 return super.init(src)
@@ -120,7 +120,7 @@ internal class FixStackAnalyzer(
                 super.clearStack()
             }
 
-            override fun execute(insn: AbstractInsnNode, interpreter: Interpreter<FixStackValue>) {
+            override fun execute(insn: AbstractInsnNode, interpreter: Interpreter<BasicValue>) {
                 when {
                     PseudoInsn.SAVE_STACK_BEFORE_TRY.isa(insn) ->
                         executeSaveStackBeforeTry(insn)
@@ -130,8 +130,10 @@ internal class FixStackAnalyzer(
                         executeBeforeInlineCallMarker(insn)
                     isAfterInlineMarker(insn) ->
                         executeAfterInlineCallMarker(insn)
-                    insn.opcode == Opcodes.RETURN ->
-                        return
+                    isMarkedReturn(insn) -> {
+                        // KT-9644: might throw "Incompatible return type" on non-local return, in fact we don't care.
+                        if (insn.opcode == Opcodes.RETURN) return
+                    }
                 }
 
                 super.execute(insn, interpreter)
@@ -139,16 +141,14 @@ internal class FixStackAnalyzer(
 
             val stackSizeWithExtra: Int get() = super.getStackSize() + extraStack.size
 
-            fun getStackContent(): List<FixStackValue> {
-                val savedStack = ArrayList<FixStackValue>()
-                for (i in 0 until super.getStackSize()) {
-                    savedStack.add(super.getStack(i))
-                }
+            fun getStackContent(): List<BasicValue> {
+                val savedStack = arrayListOf<BasicValue>()
+                IntRange(0, super.getStackSize() - 1).mapTo(savedStack) { super.getStack(it) }
                 savedStack.addAll(extraStack)
                 return savedStack
             }
 
-            override fun push(value: FixStackValue) {
+            override fun push(value: BasicValue) {
                 if (super.getStackSize() < maxStackSize) {
                     super.push(value)
                 } else {
@@ -157,18 +157,19 @@ internal class FixStackAnalyzer(
                 }
             }
 
-            fun pushAll(values: Collection<FixStackValue>) {
+            fun pushAll(values: Collection<BasicValue>) {
                 values.forEach { push(it) }
             }
 
-            override fun pop(): FixStackValue =
-                if (extraStack.isNotEmpty()) {
+            override fun pop(): BasicValue {
+                return if (extraStack.isNotEmpty()) {
                     extraStack.pop()
                 } else {
                     super.pop()
                 }
+            }
 
-            override fun setStack(i: Int, value: FixStackValue) {
+            override fun setStack(i: Int, value: BasicValue) {
                 if (i < super.getMaxStackSize()) {
                     super.setStack(i, value)
                 } else {
@@ -176,8 +177,29 @@ internal class FixStackAnalyzer(
                 }
             }
 
-            override fun merge(frame: Frame<out FixStackValue>, interpreter: Interpreter<FixStackValue>): Boolean {
-                throw UnsupportedOperationException("Stack normalization should not merge frames")
+            override fun merge(frame: Frame<out BasicValue>, interpreter: Interpreter<BasicValue>): Boolean {
+                val other = frame as FixStackFrame
+                if (stackSizeWithExtra != other.stackSizeWithExtra) {
+                    throw AnalyzerException(null, "Incompatible stack heights")
+                }
+                var changed = false
+                for (i in 0 until stackSize) {
+                    val v0 = super.getStack(i)
+                    val vm = interpreter.merge(v0, other.getStack(i))
+                    if (vm != v0) {
+                        super.setStack(i, vm)
+                        changed = true
+                    }
+                }
+                for (i in 0 until extraStack.size) {
+                    val v0 = extraStack[i]
+                    val vm = interpreter.merge(v0, other.extraStack[i])
+                    if (vm != v0) {
+                        extraStack[i] = vm
+                        changed = true
+                    }
+                }
+                return changed
             }
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackInterpreter.kt

@@ -1,157 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.optimization.fixStack
-
-import org.jetbrains.kotlin.codegen.inline.insnOpcodeText
-import org.jetbrains.org.objectweb.asm.Handle
-import org.jetbrains.org.objectweb.asm.Opcodes.*
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
-
-open class FixStackInterpreter : Interpreter<FixStackValue>(API_VERSION) {
-
-    override fun newValue(type: Type?): FixStackValue =
-        type?.toFixStackValue()
-            ?: FixStackValue.UNINITIALIZED
-
-    override fun newOperation(insn: AbstractInsnNode): FixStackValue? =
-        when (insn.opcode) {
-            ACONST_NULL ->
-                FixStackValue.OBJECT
-            ICONST_M1, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5 ->
-                FixStackValue.INT
-            LCONST_0, LCONST_1 ->
-                FixStackValue.LONG
-            FCONST_0, FCONST_1, FCONST_2 ->
-                FixStackValue.FLOAT
-            DCONST_0, DCONST_1 ->
-                FixStackValue.DOUBLE
-            BIPUSH, SIPUSH ->
-                FixStackValue.INT
-            LDC -> {
-                when (val cst = (insn as LdcInsnNode).cst) {
-                    is Int ->
-                        FixStackValue.INT
-                    is Float ->
-                        FixStackValue.FLOAT
-                    is Long ->
-                        FixStackValue.LONG
-                    is Double ->
-                        FixStackValue.DOUBLE
-                    is String, is Handle ->
-                        FixStackValue.OBJECT
-                    is Type -> {
-                        val sort = cst.sort
-                        if (sort == Type.OBJECT || sort == Type.ARRAY || sort == Type.METHOD)
-                            FixStackValue.OBJECT
-                        else
-                            throw IllegalArgumentException("Illegal LDC constant $cst")
-                    }
-                    else ->
-                        throw IllegalArgumentException("Illegal LDC constant $cst")
-                }
-            }
-            GETSTATIC ->
-                newValue(Type.getType((insn as FieldInsnNode).desc))
-            NEW ->
-                newValue(Type.getObjectType((insn as TypeInsnNode).desc))
-            else ->
-                throw IllegalArgumentException("Unexpected instruction: " + insn.insnOpcodeText)
-        }
-
-    override fun copyOperation(insn: AbstractInsnNode, value: FixStackValue?): FixStackValue =
-        when (insn.opcode) {
-            ILOAD -> FixStackValue.INT
-            LLOAD -> FixStackValue.LONG
-            FLOAD -> FixStackValue.FLOAT
-            DLOAD -> FixStackValue.DOUBLE
-            ALOAD -> FixStackValue.OBJECT
-            else -> value!!
-        }
-
-    override fun binaryOperation(insn: AbstractInsnNode, value1: FixStackValue?, value2: FixStackValue?): FixStackValue? =
-        when (insn.opcode) {
-            IALOAD, BALOAD, CALOAD, SALOAD, IADD, ISUB, IMUL, IDIV, IREM, ISHL, ISHR, IUSHR, IAND, IOR, IXOR ->
-                FixStackValue.INT
-            FALOAD, FADD, FSUB, FMUL, FDIV, FREM ->
-                FixStackValue.FLOAT
-            LALOAD, LADD, LSUB, LMUL, LDIV, LREM, LSHL, LSHR, LUSHR, LAND, LOR, LXOR ->
-                FixStackValue.LONG
-            DALOAD, DADD, DSUB, DMUL, DDIV, DREM ->
-                FixStackValue.DOUBLE
-            AALOAD ->
-                FixStackValue.OBJECT
-            LCMP, FCMPL, FCMPG, DCMPL, DCMPG ->
-                FixStackValue.INT
-            IF_ICMPEQ, IF_ICMPNE, IF_ICMPLT, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, IF_ACMPEQ, IF_ACMPNE, PUTFIELD ->
-                null
-            else ->
-                throw IllegalArgumentException("Unexpected instruction: " + insn.insnOpcodeText)
-        }
-
-    override fun ternaryOperation(
-        insn: AbstractInsnNode,
-        value1: FixStackValue?,
-        value2: FixStackValue?,
-        value3: FixStackValue?
-    ): FixStackValue? =
-        null
-
-    override fun naryOperation(insn: AbstractInsnNode, values: List<FixStackValue?>): FixStackValue? =
-        when (insn.opcode) {
-            MULTIANEWARRAY ->
-                newValue(Type.getType((insn as MultiANewArrayInsnNode).desc))
-            INVOKEDYNAMIC ->
-                newValue(Type.getReturnType((insn as InvokeDynamicInsnNode).desc))
-            else ->
-                newValue(Type.getReturnType((insn as MethodInsnNode).desc))
-        }
-
-    override fun returnOperation(insn: AbstractInsnNode?, value: FixStackValue?, expected: FixStackValue?) {
-    }
-
-    override fun unaryOperation(insn: AbstractInsnNode, value: FixStackValue?): FixStackValue? =
-        when (insn.opcode) {
-            INEG, IINC, L2I, F2I, D2I, I2B, I2C, I2S ->
-                FixStackValue.INT
-            FNEG, I2F, L2F, D2F ->
-                FixStackValue.FLOAT
-            LNEG, I2L, F2L, D2L ->
-                FixStackValue.LONG
-            DNEG, I2D, L2D, F2D ->
-                FixStackValue.DOUBLE
-            IFEQ, IFNE, IFLT, IFGE, IFGT, IFLE, TABLESWITCH, LOOKUPSWITCH, IRETURN, LRETURN, FRETURN, DRETURN, ARETURN, PUTSTATIC ->
-                null
-            GETFIELD ->
-                newValue(Type.getType((insn as FieldInsnNode).desc))
-            NEWARRAY ->
-                FixStackValue.OBJECT
-            ANEWARRAY -> {
-                FixStackValue.OBJECT
-            }
-            ARRAYLENGTH ->
-                FixStackValue.INT
-            ATHROW ->
-                null
-            CHECKCAST ->
-                FixStackValue.OBJECT
-            INSTANCEOF ->
-                FixStackValue.INT
-            MONITORENTER, MONITOREXIT, IFNULL, IFNONNULL ->
-                null
-            else ->
-                throw IllegalArgumentException("Unexpected instruction: " + insn.insnOpcodeText)
-        }
-
-    override fun merge(v: FixStackValue?, w: FixStackValue?): FixStackValue? =
-        when {
-            v == w -> v
-            v == null -> w
-            w == null -> v
-            else -> throw AssertionError("Mismatching value kinds: $v != $w")
-        }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackValue.kt

@@ -1,38 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.optimization.fixStack
-
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.analysis.Value
-
-enum class FixStackValue(
-    private val _size: Int,
-    val loadOpcode: Int,
-    val storeOpcode: Int,
-    val popOpcode: Int
-) : Value {
-    INT(1, Opcodes.ILOAD, Opcodes.ISTORE, Opcodes.POP),
-    LONG(2, Opcodes.LLOAD, Opcodes.LSTORE, Opcodes.POP2),
-    FLOAT(1, Opcodes.FLOAD, Opcodes.FSTORE, Opcodes.POP),
-    DOUBLE(2, Opcodes.DLOAD, Opcodes.DSTORE, Opcodes.POP2),
-    OBJECT(1, Opcodes.ALOAD, Opcodes.ASTORE, Opcodes.POP),
-    UNINITIALIZED(1, -1, -1, -1)
-    ;
-
-    override fun getSize(): Int = _size
-}
-
-fun Type.toFixStackValue(): FixStackValue? =
-    when (this.sort) {
-        Type.VOID -> null
-        Type.BOOLEAN, Type.BYTE, Type.CHAR, Type.SHORT, Type.INT -> FixStackValue.INT
-        Type.LONG -> FixStackValue.LONG
-        Type.FLOAT -> FixStackValue.FLOAT
-        Type.DOUBLE -> FixStackValue.DOUBLE
-        Type.OBJECT, Type.ARRAY, Type.METHOD -> FixStackValue.OBJECT
-        else -> throw AssertionError("Unexpected type: $this")
-    }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/LocalVariablesManager.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.codegen.optimization.fixStack
 
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import kotlin.math.max
 
 internal class LocalVariablesManager(val context: FixStackContext, val methodNode: MethodNode) {
@@ -38,10 +39,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
         methodNode.maxLocals = max(methodNode.maxLocals, newValue)
     }
 
-    fun allocateVariablesForSaveStackMarker(
-        saveStackMarker: AbstractInsnNode,
-        savedStackValues: List<FixStackValue>
-    ): SavedStackDescriptor {
+    fun allocateVariablesForSaveStackMarker(saveStackMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
         val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker]!!.size
         return allocateNewHandle(numRestoreStackMarkers, saveStackMarker, savedStackValues)
     }
@@ -49,10 +47,10 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
     private fun allocateNewHandle(
         numRestoreStackMarkers: Int,
         saveStackMarker: AbstractInsnNode,
-        savedStackValues: List<FixStackValue>
+        savedStackValues: List<BasicValue>
     ): SavedStackDescriptor {
-        if (savedStackValues.any { it == FixStackValue.UNINITIALIZED }) {
-            throw AssertionError("Uninitialized value on stack at ${methodNode.instructions.indexOf(saveStackMarker)}: $savedStackValues")
+        if (savedStackValues.any { it.type == null }) {
+            throw AssertionError("Uninitialized value on stack at ${methodNode.instructions.indexOf(saveStackMarker)}")
         }
 
         val firstUnusedLocalVarIndex = getFirstUnusedLocalVariableIndex()
@@ -80,7 +78,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
 
     fun allocateVariablesForBeforeInlineMarker(
         beforeInlineMarker: AbstractInsnNode,
-        savedStackValues: List<FixStackValue>
+        savedStackValues: List<BasicValue>
     ): SavedStackDescriptor {
         return allocateNewHandle(1, beforeInlineMarker, savedStackValues)
     }
@@ -103,7 +101,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
         }
     }
 
-    fun createReturnValueVariable(returnValue: FixStackValue): Int {
+    fun createReturnValueVariable(returnValue: BasicValue): Int {
         val returnValueIndex = getFirstUnusedLocalVariableIndex()
         updateMaxLocals(returnValueIndex + returnValue.size)
         return returnValueIndex

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/StackTransformationUtils.kt

@@ -54,10 +54,10 @@ fun <V : Value> Frame<V>.peekWords(size1: Int, size2: Int): List<V>? {
 }
 
 class SavedStackDescriptor(
-    val savedValues: List<FixStackValue>,
+    val savedValues: List<BasicValue>,
     val firstLocalVarIndex: Int
 ) {
-    private val savedValuesSize = savedValues.fold(0) { size, value -> size + value.size }
+    private val savedValuesSize = savedValues.fold(0, { size, value -> size + value.size })
     val firstUnusedLocalVarIndex = firstLocalVarIndex + savedValuesSize
 
     override fun toString(): String =
@@ -88,13 +88,13 @@ fun restoreStackWithReturnValue(
     methodNode: MethodNode,
     nodeToReplace: AbstractInsnNode,
     savedStackDescriptor: SavedStackDescriptor,
-    returnValue: FixStackValue,
+    returnValue: BasicValue,
     returnValueLocalVarIndex: Int
 ) {
     with(methodNode.instructions) {
-        insertBefore(nodeToReplace, VarInsnNode(returnValue.storeOpcode, returnValueLocalVarIndex))
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.type.getOpcode(Opcodes.ISTORE), returnValueLocalVarIndex))
         generateLoadInstructions(methodNode, nodeToReplace, savedStackDescriptor)
-        insertBefore(nodeToReplace, VarInsnNode(returnValue.loadOpcode, returnValueLocalVarIndex))
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.type.getOpcode(Opcodes.ILOAD), returnValueLocalVarIndex))
         remove(nodeToReplace)
     }
 }
@@ -102,7 +102,10 @@ fun restoreStackWithReturnValue(
 fun generateLoadInstructions(methodNode: MethodNode, location: AbstractInsnNode, savedStackDescriptor: SavedStackDescriptor) {
     var localVarIndex = savedStackDescriptor.firstLocalVarIndex
     for (value in savedStackDescriptor.savedValues) {
-        methodNode.instructions.insertBefore(location, VarInsnNode(value.loadOpcode, localVarIndex))
+        methodNode.instructions.insertBefore(
+            location,
+            VarInsnNode(value.type.getOpcode(Opcodes.ILOAD), localVarIndex)
+        )
         localVarIndex += value.size
     }
 }
@@ -111,7 +114,10 @@ fun generateStoreInstructions(methodNode: MethodNode, location: AbstractInsnNode
     var localVarIndex = savedStackDescriptor.firstUnusedLocalVarIndex
     for (value in savedStackDescriptor.savedValues.asReversed()) {
         localVarIndex -= value.size
-        methodNode.instructions.insertBefore(location, VarInsnNode(value.storeOpcode, localVarIndex))
+        methodNode.instructions.insertBefore(
+            location,
+            VarInsnNode(value.type.getOpcode(Opcodes.ISTORE), localVarIndex)
+        )
     }
 }
 
@@ -140,10 +146,10 @@ fun replaceAlwaysTrueIfeqWithGoto(methodNode: MethodNode, node: AbstractInsnNode
     }
 }
 
-fun replaceMarkerWithPops(methodNode: MethodNode, node: AbstractInsnNode, expectedStackSize: Int, stackContent: List<FixStackValue>) {
+fun replaceMarkerWithPops(methodNode: MethodNode, node: AbstractInsnNode, expectedStackSize: Int, stackContent: List<BasicValue>) {
     with(methodNode.instructions) {
         for (stackValue in stackContent.subList(expectedStackSize, stackContent.size)) {
-            insert(node, InsnNode(stackValue.popOpcode))
+            insert(node, getPopInstruction(stackValue))
         }
         remove(node)
     }

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

@@ -299,8 +299,6 @@ class GenerationState private constructor(
                 !configuration.getBoolean(JVMConfigurationKeys.NO_UNIFIED_NULL_CHECKS)
     val functionsWithInlineClassReturnTypesMangled: Boolean =
         languageVersionSettings.supportsFeature(LanguageFeature.MangleClassMembersReturningInlineClasses)
-    val shouldValidateIr = configuration.getBoolean(JVMConfigurationKeys.VALIDATE_IR)
-    val shouldValidateBytecode = configuration.getBoolean(JVMConfigurationKeys.VALIDATE_BYTECODE)
 
     val rootContext: CodegenContext<*> = RootContext(this)
 
@@ -407,8 +405,8 @@ class GenerationState private constructor(
             this[KOTLIN_1_2] = oldMetadataVersion
             this[KOTLIN_1_3] = oldMetadataVersion
             this[KOTLIN_1_4] = JvmMetadataVersion(1, 4, 3)
-            this[KOTLIN_1_5] = JvmMetadataVersion(1, 5, 1)
-            this[KOTLIN_1_6] = JvmMetadataVersion.INSTANCE
+            this[KOTLIN_1_5] = JvmMetadataVersion.INSTANCE
+            this[KOTLIN_1_6] = JvmMetadataVersion(1, 6, 0)
             this[KOTLIN_1_7] = JvmMetadataVersion(1, 7, 0)
 
             check(size == LanguageVersion.values().size) {

compiler/build.gradle.kts

@@ -12,6 +12,25 @@ val otherCompilerModules = compilerModules.filter { it != path }
 
 val tasksWithWarnings: List<String> by rootProject.extra
 
+val effectSystemEnabled: Boolean by rootProject.extra
+val newInferenceEnabled: Boolean by rootProject.extra
+
+configureFreeCompilerArg(effectSystemEnabled, "-Xeffect-system")
+configureFreeCompilerArg(newInferenceEnabled, "-Xnew-inference")
+configureFreeCompilerArg(true, "-Xuse-mixed-named-arguments")
+
+fun configureFreeCompilerArg(isEnabled: Boolean, compilerArgument: String) {
+    if (isEnabled) {
+        allprojects {
+            tasks.withType<KotlinCompile<*>> {
+                kotlinOptions {
+                    freeCompilerArgs += listOf(compilerArgument)
+                }
+            }
+        }
+    }
+}
+
 val antLauncherJar by configurations.creating
 
 dependencies {
@@ -66,9 +85,7 @@ if (kotlinBuildProperties.isInJpsBuildIdeaSync) {
     idea {
         this.module.generatedSourceDirs.add(generationRoot)
     }
-}
-
-if (!kotlinBuildProperties.disableWerror) {
+} else if (!kotlinBuildProperties.useFir && !kotlinBuildProperties.disableWerror) {
     allprojects {
         tasks.withType<KotlinCompile<*>> {
             if (path !in tasksWithWarnings) {

compiler/cli/build.gradle.kts

@@ -57,10 +57,10 @@ sourceSets {
 
 tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
     kotlinOptions {
-        languageVersion = "1.4"
-        apiVersion = "1.4"
+        languageVersion = "1.3"
+        apiVersion = "1.3"
         freeCompilerArgs = freeCompilerArgs - "-progressive" + listOf(
-            "-Xskip-prerelease-check", "-Xsuppress-version-warnings", "-Xuse-mixed-named-arguments", "-Xnew-inference"
+            "-Xskip-prerelease-check", "-Xsuppress-version-warnings"
         )
     }
 }

compiler/cli/cli-common/resources/META-INF/extensions/core.xml

@@ -0,0 +1,12 @@
+<idea-plugin>
+    <id>org.jetbrains.kotlin</id>
+    <version>1.2</version>
+
+    <!-- Don't add more extension points here! Logic in KotlinCoreEnvironment assumes that there is only one EP.  -->
+    <!-- And this file should be removed once 202 is no longer supported -->
+    <extensionPoints>
+        <extensionPoint qualifiedName="com.intellij.psi.classFileDecompiler"
+                        interface="com.intellij.psi.compiled.ClassFileDecompilers$Decompiler"
+                        dynamic="true"/>
+    </extensionPoints>
+</idea-plugin>

compiler/cli/cli-common/resources/META-INF/extensions/core.xml.as42

@@ -0,0 +1,10 @@
+<idea-plugin>
+    <id>org.jetbrains.kotlin</id>
+    <version>1.2</version>
+
+    <extensionPoints>
+        <extensionPoint qualifiedName="com.intellij.psi.classFileDecompiler"
+                        interface="com.intellij.psi.compiled.ClassFileDecompilers$Decompiler"
+                        dynamic="true"/>
+    </extensionPoints>
+</idea-plugin>

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

@@ -369,6 +369,7 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var extendedCompilerChecks: Boolean by FreezableVar(false)
 
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(
         value = "-Xbuiltins-from-sources",
         description = "Compile builtIns from sources"
@@ -381,12 +382,6 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var unrestrictedBuilderInference: Boolean by FreezableVar(false)
 
-    @Argument(
-        value = "-Xself-upper-bound-inference",
-        description = "Support inferring type arguments based on only self upper bounds of the corresponding type parameters"
-    )
-    var selfUpperBoundInference: Boolean by FreezableVar(false)
-
     open fun configureAnalysisFlags(collector: MessageCollector, languageVersion: LanguageVersion): MutableMap<AnalysisFlag<*>, Any> {
         return HashMap<AnalysisFlag<*>, Any>().apply {
             put(AnalysisFlags.skipMetadataVersionCheck, skipMetadataVersionCheck)
@@ -429,10 +424,6 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
                 put(LanguageFeature.UnrestrictedBuilderInference, LanguageFeature.State.ENABLED)
             }
 
-            if (selfUpperBoundInference) {
-                put(LanguageFeature.TypeInferenceOnCallsWithSelfTypes, LanguageFeature.State.ENABLED)
-            }
-
             if (newInference) {
                 put(LanguageFeature.NewInference, LanguageFeature.State.ENABLED)
                 put(LanguageFeature.SamConversionPerArgument, LanguageFeature.State.ENABLED)

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

@@ -214,12 +214,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var useOldClassFilesReading: Boolean by FreezableVar(false)
 
-    @Argument(
-        value = "-Xuse-fast-jar-file-system",
-        description = "Use fast implementation on Jar FS. This may speed up compilation time, but currently it's an experimental mode"
-    )
-    var useFastJarFileSystem: Boolean by FreezableVar(false)
-
     @Argument(
         value = "-Xdump-declarations-to",
         valueDescription = "<path>",
@@ -511,18 +505,6 @@ default: `indy-with-constants` for JVM target 9 or greater, `inline` otherwise""
     )
     var serializeIr: Boolean by FreezableVar(false)
 
-    @Argument(
-        value = "-Xvalidate-ir",
-        description = "Validate IR before and after lowering"
-    )
-    var validateIr: Boolean by FreezableVar(false)
-
-    @Argument(
-        value = "-Xvalidate-bytecode",
-        description = "Validate generated JVM bytecode before and after optimizations"
-    )
-    var validateBytecode: Boolean by FreezableVar(false)
-
     override fun configureAnalysisFlags(collector: MessageCollector, languageVersion: LanguageVersion): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector, languageVersion)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics

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

@@ -38,8 +38,6 @@ import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalNextRoundChecker
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.ir.backend.js.*
-import org.jetbrains.kotlin.ir.backend.js.ic.buildCache
-import org.jetbrains.kotlin.ir.backend.js.ic.checkCaches
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
 import org.jetbrains.kotlin.js.config.*
@@ -93,7 +91,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
             configuration.put(CommonConfigurationKeys.MODULE_NAME, "repl.kts")
 
             val environment = KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(rootDisposable, configuration)
-            val projectEnv = KotlinCoreEnvironment.ProjectEnvironment(rootDisposable, environment, configuration)
+            val projectEnv = KotlinCoreEnvironment.ProjectEnvironment(rootDisposable, environment)
             projectEnv.registerExtensionsFromPlugins(configuration)
 
             val scriptingEvaluators = ScriptEvaluationExtension.getInstances(projectEnv.project)
@@ -181,44 +179,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         // TODO: Handle non-empty main call arguments
         val mainCallArguments = if (K2JsArgumentConstants.NO_CALL == arguments.main) null else emptyList<String>()
 
-        val icCaches = configureLibraries(arguments.cacheDirectories)
-
-        if (arguments.irBuildCache) {
-            messageCollector.report(INFO, "")
-            messageCollector.report(INFO, "Building cache:")
-            messageCollector.report(INFO, "to: ${outputFilePath}")
-            messageCollector.report(INFO, arguments.cacheDirectories ?: "")
-            messageCollector.report(INFO, libraries.toString())
-
-            val includes = arguments.includes!!
-
-            // TODO: deduplicate
-            val mainModule = run {
-                if (sourcesFiles.isNotEmpty()) {
-                    messageCollector.report(ERROR, "Source files are not supported when -Xinclude is present")
-                }
-                MainModule.Klib(includes)
-            }
-
-            val start = System.currentTimeMillis()
-            if (buildCache(
-                    cachePath = outputFilePath,
-                    project = projectJs,
-                    mainModule = mainModule,
-                    analyzer = AnalyzerWithCompilerReport(config.configuration),
-                    configuration = config.configuration,
-                    dependencies = libraries,
-                    friendDependencies = friendLibraries,
-                    icCache = checkCaches(libraries, icCaches, skipLib = mainModule.libPath)
-                )
-            ) {
-                messageCollector.report(INFO, "IC cache building duration: ${System.currentTimeMillis() - start}ms")
-            } else {
-                messageCollector.report(INFO, "IC cache up-to-date check duration: ${System.currentTimeMillis() - start}ms")
-            }
-            return OK
-        }
-
         if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) {
             if (arguments.irProduceKlibFile) {
                 require(outputFile.extension == KLIB_FILE_EXTENSION) { "Please set up .klib file as output" }
@@ -239,9 +199,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         }
 
         if (arguments.irProduceJs) {
-            messageCollector.report(INFO,"Produce executable: $outputFilePath")
-            messageCollector.report(INFO, arguments.cacheDirectories ?: "")
-
             val phaseConfig = createPhaseConfig(jsPhases, arguments, messageCollector)
 
             val includes = arguments.includes
@@ -278,7 +235,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                 val runner = """
                     const wasmBinary = read(String.raw`${outputWasmFile.absoluteFile}`, 'binary');
                     const wasmModule = new WebAssembly.Module(wasmBinary);
-                    wasmInstance = new WebAssembly.Instance(wasmModule, { runtime, js_code });
+                    const wasmInstance = new WebAssembly.Instance(wasmModule, { runtime, js_code });
                     wasmInstance.exports.main();
                 """.trimIndent()
 
@@ -286,8 +243,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                 return OK
             }
 
-            val start = System.currentTimeMillis()
-
             val compiledModule = compile(
                 projectJs,
                 mainModule,
@@ -315,13 +270,8 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     arguments.irSafeExternalBooleanDiagnostic,
                     messageCollector
                 ),
-                lowerPerModule = icCaches.isNotEmpty(),
-                useStdlibCache = icCaches.isNotEmpty(),
-                icCache = if (icCaches.isNotEmpty()) checkCaches(libraries, icCaches, skipLib = includes).data else emptyMap(),
             )
 
-            messageCollector.report(INFO, "Executable production duration: ${System.currentTimeMillis() - start}ms")
-
             val outputs = if (arguments.irDce && !arguments.irDceDriven) compiledModule.outputsAfterDce!! else compiledModule.outputs!!
             outputFile.write(outputs)
             outputs.dependencies.forEach { (name, content) ->

compiler/cli/src/com/intellij/util/io/FileChannelUtil.java

@@ -1,13 +0,0 @@
-// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package com.intellij.util.io;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.nio.channels.FileChannel;
-
-public final class FileChannelUtil {
-    @NotNull
-    static FileChannel unInterruptible(@NotNull FileChannel channel) {
-        return channel;
-    }
-}

compiler/cli/src/org/jetbrains/kotlin/cli/common/extensions/ScriptEvaluationExtension.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.cli.common.extensions
 
+import com.intellij.core.JavaCoreProjectEnvironment
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
 
@@ -22,6 +22,6 @@ interface ScriptEvaluationExtension {
     fun eval(
         arguments: CommonCompilerArguments,
         configuration: CompilerConfiguration,
-        projectEnvironment: KotlinCoreEnvironment.ProjectEnvironment
+        projectEnvironment: JavaCoreProjectEnvironment
     ): ExitCode
 }

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

@@ -233,8 +233,8 @@ object JvmRuntimeVersionsConsistencyChecker {
         jars: List<KotlinLibraryFile>
     ): MavenComparableVersion? {
         assert(jars.isNotEmpty()) { "'jars' must not be empty" }
-        val oldestVersion = jars.minOf { it.version }
-        val newestVersion = jars.maxOf { it.version }
+        val oldestVersion = jars.minBy { it.version }!!.version
+        val newestVersion = jars.maxBy { it.version }!!.version
 
         // If the oldest version is the same as the newest version, then all jars have the same version
         if (oldestVersion == newestVersion) return oldestVersion
@@ -250,9 +250,9 @@ object JvmRuntimeVersionsConsistencyChecker {
         // we suggest to provide an explicit dependency on version X.
         // TODO: report this depending on the content of the jars instead
         val minReflectJar =
-            jars.filter { it.file.name.startsWith("kotlin-reflect") }.minByOrNull { it.version }
+            jars.filter { it.file.name.startsWith("kotlin-reflect") }.minBy { it.version }
         val maxStdlibJar =
-            jars.filter { it.file.name.startsWith("kotlin-runtime") || it.file.name.startsWith("kotlin-stdlib") }.maxByOrNull { it.version }
+            jars.filter { it.file.name.startsWith("kotlin-runtime") || it.file.name.startsWith("kotlin-stdlib") }.maxBy { it.version }
         if (minReflectJar != null && maxStdlibJar != null && minReflectJar.version < maxStdlibJar.version) {
             messageCollector.issue(
                 null,

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

@@ -89,8 +89,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             val projectEnvironment =
                 KotlinCoreEnvironment.ProjectEnvironment(
                     rootDisposable,
-                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(rootDisposable, configuration),
-                    configuration
+                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(rootDisposable, configuration)
                 )
             projectEnvironment.registerExtensionsFromPlugins(configuration)
 

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

@@ -235,7 +235,6 @@ object FirKotlinToJvmBytecodeCompiler {
             if (commonSession != null) {
                 sourceDependsOnDependencies(listOf(commonSession.moduleData))
             }
-            friendDependencies(module.getFriendPaths())
         }
 
         val commonAnalyzerFacade = commonSession?.let { FirAnalyzerFacade(it, languageVersionSettings, commonKtFiles) }

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

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler
+
+import com.intellij.openapi.project.DumbUtil
+
+@Suppress("UnstableApiUsage")
+class KotlinCoreDumbUtil : DumbUtil {
+    override fun <T : Any?> filterByDumbAwarenessHonoringIgnoring(collection: Collection<T>): List<T> =
+        when (collection) {
+            is List<T> -> collection
+            else -> ArrayList(collection)
+        }
+
+    override fun mayUseIndices(): Boolean = false
+}

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

@@ -68,7 +68,6 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_W
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.cli.jvm.JvmRuntimeVersionsConsistencyChecker
-import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarFileSystem
 import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.cli.jvm.index.*
 import org.jetbrains.kotlin.cli.jvm.javac.JavacWrapperRegistrar
@@ -93,11 +92,11 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
-import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFactoryService
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
@@ -108,54 +107,17 @@ import java.nio.file.FileSystems
 import java.util.zip.ZipFile
 
 class KotlinCoreEnvironment private constructor(
-    val projectEnvironment: ProjectEnvironment,
+    val projectEnvironment: JavaCoreProjectEnvironment,
     private val initialConfiguration: CompilerConfiguration,
     configFiles: EnvironmentConfigFiles
 ) {
 
     class ProjectEnvironment(
         disposable: Disposable,
-        applicationEnvironment: KotlinCoreApplicationEnvironment,
-        configuration: CompilerConfiguration
+        applicationEnvironment: KotlinCoreApplicationEnvironment
     ) :
         KotlinCoreProjectEnvironment(disposable, applicationEnvironment) {
 
-        internal val jarFileSystem: VirtualFileSystem
-
-        init {
-            val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
-
-            if (configuration.getBoolean(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM)) {
-                messageCollector?.report(
-                    STRONG_WARNING,
-                    "Using new faster version of JAR FS: it should make your build faster, but the new implementation is experimental"
-                )
-            }
-
-            jarFileSystem = when {
-                configuration.getBoolean(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM) || configuration.getBoolean(CommonConfigurationKeys.USE_FIR) -> {
-                    val fastJarFs = FastJarFileSystem.createIfUnmappingPossible()
-
-                    if (fastJarFs == null) {
-                        messageCollector?.report(
-                            STRONG_WARNING,
-                            "Your JDK doesn't seem to support mapped buffer unmapping, so the slower (old) version of JAR FS will be used"
-                        )
-                        applicationEnvironment.jarFileSystem
-                    } else {
-
-                        Disposer.register(disposable) {
-                            fastJarFs.clearHandlersCache()
-                        }
-
-                        fastJarFs
-                    }
-                }
-
-                else -> applicationEnvironment.jarFileSystem
-            }
-        }
-
         private var extensionRegistered = false
 
         override fun preregisterServices() {
@@ -205,13 +167,6 @@ class KotlinCoreEnvironment private constructor(
 
         val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
 
-        if (configuration.getBoolean(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM)) {
-            messageCollector?.report(
-                STRONG_WARNING,
-                "Using new faster version of JAR FS: it should make your build faster, but the new implementation is experimental"
-            )
-        }
-
         (projectEnvironment as? ProjectEnvironment)?.registerExtensionsFromPlugins(configuration)
         // otherwise consider that project environment is properly configured before passing to the environment
         // TODO: consider some asserts to check important extension points
@@ -267,14 +222,11 @@ class KotlinCoreEnvironment private constructor(
         this.initialRoots.addAll(initialRoots)
 
         if (!configuration.getBoolean(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK) && messageCollector != null) {
-            /*
-            // Temporarily disable until compiler is bootstrapped to 1.6.
             JvmRuntimeVersionsConsistencyChecker.checkCompilerClasspathConsistency(
                 messageCollector,
                 configuration,
                 initialRoots.mapNotNull { (file, type) -> if (type == JavaRoot.RootType.BINARY) file else null }
             )
-            */
         }
 
         val (roots, singleJavaFileRoots) =
@@ -439,7 +391,7 @@ class KotlinCoreEnvironment private constructor(
     }
 
     private fun findJarRoot(file: File): VirtualFile? =
-        projectEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}")
+        applicationEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}")
 
     private fun getSourceRootsCheckingForDuplicates(): List<KotlinSourceRoot> {
         val uniqueSourceRoots = hashSetOf<String>()
@@ -465,22 +417,17 @@ class KotlinCoreEnvironment private constructor(
     companion object {
         private val LOG = Logger.getInstance(KotlinCoreEnvironment::class.java)
 
-        @PublishedApi
-        internal val APPLICATION_LOCK = Object()
-
+        private val APPLICATION_LOCK = Object()
         private var ourApplicationEnvironment: KotlinCoreApplicationEnvironment? = null
         private var ourProjectCount = 0
 
-        inline fun <R> underApplicationLock(action: () -> R): R =
-            synchronized(APPLICATION_LOCK) { action() }
-
         @JvmStatic
         fun createForProduction(
             parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
         ): KotlinCoreEnvironment {
             setupIdeaStandaloneExecution()
             val appEnv = getOrCreateApplicationEnvironmentForProduction(parentDisposable, configuration)
-            val projectEnv = ProjectEnvironment(parentDisposable, appEnv, configuration)
+            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
             val environment = KotlinCoreEnvironment(projectEnv, configuration, configFiles)
 
             synchronized(APPLICATION_LOCK) {
@@ -491,7 +438,7 @@ class KotlinCoreEnvironment private constructor(
 
         @JvmStatic
         fun createForProduction(
-            projectEnvironment: ProjectEnvironment, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
+            projectEnvironment: JavaCoreProjectEnvironment, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
         ): KotlinCoreEnvironment {
             val environment = KotlinCoreEnvironment(projectEnvironment, configuration, configFiles)
 
@@ -512,7 +459,7 @@ class KotlinCoreEnvironment private constructor(
             val configuration = initialConfiguration.copy()
             // Tests are supposed to create a single project and dispose it right after use
             val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            val projectEnv = ProjectEnvironment(parentDisposable, appEnv, configuration)
+            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
             return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs)
         }
 
@@ -527,7 +474,7 @@ class KotlinCoreEnvironment private constructor(
         @TestOnly
         fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment {
             val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            return ProjectEnvironment(parentDisposable, appEnv, configuration)
+            return ProjectEnvironment(parentDisposable, appEnv)
         }
 
         // used in the daemon for jar cache cleanup
@@ -546,14 +493,7 @@ class KotlinCoreEnvironment private constructor(
         ): KotlinCoreApplicationEnvironment {
             synchronized(APPLICATION_LOCK) {
                 if (ourApplicationEnvironment == null) {
-                    val disposable = if (unitTestMode) {
-                        parentDisposable
-                    } else {
-                        // TODO this is a memory leak in the compiler, as this Disposable is not registered and thus is never disposed
-                        // but using parentDisposable as disposable in compiler, causes access to application extension points after
-                        // they was disposed, this needs to be fixed
-                        Disposer.newDisposable("Disposable for the KotlinCoreApplicationEnvironment")
-                    }
+                    val disposable = Disposer.newDisposable()
                     ourApplicationEnvironment = createApplicationEnvironment(disposable, configuration, unitTestMode)
                     ourProjectCount = 0
                     Disposer.register(disposable, Disposable {
@@ -598,6 +538,11 @@ class KotlinCoreEnvironment private constructor(
             val applicationEnvironment = KotlinCoreApplicationEnvironment.create(parentDisposable, unitTestMode)
 
             registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/compiler.xml")
+            // FIX ME WHEN BUNCH 202 REMOVED: this code is required to support compiler bundled to both 202 and 203.
+            // Please, remove "com.intellij.psi.classFileDecompiler" EP registration once 202 is no longer supported by the compiler
+            if (!ApplicationManager.getApplication().extensionArea.hasExtensionPoint("com.intellij.psi.classFileDecompiler")) {
+                registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/core.xml")
+            }
 
             registerApplicationServicesForCLI(applicationEnvironment)
             registerApplicationServices(applicationEnvironment)

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

@@ -0,0 +1,722 @@
+/*
+ * 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.cli.jvm.compiler
+
+import com.intellij.codeInsight.ExternalAnnotationsManager
+import com.intellij.codeInsight.InferredAnnotationsManager
+import com.intellij.core.CoreApplicationEnvironment
+import com.intellij.core.CoreJavaFileManager
+import com.intellij.core.JavaCoreProjectEnvironment
+import com.intellij.ide.highlighter.JavaFileType
+import com.intellij.lang.java.JavaParserDefinition
+import com.intellij.mock.MockProject
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.TransactionGuard
+import com.intellij.openapi.application.TransactionGuardImpl
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.extensions.ExtensionsArea
+import com.intellij.openapi.fileTypes.PlainTextFileType
+import com.intellij.openapi.project.DumbUtil
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.util.io.FileUtilRt
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.openapi.vfs.*
+import com.intellij.openapi.vfs.impl.ZipHandler
+import com.intellij.psi.PsiElementFinder
+import com.intellij.psi.PsiManager
+import com.intellij.psi.impl.JavaClassSupersImpl
+import com.intellij.psi.impl.PsiElementFinderImpl
+import com.intellij.psi.impl.PsiTreeChangePreprocessor
+import com.intellij.psi.impl.file.impl.JavaFileManager
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.util.JavaClassSupers
+import com.intellij.util.io.URLUtil
+import com.intellij.util.lang.UrlClassLoader
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
+import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
+import org.jetbrains.kotlin.asJava.classes.FacadeCache
+import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
+import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.CliModuleVisibilityManagerImpl
+import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
+import org.jetbrains.kotlin.cli.common.config.ContentRoot
+import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
+import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
+import org.jetbrains.kotlin.cli.common.extensions.ScriptEvaluationExtension
+import org.jetbrains.kotlin.cli.common.extensions.ShellExtension
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_WARNING
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.common.toBooleanLenient
+import org.jetbrains.kotlin.cli.jvm.JvmRuntimeVersionsConsistencyChecker
+import org.jetbrains.kotlin.cli.jvm.config.*
+import org.jetbrains.kotlin.cli.jvm.index.*
+import org.jetbrains.kotlin.cli.jvm.javac.JavacWrapperRegistrar
+import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleFinder
+import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleResolver
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem
+import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
+import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
+import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.extensions.*
+import org.jetbrains.kotlin.extensions.internal.CandidateInterceptor
+import org.jetbrains.kotlin.extensions.internal.TypeResolutionInterceptor
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.js.translate.extensions.JsSyntheticTranslateExtension
+import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
+import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
+import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
+import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
+import org.jetbrains.kotlin.parsing.KotlinParserDefinition
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
+import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
+import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
+import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
+import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
+import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
+import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFactoryService
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
+import org.jetbrains.kotlin.serialization.DescriptorSerializerPlugin
+import org.jetbrains.kotlin.utils.PathUtil
+import java.io.File
+import java.nio.file.FileSystems
+import java.util.zip.ZipFile
+
+class KotlinCoreEnvironment private constructor(
+    val projectEnvironment: JavaCoreProjectEnvironment,
+    initialConfiguration: CompilerConfiguration,
+    configFiles: EnvironmentConfigFiles
+) {
+
+    class ProjectEnvironment(
+        disposable: Disposable, applicationEnvironment: KotlinCoreApplicationEnvironment
+    ) :
+        KotlinCoreProjectEnvironment(disposable, applicationEnvironment) {
+
+        private var extensionRegistered = false
+
+        override fun preregisterServices() {
+            registerProjectExtensionPoints(project.extensionArea)
+        }
+
+        fun registerExtensionsFromPlugins(configuration: CompilerConfiguration) {
+            if (!extensionRegistered) {
+                registerPluginExtensionPoints(project)
+                registerExtensionsFromPlugins(project, configuration)
+                extensionRegistered = true
+            }
+        }
+
+        override fun registerJavaPsiFacade() {
+            with(project) {
+                registerService(
+                    CoreJavaFileManager::class.java,
+                    ServiceManager.getService(this, JavaFileManager::class.java) as CoreJavaFileManager
+                )
+
+                registerKotlinLightClassSupport(project)
+
+                registerService(ExternalAnnotationsManager::class.java, MockExternalAnnotationsManager())
+                registerService(InferredAnnotationsManager::class.java, MockInferredAnnotationsManager())
+            }
+
+            super.registerJavaPsiFacade()
+        }
+    }
+
+    private val sourceFiles = mutableListOf<KtFile>()
+    private val rootsIndex: JvmDependenciesDynamicCompoundIndex
+    private val packagePartProviders = mutableListOf<JvmPackagePartProvider>()
+
+    private val classpathRootsResolver: ClasspathRootsResolver
+    private val initialRoots = ArrayList<JavaRoot>()
+
+    val configuration: CompilerConfiguration = initialConfiguration.apply { setupJdkClasspathRoots(configFiles) }.copy()
+
+    init {
+        PersistentFSConstants::class.java.getDeclaredField("ourMaxIntellisenseFileSize")
+            .apply { isAccessible = true }
+            .setInt(null, FileUtilRt.LARGE_FOR_CONTENT_LOADING)
+
+        val project = projectEnvironment.project
+
+        val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+
+        (projectEnvironment as? ProjectEnvironment)?.registerExtensionsFromPlugins(configuration)
+        // otherwise consider that project environment is properly configured before passing to the environment
+        // TODO: consider some asserts to check important extension points
+
+        project.registerService(DeclarationProviderFactoryService::class.java, CliDeclarationProviderFactoryService(sourceFiles))
+
+        val isJvm = configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES
+        project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl(isJvm))
+
+        registerProjectServicesForCLI(projectEnvironment)
+
+        registerProjectServices(projectEnvironment.project)
+
+        for (extension in CompilerConfigurationExtension.getInstances(project)) {
+            extension.updateConfiguration(configuration)
+        }
+
+        sourceFiles += createKtFiles(project)
+
+        collectAdditionalSources(project)
+
+        sourceFiles.sortBy { it.virtualFile.path }
+
+        val javaFileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl
+
+        val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME)
+        val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL)
+        val javaModuleFinder = CliJavaModuleFinder(
+            jdkHome?.path?.let { path ->
+                jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
+            },
+            javaFileManager
+        )
+
+        val outputDirectory =
+            configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory()
+                ?: configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)?.absolutePath
+
+        classpathRootsResolver = ClasspathRootsResolver(
+            PsiManager.getInstance(project),
+            messageCollector,
+            configuration.getList(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES),
+            this::contentRootToVirtualFile,
+            javaModuleFinder,
+            !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE),
+            outputDirectory?.let(this::findLocalFile),
+            javaFileManager
+        )
+
+        val (initialRoots, javaModules) =
+            classpathRootsResolver.convertClasspathRoots(configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS))
+        this.initialRoots.addAll(initialRoots)
+
+        if (!configuration.getBoolean(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK) && messageCollector != null) {
+            JvmRuntimeVersionsConsistencyChecker.checkCompilerClasspathConsistency(
+                messageCollector,
+                configuration,
+                initialRoots.mapNotNull { (file, type) -> if (type == JavaRoot.RootType.BINARY) file else null }
+            )
+        }
+
+        val (roots, singleJavaFileRoots) =
+            initialRoots.partition { (file) -> file.isDirectory || file.extension != JavaFileType.DEFAULT_EXTENSION }
+
+        // REPL and kapt2 update classpath dynamically
+        rootsIndex = JvmDependenciesDynamicCompoundIndex().apply {
+            addIndex(JvmDependenciesIndexImpl(roots))
+            updateClasspathFromRootsIndex(this)
+        }
+
+        javaFileManager.initialize(
+            rootsIndex,
+            packagePartProviders,
+            SingleJavaFileRootsIndex(singleJavaFileRoots),
+            configuration.getBoolean(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING)
+        )
+
+        project.registerService(
+            JavaModuleResolver::class.java,
+            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList(), project)
+        )
+
+        val finderFactory = CliVirtualFileFinderFactory(rootsIndex)
+        project.registerService(MetadataFinderFactory::class.java, finderFactory)
+        project.registerService(VirtualFileFinderFactory::class.java, finderFactory)
+
+        project.putUserData(APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY, fun(roots: List<File>) {
+            updateClasspath(roots.map { JavaSourceRoot(it, null) })
+        })
+    }
+
+    private fun collectAdditionalSources(project: MockProject) {
+        var unprocessedSources: Collection<KtFile> = sourceFiles
+        val processedSources = HashSet<KtFile>()
+        val processedSourcesByExtension = HashMap<CollectAdditionalSourcesExtension, Collection<KtFile>>()
+        // repeat feeding extensions with sources while new sources a being added
+        var sourceCollectionIterations = 0
+        while (unprocessedSources.isNotEmpty()) {
+            if (sourceCollectionIterations++ > 10) { // TODO: consider using some appropriate global constant
+                throw IllegalStateException("Unable to collect additional sources in reasonable number of iterations")
+            }
+            processedSources.addAll(unprocessedSources)
+            val allNewSources = ArrayList<KtFile>()
+            for (extension in CollectAdditionalSourcesExtension.getInstances(project)) {
+                // do not feed the extension with the sources it returned on the previous iteration
+                val sourcesToProcess = unprocessedSources - (processedSourcesByExtension[extension] ?: emptyList())
+                val newSources = extension.collectAdditionalSourcesAndUpdateConfiguration(sourcesToProcess, configuration, project)
+                if (newSources.isNotEmpty()) {
+                    allNewSources.addAll(newSources)
+                    processedSourcesByExtension[extension] = newSources
+                }
+            }
+            unprocessedSources = allNewSources.filterNot { processedSources.contains(it) }.distinct()
+            sourceFiles += unprocessedSources
+        }
+    }
+
+    fun addKotlinSourceRoots(rootDirs: List<File>) {
+        val roots = rootDirs.map { KotlinSourceRoot(it.absolutePath, isCommon = false) }
+        sourceFiles += createSourceFilesFromSourceRoots(configuration, project, roots)
+    }
+
+    fun createPackagePartProvider(scope: GlobalSearchScope): JvmPackagePartProvider {
+        return JvmPackagePartProvider(configuration.languageVersionSettings, scope).apply {
+            addRoots(initialRoots, configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY))
+            packagePartProviders += this
+            (ModuleAnnotationsResolver.getInstance(project) as CliModuleAnnotationsResolver).addPackagePartProvider(this)
+        }
+    }
+
+    private val VirtualFile.javaFiles: List<VirtualFile>
+        get() = mutableListOf<VirtualFile>().apply {
+            VfsUtilCore.processFilesRecursively(this@javaFiles) { file ->
+                if (file.fileType == JavaFileType.INSTANCE) {
+                    add(file)
+                }
+                true
+            }
+        }
+
+    private val allJavaFiles: List<File>
+        get() = configuration.javaSourceRoots
+            .mapNotNull(this::findLocalFile)
+            .flatMap { it.javaFiles }
+            .map { File(it.canonicalPath) }
+
+    fun registerJavac(
+        javaFiles: List<File> = allJavaFiles,
+        kotlinFiles: List<KtFile> = sourceFiles,
+        arguments: Array<String>? = null,
+        bootClasspath: List<File>? = null,
+        sourcePath: List<File>? = null
+    ): Boolean {
+        return JavacWrapperRegistrar.registerJavac(
+            projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments, bootClasspath, sourcePath,
+            LightClassGenerationSupport.getInstance(project), packagePartProviders
+        )
+    }
+
+    private val applicationEnvironment: CoreApplicationEnvironment
+        get() = projectEnvironment.environment
+
+    val project: Project
+        get() = projectEnvironment.project
+
+    internal fun countLinesOfCode(sourceFiles: List<KtFile>): Int =
+        sourceFiles.sumBy { sourceFile ->
+            val text = sourceFile.text
+            StringUtil.getLineBreakCount(text) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1)
+        }
+
+    private fun updateClasspathFromRootsIndex(index: JvmDependenciesIndex) {
+        index.indexedRoots.forEach {
+            projectEnvironment.addSourcesToClasspath(it.file)
+        }
+    }
+
+    fun updateClasspath(contentRoots: List<ContentRoot>): List<File>? {
+        // TODO: add new Java modules to CliJavaModuleResolver
+        val newRoots = classpathRootsResolver.convertClasspathRoots(contentRoots).roots
+
+        if (packagePartProviders.isEmpty()) {
+            initialRoots.addAll(newRoots)
+        } else {
+            for (packagePartProvider in packagePartProviders) {
+                packagePartProvider.addRoots(newRoots, configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY))
+            }
+        }
+
+        return rootsIndex.addNewIndexForRoots(newRoots)?.let { newIndex ->
+            updateClasspathFromRootsIndex(newIndex)
+            newIndex.indexedRoots.mapNotNull { (file) ->
+                VfsUtilCore.virtualToIoFile(VfsUtilCore.getVirtualFileForJar(file) ?: file)
+            }.toList()
+        }.orEmpty()
+    }
+
+    private fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? =
+        when (root) {
+            is JvmClasspathRoot ->
+                if (root.file.isFile) findJarRoot(root.file) else findExistingRoot(root, "Classpath entry")
+            is JvmModulePathRoot ->
+                if (root.file.isFile) findJarRoot(root.file) else findExistingRoot(root, "Java module root")
+            is JavaSourceRoot ->
+                findExistingRoot(root, "Java source root")
+            else ->
+                throw IllegalStateException("Unexpected root: $root")
+        }
+
+    internal fun findLocalFile(path: String): VirtualFile? =
+        applicationEnvironment.localFileSystem.findFileByPath(path)
+
+    private fun findExistingRoot(root: JvmContentRoot, rootDescription: String): VirtualFile? {
+        return findLocalFile(root.file.absolutePath).also {
+            if (it == null) {
+                report(STRONG_WARNING, "$rootDescription points to a non-existent location: ${root.file}")
+            }
+        }
+    }
+
+    private fun findJarRoot(file: File): VirtualFile? =
+        applicationEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}")
+
+    private fun getSourceRootsCheckingForDuplicates(): List<KotlinSourceRoot> {
+        val uniqueSourceRoots = hashSetOf<String>()
+        val result = mutableListOf<KotlinSourceRoot>()
+
+        for (root in configuration.kotlinSourceRoots) {
+            if (!uniqueSourceRoots.add(root.path)) {
+                report(STRONG_WARNING, "Duplicate source root: ${root.path}")
+            }
+            result.add(root)
+        }
+
+        return result
+    }
+
+    fun getSourceFiles(): List<KtFile> = sourceFiles
+
+    private fun createKtFiles(project: Project): List<KtFile> =
+        createSourceFilesFromSourceRoots(configuration, project, getSourceRootsCheckingForDuplicates())
+
+    internal fun report(severity: CompilerMessageSeverity, message: String) = configuration.report(severity, message)
+
+    companion object {
+        private val LOG = Logger.getInstance(KotlinCoreEnvironment::class.java)
+
+        private val APPLICATION_LOCK = Object()
+        private var ourApplicationEnvironment: KotlinCoreApplicationEnvironment? = null
+        private var ourProjectCount = 0
+
+        @JvmStatic
+        fun createForProduction(
+            parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
+        ): KotlinCoreEnvironment {
+            setupIdeaStandaloneExecution()
+            val appEnv = getOrCreateApplicationEnvironmentForProduction(parentDisposable, configuration)
+            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
+            val environment = KotlinCoreEnvironment(projectEnv, configuration, configFiles)
+
+            synchronized(APPLICATION_LOCK) {
+                ourProjectCount++
+            }
+            return environment
+        }
+
+        @JvmStatic
+        fun createForProduction(
+            projectEnvironment: JavaCoreProjectEnvironment, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
+        ): KotlinCoreEnvironment {
+            val environment = KotlinCoreEnvironment(projectEnvironment, configuration, configFiles)
+
+            if (projectEnvironment.environment == applicationEnvironment) {
+                // accounting for core environment disposing
+                synchronized(APPLICATION_LOCK) {
+                    ourProjectCount++
+                }
+            }
+            return environment
+        }
+
+        @TestOnly
+        @JvmStatic
+        fun createForTests(
+            parentDisposable: Disposable, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles
+        ): KotlinCoreEnvironment {
+            val configuration = initialConfiguration.copy()
+            // Tests are supposed to create a single project and dispose it right after use
+            val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
+            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
+            return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs)
+        }
+
+        @TestOnly
+        @JvmStatic
+        fun createForTests(
+            projectEnvironment: ProjectEnvironment, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles
+        ): KotlinCoreEnvironment {
+            return KotlinCoreEnvironment(projectEnvironment, initialConfiguration, extensionConfigs)
+        }
+
+        @TestOnly
+        fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment {
+            val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
+            return ProjectEnvironment(parentDisposable, appEnv)
+        }
+
+        // used in the daemon for jar cache cleanup
+        val applicationEnvironment: KotlinCoreApplicationEnvironment? get() = ourApplicationEnvironment
+
+        fun getOrCreateApplicationEnvironmentForProduction(
+            parentDisposable: Disposable, configuration: CompilerConfiguration
+        ): KotlinCoreApplicationEnvironment = getOrCreateApplicationEnvironment(parentDisposable, configuration, unitTestMode = false)
+
+        fun getOrCreateApplicationEnvironmentForTests(
+            parentDisposable: Disposable, configuration: CompilerConfiguration
+        ): KotlinCoreApplicationEnvironment = getOrCreateApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
+
+        private fun getOrCreateApplicationEnvironment(
+            parentDisposable: Disposable, configuration: CompilerConfiguration, unitTestMode: Boolean
+        ): KotlinCoreApplicationEnvironment {
+            synchronized(APPLICATION_LOCK) {
+                if (ourApplicationEnvironment == null) {
+                    val disposable = Disposer.newDisposable()
+                    ourApplicationEnvironment = createApplicationEnvironment(disposable, configuration, unitTestMode)
+                    ourProjectCount = 0
+                    Disposer.register(disposable, Disposable {
+                        synchronized(APPLICATION_LOCK) {
+                            ourApplicationEnvironment = null
+                        }
+                    })
+                }
+                // Disposing of the environment is unsafe in production then parallel builds are enabled, but turning it off universally
+                // breaks a lot of tests, therefore it is disabled for production and enabled for tests
+                if (System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY).toBooleanLenient() != true) {
+                    // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ)
+                    // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well
+                    Disposer.register(parentDisposable, Disposable {
+                        synchronized(APPLICATION_LOCK) {
+                            if (--ourProjectCount <= 0) {
+                                disposeApplicationEnvironment()
+                            }
+                        }
+                    })
+                }
+
+                return ourApplicationEnvironment!!
+            }
+        }
+
+        private fun disposeApplicationEnvironment() {
+            synchronized(APPLICATION_LOCK) {
+                val environment = ourApplicationEnvironment ?: return
+                ourApplicationEnvironment = null
+                Disposer.dispose(environment.parentDisposable)
+                ZipHandler.clearFileAccessorCache()
+            }
+        }
+
+        private fun createApplicationEnvironment(
+            parentDisposable: Disposable, configuration: CompilerConfiguration, unitTestMode: Boolean
+        ): KotlinCoreApplicationEnvironment {
+            val applicationEnvironment = KotlinCoreApplicationEnvironment.create(parentDisposable, unitTestMode)
+
+            registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/compiler.xml")
+            registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/core.xml")
+
+            registerApplicationServicesForCLI(applicationEnvironment)
+            registerApplicationServices(applicationEnvironment)
+
+            return applicationEnvironment
+        }
+
+        private fun registerApplicationExtensionPointsAndExtensionsFrom(configuration: CompilerConfiguration, configFilePath: String) {
+            fun File.hasConfigFile(configFile: String): Boolean =
+                if (isDirectory) File(this, "META-INF" + File.separator + configFile).exists()
+                else try {
+                    ZipFile(this).use {
+                        it.getEntry("META-INF/$configFile") != null
+                    }
+                } catch (e: Throwable) {
+                    false
+                }
+
+            val pluginRoot: File =
+                configuration.get(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT)?.let(::File)
+                    ?: PathUtil.getResourcePathForClass(this::class.java).takeIf { it.hasConfigFile(configFilePath) }
+                    // hack for load extensions when compiler run directly from project directory (e.g. in tests)
+                    ?: File("compiler/cli/cli-common/resources").takeIf { it.hasConfigFile(configFilePath) }
+                    ?: throw IllegalStateException(
+                        "Unable to find extension point configuration $configFilePath " +
+                                "(cp:\n  ${(Thread.currentThread().contextClassLoader as? UrlClassLoader)?.urls?.joinToString("\n  ") { it.file }})"
+                    )
+
+            CoreApplicationEnvironment.registerExtensionPointAndExtensions(
+                FileSystems.getDefault().getPath(pluginRoot.path),
+                configFilePath,
+                ApplicationManager.getApplication().extensionArea
+            )
+        }
+
+        @JvmStatic
+        @Suppress("MemberVisibilityCanPrivate") // made public for CLI Android Lint
+        fun registerPluginExtensionPoints(project: MockProject) {
+            ExpressionCodegenExtension.registerExtensionPoint(project)
+            SyntheticResolveExtension.registerExtensionPoint(project)
+            SyntheticJavaResolveExtension.registerExtensionPoint(project)
+            ClassBuilderInterceptorExtension.registerExtensionPoint(project)
+            AnalysisHandlerExtension.registerExtensionPoint(project)
+            PackageFragmentProviderExtension.registerExtensionPoint(project)
+            StorageComponentContainerContributor.registerExtensionPoint(project)
+            DeclarationAttributeAltererExtension.registerExtensionPoint(project)
+            PreprocessedVirtualFileFactoryExtension.registerExtensionPoint(project)
+            JsSyntheticTranslateExtension.registerExtensionPoint(project)
+            CompilerConfigurationExtension.registerExtensionPoint(project)
+            CollectAdditionalSourcesExtension.registerExtensionPoint(project)
+            ExtraImportsProviderExtension.registerExtensionPoint(project)
+            IrGenerationExtension.registerExtensionPoint(project)
+            ScriptEvaluationExtension.registerExtensionPoint(project)
+            ShellExtension.registerExtensionPoint(project)
+            TypeResolutionInterceptor.registerExtensionPoint(project)
+            CandidateInterceptor.registerExtensionPoint(project)
+            DescriptorSerializerPlugin.registerExtensionPoint(project)
+        }
+
+        internal fun registerExtensionsFromPlugins(project: MockProject, configuration: CompilerConfiguration) {
+            val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+            for (registrar in configuration.getList(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
+                try {
+                    registrar.registerProjectComponents(project, configuration)
+                } catch (e: AbstractMethodError) {
+                    val message = "The provided plugin ${registrar.javaClass.name} is not compatible with this version of compiler"
+                    // Since the scripting plugin is often discovered in the compiler environment, it is often taken from the incompatible
+                    // location, and in many cases this is not a fatal error, therefore strong warning is generated instead of exception
+                    if (registrar.javaClass.simpleName == "ScriptingCompilerConfigurationComponentRegistrar") {
+                        messageCollector?.report(STRONG_WARNING, "Default scripting plugin is disabled: $message")
+                    } else {
+                        throw IllegalStateException(message, e)
+                    }
+                }
+            }
+        }
+
+
+        private fun registerApplicationServicesForCLI(applicationEnvironment: KotlinCoreApplicationEnvironment) {
+            // ability to get text from annotations xml files
+            applicationEnvironment.registerFileType(PlainTextFileType.INSTANCE, "xml")
+            applicationEnvironment.registerParserDefinition(JavaParserDefinition())
+        }
+
+        // made public for Upsource
+        @Suppress("MemberVisibilityCanBePrivate")
+        @JvmStatic
+        fun registerApplicationServices(applicationEnvironment: KotlinCoreApplicationEnvironment) {
+            with(applicationEnvironment) {
+                registerFileType(KotlinFileType.INSTANCE, "kt")
+                registerFileType(KotlinFileType.INSTANCE, KotlinParserDefinition.STD_SCRIPT_SUFFIX)
+                registerParserDefinition(KotlinParserDefinition())
+                application.registerService(KotlinBinaryClassCache::class.java, KotlinBinaryClassCache())
+                application.registerService(JavaClassSupers::class.java, JavaClassSupersImpl::class.java)
+                application.registerService(TransactionGuard::class.java, TransactionGuardImpl::class.java)
+            }
+        }
+
+        @JvmStatic
+        fun registerProjectExtensionPoints(area: ExtensionsArea) {
+            CoreApplicationEnvironment.registerExtensionPoint(
+                area, PsiTreeChangePreprocessor.EP.name, PsiTreeChangePreprocessor::class.java
+            )
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP.name, PsiElementFinder::class.java)
+
+            IdeaExtensionPoints.registerVersionSpecificProjectExtensionPoints(area)
+        }
+
+        // made public for Upsource
+        @JvmStatic
+        @Deprecated("Use registerProjectServices(project) instead.", ReplaceWith("registerProjectServices(projectEnvironment.project)"))
+        fun registerProjectServices(
+            projectEnvironment: JavaCoreProjectEnvironment,
+            @Suppress("UNUSED_PARAMETER") messageCollector: MessageCollector?
+        ) {
+            registerProjectServices(projectEnvironment.project)
+        }
+
+        // made public for Android Lint
+        @JvmStatic
+        fun registerProjectServices(project: MockProject) {
+            with(project) {
+                registerService(KotlinJavaPsiFacade::class.java, KotlinJavaPsiFacade(this))
+                registerService(FacadeCache::class.java, FacadeCache(this))
+                registerService(ModuleAnnotationsResolver::class.java, CliModuleAnnotationsResolver())
+            }
+        }
+
+        private fun registerProjectServicesForCLI(@Suppress("UNUSED_PARAMETER") projectEnvironment: JavaCoreProjectEnvironment) {
+            /**
+             * Note that Kapt may restart code analysis process, and CLI services should be aware of that.
+             * Use PsiManager.getModificationTracker() to ensure that all the data you cached is still valid.
+             */
+        }
+
+        // made public for Android Lint
+        @JvmStatic
+        fun registerKotlinLightClassSupport(project: MockProject) {
+            with(project) {
+                val traceHolder = CliTraceHolder()
+                val cliLightClassGenerationSupport = CliLightClassGenerationSupport(traceHolder, project)
+                val kotlinAsJavaSupport = CliKotlinAsJavaSupport(this, traceHolder)
+                registerService(LightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
+                registerService(CliLightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
+                registerService(KotlinAsJavaSupport::class.java, kotlinAsJavaSupport)
+                registerService(CodeAnalyzerInitializer::class.java, traceHolder)
+                @Suppress("UnstableApiUsage")
+                registerService(DumbUtil::class.java, KotlinCoreDumbUtil())
+
+                // We don't pass Disposable because in some tests, we manually unregister these extensions, and that leads to LOG.error
+                // exception from `ExtensionPointImpl.doRegisterExtension`, because the registered extension can no longer be found
+                // when the project is being disposed.
+                // For example, see the `unregisterExtension` call in `GenerationUtils.compileFilesUsingFrontendIR`.
+                // TODO: refactor this to avoid registering unneeded extensions in the first place, and avoid using deprecated API.
+                @Suppress("DEPRECATION")
+                PsiElementFinder.EP.getPoint(project).registerExtension(JavaElementFinder(this))
+                @Suppress("DEPRECATION")
+                PsiElementFinder.EP.getPoint(project).registerExtension(PsiElementFinderImpl(this))
+            }
+        }
+
+        private fun CompilerConfiguration.setupJdkClasspathRoots(configFiles: EnvironmentConfigFiles) {
+            if (getBoolean(JVMConfigurationKeys.NO_JDK)) return
+
+            val jvmTarget = configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES
+            if (!jvmTarget) return
+
+            val jdkHome = get(JVMConfigurationKeys.JDK_HOME)
+            val (javaRoot, classesRoots) = if (jdkHome == null) {
+                val javaHome = File(System.getProperty("java.home"))
+                put(JVMConfigurationKeys.JDK_HOME, javaHome)
+
+                javaHome to PathUtil.getJdkClassesRootsFromCurrentJre()
+            } else {
+                jdkHome to PathUtil.getJdkClassesRoots(jdkHome)
+            }
+
+            if (!CoreJrtFileSystem.isModularJdk(javaRoot)) {
+                if (classesRoots.isEmpty()) {
+                    report(ERROR, "No class roots are found in the JDK path: $javaRoot")
+                } else {
+                    addJvmSdkRoots(classesRoots)
+                }
+            }
+        }
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/ByteArrayCharSequence.kt

@@ -1,40 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
-
-class ByteArrayCharSequence(
-    private val bytes: ByteArray,
-    private val start: Int = 0,
-    private val end: Int = bytes.size
-) : CharSequence {
-
-    override fun hashCode(): Int {
-        error("Do not try computing hashCode ByteArrayCharSequence")
-    }
-
-    override fun equals(other: Any?): Boolean {
-        error("Do not try comparing ByteArrayCharSequence")
-    }
-
-    override val length get() = end - start
-
-    override fun get(index: Int): Char = bytes[index + start].toChar()
-
-    override fun subSequence(startIndex: Int, endIndex: Int): CharSequence {
-        if (startIndex == 0 && endIndex == length) return this
-        return ByteArrayCharSequence(bytes, start + startIndex, start + endIndex)
-    }
-
-    override fun toString(): String {
-        val chars = CharArray(length)
-
-        for (i in 0 until length) {
-            chars[i] = bytes[i + start].toChar()
-        }
-
-        return String(chars)
-    }
-}
-

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/FastJarFileSystem.kt

@@ -1,115 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
-
-import com.intellij.openapi.util.Couple
-import com.intellij.openapi.vfs.DeprecatedVirtualFileSystem
-import com.intellij.openapi.vfs.StandardFileSystems
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.util.containers.ConcurrentFactoryMap
-import com.intellij.util.io.FileAccessorCache
-import java.io.File
-import java.io.IOException
-import java.io.RandomAccessFile
-import java.nio.ByteBuffer
-import java.nio.MappedByteBuffer
-import java.nio.channels.FileChannel
-
-private typealias RandomAccessFileAndBuffer = Pair<RandomAccessFile, MappedByteBuffer>
-
-class FastJarFileSystem private constructor(internal val unmapBuffer: MappedByteBuffer.() -> Unit) : DeprecatedVirtualFileSystem() {
-    private val myHandlers: MutableMap<String, FastJarHandler> =
-        ConcurrentFactoryMap.createMap { key: String -> FastJarHandler(this@FastJarFileSystem, key) }
-
-    internal val cachedOpenFileHandles: FileAccessorCache<File, RandomAccessFileAndBuffer> =
-        object : FileAccessorCache<File, RandomAccessFileAndBuffer>(20, 10) {
-            @Throws(IOException::class)
-            override fun createAccessor(file: File): RandomAccessFileAndBuffer {
-                val randomAccessFile = RandomAccessFile(file, "r")
-                return Pair(randomAccessFile, randomAccessFile.channel.map(FileChannel.MapMode.READ_ONLY, 0, randomAccessFile.length()))
-            }
-
-            @Throws(IOException::class)
-            override fun disposeAccessor(fileAccessor: RandomAccessFileAndBuffer) {
-                fileAccessor.first.close()
-                fileAccessor.second.unmapBuffer()
-            }
-
-            override fun isEqual(val1: File, val2: File): Boolean {
-                return val1 == val2 // reference equality to handle different jars for different ZipHandlers on the same path
-            }
-        }
-
-    override fun getProtocol(): String {
-        return StandardFileSystems.JAR_PROTOCOL
-    }
-
-    override fun findFileByPath(path: String): VirtualFile? {
-        val pair = splitPath(path)
-        return myHandlers[pair.first]!!.findFileByPath(pair.second)
-    }
-
-    override fun refresh(asynchronous: Boolean) {}
-    override fun refreshAndFindFileByPath(path: String): VirtualFile? {
-        return findFileByPath(path)
-    }
-
-    fun clearHandlersCache() {
-        myHandlers.clear()
-        cachedOpenFileHandles.clear()
-    }
-
-    companion object {
-        fun splitPath(path: String): Couple<String> {
-            val separator = path.indexOf("!/")
-            require(separator >= 0) { "Path in JarFileSystem must contain a separator: $path" }
-            val localPath = path.substring(0, separator)
-            val pathInJar = path.substring(separator + 2)
-            return Couple.of(localPath, pathInJar)
-        }
-
-        fun createIfUnmappingPossible(): FastJarFileSystem? {
-            val cleanerCallBack = prepareCleanerCallback() ?: return null
-            return FastJarFileSystem(cleanerCallBack)
-        }
-    }
-}
-
-
-private val IS_PRIOR_9_JRE = System.getProperty("java.specification.version", "").startsWith("1.")
-
-private fun prepareCleanerCallback(): ((ByteBuffer) -> Unit)? {
-    return try {
-        if (IS_PRIOR_9_JRE) {
-            val cleaner = Class.forName("java.nio.DirectByteBuffer").getMethod("cleaner")
-            cleaner.isAccessible = true
-
-            val clean = Class.forName("sun.misc.Cleaner").getMethod("clean")
-            clean.isAccessible = true
-
-            { buffer: ByteBuffer -> clean.invoke(cleaner.invoke(buffer)) }
-        } else {
-            val unsafeClass = try {
-                Class.forName("sun.misc.Unsafe")
-            } catch (ex: Exception) {
-                // jdk.internal.misc.Unsafe doesn't yet have an invokeCleaner() method,
-                // but that method should be added if sun.misc.Unsafe is removed.
-                Class.forName("jdk.internal.misc.Unsafe")
-            }
-
-            val clean = unsafeClass.getMethod("invokeCleaner", ByteBuffer::class.java)
-            clean.isAccessible = true
-
-            val theUnsafeField = unsafeClass.getDeclaredField("theUnsafe")
-            theUnsafeField.isAccessible = true
-
-            val theUnsafe = theUnsafeField.get(null);
-
-            { buffer: ByteBuffer -> clean.invoke(theUnsafe, buffer) }
-        }
-    } catch (ex: Exception) {
-        null
-    }
-}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/FastJarHandler.kt

@@ -1,107 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
-
-import com.intellij.openapi.util.text.StringUtil
-import com.intellij.openapi.vfs.VirtualFile
-import java.io.File
-import java.io.FileNotFoundException
-import java.io.RandomAccessFile
-import java.nio.channels.FileChannel
-
-class FastJarHandler(val fileSystem: FastJarFileSystem, path: String) {
-    private val myRoot: VirtualFile?
-    internal val file = File(path)
-
-    private val cachedManifest: ByteArray?
-
-    init {
-        val entries: List<ZipEntryDescription>
-        RandomAccessFile(file, "r").use { randomAccessFile ->
-            val mappedByteBuffer = randomAccessFile.channel.map(FileChannel.MapMode.READ_ONLY, 0, randomAccessFile.length())
-            try {
-                entries = mappedByteBuffer.parseCentralDirectory()
-                cachedManifest =
-                    entries.singleOrNull { StringUtil.equals(MANIFEST_PATH, it.relativePath) }
-                        ?.let(mappedByteBuffer::contentsToByteArray)
-            } finally {
-                with(fileSystem) {
-                    mappedByteBuffer.unmapBuffer()
-                }
-            }
-        }
-
-        myRoot = FastJarVirtualFile(this, "", -1, parent = null, entryDescription = null)
-
-        // ByteArrayCharSequence should not be used instead of String
-        // because the former class does not support equals/hashCode properly
-        val filesByRelativePath = HashMap<String, FastJarVirtualFile>(entries.size)
-        filesByRelativePath[""] = myRoot
-
-        for (entryDescription in entries) {
-            if (!entryDescription.isDirectory) {
-                createFile(entryDescription, filesByRelativePath)
-            } else {
-                getOrCreateDirectory(entryDescription.relativePath, filesByRelativePath)
-            }
-        }
-
-        for (node in filesByRelativePath.values) {
-            node.initChildrenArrayFromList()
-        }
-    }
-
-    private fun createFile(entry: ZipEntryDescription, directories: MutableMap<String, FastJarVirtualFile>): FastJarVirtualFile {
-        val (parentName, shortName) = entry.relativePath.splitPath()
-
-        val parentFile = getOrCreateDirectory(parentName, directories)
-        if ("." == shortName) {
-            return parentFile
-        }
-
-        return FastJarVirtualFile(
-            this, shortName,
-            if (entry.isDirectory) -1 else entry.uncompressedSize,
-            parentFile,
-            entry,
-        )
-    }
-
-    private fun getOrCreateDirectory(entryName: CharSequence, directories: MutableMap<String, FastJarVirtualFile>): FastJarVirtualFile {
-        return directories.getOrPut(entryName.toString()) {
-            val (parentPath, shortName) = entryName.splitPath()
-            val parentFile = getOrCreateDirectory(parentPath, directories)
-
-            FastJarVirtualFile(this, shortName, -1, parentFile, entryDescription = null)
-        }
-    }
-
-    private fun CharSequence.splitPath(): Pair<CharSequence, CharSequence> {
-        var slashIndex = this.length - 1
-
-        while (slashIndex >= 0 && this[slashIndex] != '/') {
-            slashIndex--
-        }
-
-        if (slashIndex == -1) return Pair("", this)
-        return Pair(subSequence(0, slashIndex), subSequence(slashIndex + 1, this.length))
-    }
-
-    fun findFileByPath(pathInJar: String): VirtualFile? {
-        return myRoot?.findFileByRelativePath(pathInJar)
-    }
-
-    fun contentsToByteArray(zipEntryDescription: ZipEntryDescription): ByteArray {
-        val relativePath = zipEntryDescription.relativePath
-        if (StringUtil.equals(relativePath, MANIFEST_PATH)) return cachedManifest ?: throw FileNotFoundException("$file!/$relativePath")
-        return fileSystem.cachedOpenFileHandles[file].use {
-            synchronized(it) {
-                it.get().second.contentsToByteArray(zipEntryDescription)
-            }
-        }
-    }
-}
-
-private const val MANIFEST_PATH = "META-INF/MANIFEST.MF"

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/FastJarVirtualFile.kt

@@ -1,108 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
-
-import com.intellij.openapi.util.io.BufferExposingByteArrayInputStream
-import com.intellij.openapi.util.io.FileUtil
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.openapi.vfs.VirtualFileSystem
-import java.io.IOException
-import java.io.InputStream
-import java.io.OutputStream
-
-internal class FastJarVirtualFile(
-    private val handler: FastJarHandler,
-    private val name: CharSequence,
-    private val length: Int,
-    private val parent: FastJarVirtualFile?,
-    private val entryDescription: ZipEntryDescription?,
-) : VirtualFile() {
-
-    private var myChildrenArray = EMPTY_ARRAY
-    private val myChildrenList: MutableList<VirtualFile> = mutableListOf()
-
-    init {
-        parent?.myChildrenList?.add(this)
-    }
-
-    fun initChildrenArrayFromList() {
-        myChildrenArray = myChildrenList.toTypedArray()
-        myChildrenList.clear()
-    }
-
-    override fun getName(): String {
-        return name.toString()
-    }
-
-    override fun getNameSequence(): CharSequence {
-        return name
-    }
-
-    override fun getFileSystem(): VirtualFileSystem {
-        return handler.fileSystem
-    }
-
-    override fun getPath(): String {
-        if (parent == null) {
-            return FileUtil.toSystemIndependentName(handler.file.path) + "!/"
-        }
-        val parentPath = parent.path
-        val answer = StringBuilder(parentPath.length + 1 + name.length)
-        answer.append(parentPath)
-        if (answer[answer.length - 1] != '/') {
-            answer.append('/')
-        }
-        answer.append(name)
-        return answer.toString()
-    }
-
-    override fun isWritable(): Boolean {
-        return false
-    }
-
-    override fun isDirectory(): Boolean {
-        return length < 0
-    }
-
-    override fun isValid(): Boolean {
-        return true
-    }
-
-    override fun getParent(): VirtualFile? {
-        return parent
-    }
-
-    override fun getChildren(): Array<VirtualFile> {
-        return myChildrenArray
-    }
-
-    @Throws(IOException::class)
-    override fun getOutputStream(requestor: Any, newModificationStamp: Long, newTimeStamp: Long): OutputStream {
-        throw UnsupportedOperationException("JarFileSystem is read-only")
-    }
-
-    @Throws(IOException::class)
-    override fun contentsToByteArray(): ByteArray {
-        if (entryDescription == null) return EMPTY_BYTE_ARRAY
-        return handler.contentsToByteArray(entryDescription)
-    }
-
-    override fun getTimeStamp(): Long = 0
-
-    override fun getLength(): Long = length.toLong()
-
-    override fun refresh(asynchronous: Boolean, recursive: Boolean, postRunnable: Runnable?) {}
-
-    @Throws(IOException::class)
-    override fun getInputStream(): InputStream {
-        return BufferExposingByteArrayInputStream(contentsToByteArray())
-    }
-
-    override fun getModificationStamp(): Long {
-        return 0
-    }
-}
-
-private val EMPTY_BYTE_ARRAY = ByteArray(0)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/ZipImplementation.kt

@@ -1,129 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
-
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import java.nio.MappedByteBuffer
-import java.util.zip.Inflater
-
-
-class ZipEntryDescription(
-    val relativePath: CharSequence,
-    val compressedSize: Int,
-    val uncompressedSize: Int,
-    val offsetInFile: Int,
-    val compressionKind: CompressionKind,
-    val fileNameSize: Int,
-) {
-
-    enum class CompressionKind {
-        PLAIN, DEFLATE
-    }
-
-    val isDirectory get() = uncompressedSize == 0
-}
-
-private const val END_OF_CENTRAL_DIR_SIZE = 22
-private const val LOCAL_FILE_HEADER_EXTRA_OFFSET = 28
-private const val LOCAL_FILE_HEADER_SIZE = LOCAL_FILE_HEADER_EXTRA_OFFSET + 2
-
-fun MappedByteBuffer.contentsToByteArray(
-    zipEntryDescription: ZipEntryDescription
-): ByteArray {
-    order(ByteOrder.LITTLE_ENDIAN)
-    val extraSize =
-        getUnsignedShort(zipEntryDescription.offsetInFile + LOCAL_FILE_HEADER_EXTRA_OFFSET)
-
-    position(
-        zipEntryDescription.offsetInFile + LOCAL_FILE_HEADER_SIZE + zipEntryDescription.fileNameSize + extraSize
-    )
-    val compressed = ByteArray(zipEntryDescription.compressedSize + 1)
-    get(compressed, 0, zipEntryDescription.compressedSize)
-
-    return when (zipEntryDescription.compressionKind) {
-        ZipEntryDescription.CompressionKind.DEFLATE -> {
-            val inflater = Inflater(true)
-            inflater.setInput(compressed, 0, zipEntryDescription.compressedSize)
-
-            val result = ByteArray(zipEntryDescription.uncompressedSize)
-
-            inflater.inflate(result)
-
-            result
-        }
-        ZipEntryDescription.CompressionKind.PLAIN -> compressed.copyOf(zipEntryDescription.compressedSize)
-    }
-}
-
-fun MappedByteBuffer.parseCentralDirectory(): List<ZipEntryDescription> {
-    order(ByteOrder.LITTLE_ENDIAN)
-
-    var endOfCentralDirectoryOffset = capacity() - END_OF_CENTRAL_DIR_SIZE
-    while (endOfCentralDirectoryOffset >= 0) {
-        // header of "End of central directory"
-        if (getInt(endOfCentralDirectoryOffset) == 0x06054b50) break
-        endOfCentralDirectoryOffset--
-    }
-
-    val entriesNumber = getUnsignedShort(endOfCentralDirectoryOffset + 10)
-    val offsetOfCentralDirectory = getInt(endOfCentralDirectoryOffset + 16)
-
-    var currentOffset = offsetOfCentralDirectory
-
-    val result = mutableListOf<ZipEntryDescription>()
-    for (i in 0 until entriesNumber) {
-        val headerConst = getInt(currentOffset)
-        require(headerConst == 0x02014b50) {
-            "$i: $headerConst"
-        }
-
-        val versionNeededToExtract =
-            getShort(currentOffset + 6).toInt()
-
-        val compressionMethod = getShort(currentOffset + 10).toInt()
-
-        val compressedSize = getInt(currentOffset + 20)
-        val uncompressedSize = getInt(currentOffset + 24)
-        val fileNameLength = getUnsignedShort(currentOffset + 28).toInt()
-        val extraLength = getUnsignedShort(currentOffset + 30).toInt()
-        val fileCommentLength = getUnsignedShort(currentOffset + 32).toInt()
-
-        val offsetOfFileData = getInt(currentOffset + 42)
-
-        val bytesForName = ByteArray(fileNameLength)
-
-        position(currentOffset + 46)
-        get(bytesForName)
-
-        val name =
-            if (bytesForName.all { it >= 0 })
-                ByteArrayCharSequence(bytesForName)
-            else
-                String(bytesForName, Charsets.UTF_8)
-
-        currentOffset += 46 + fileNameLength + extraLength + fileCommentLength
-
-        require(versionNeededToExtract == 10 || versionNeededToExtract == 20) {
-            "Unexpected versionNeededToExtract ($versionNeededToExtract) at $name"
-        }
-
-        val compressionKind = when (compressionMethod) {
-            0 -> ZipEntryDescription.CompressionKind.PLAIN
-            8 -> ZipEntryDescription.CompressionKind.DEFLATE
-            else -> error("Unexpected compression method ($compressionMethod) at $name")
-        }
-
-        result += ZipEntryDescription(
-            name, compressedSize, uncompressedSize, offsetOfFileData, compressionKind,
-            fileNameLength
-        )
-    }
-
-    return result
-}
-
-private fun ByteBuffer.getUnsignedShort(offset: Int): Int = java.lang.Short.toUnsignedInt(getShort(offset))

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

@@ -254,9 +254,6 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
 
     put(JVMConfigurationKeys.SERIALIZE_IR, arguments.serializeIr)
 
-    put(JVMConfigurationKeys.VALIDATE_IR, arguments.validateIr)
-    put(JVMConfigurationKeys.VALIDATE_BYTECODE, arguments.validateBytecode)
-
     if (!JVMConstructorCallNormalizationMode.isSupportedValue(arguments.constructorCallNormalizationMode)) {
         messageCollector.report(
             ERROR,
@@ -283,16 +280,11 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
     put(JVMConfigurationKeys.USE_TYPE_TABLE, arguments.useTypeTable)
     put(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK, arguments.skipRuntimeVersionCheck)
     put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, arguments.useOldClassFilesReading)
-    put(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM, arguments.useFastJarFileSystem)
 
     if (arguments.useOldClassFilesReading) {
         messageCollector.report(INFO, "Using the old java class files reading implementation")
     }
 
-    if (arguments.useFastJarFileSystem) {
-        messageCollector.report(INFO, "Using fast Jar FS implementation")
-    }
-
     put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
     put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)
     put(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS, arguments.useOldSpilledVarTypeAnalysis)

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

@@ -99,9 +99,6 @@ public class JVMConfigurationKeys {
     public static final CompilerConfigurationKey<Boolean> USE_PSI_CLASS_FILES_READING =
             CompilerConfigurationKey.create("use a slower (PSI-based) class files reading implementation");
 
-    public static final CompilerConfigurationKey<Boolean> USE_FAST_JAR_FILE_SYSTEM =
-            CompilerConfigurationKey.create("use a faster JAR filesystem implementation");
-
     public static final CompilerConfigurationKey<Boolean> USE_JAVAC =
             CompilerConfigurationKey.create("use javac [experimental]");
 
@@ -157,11 +154,5 @@ public class JVMConfigurationKeys {
             CompilerConfigurationKey.create("Don't automatically include kotlin-reflect.jar into the output if the output is a jar");
 
     public static final CompilerConfigurationKey<Boolean> SERIALIZE_IR =
-            CompilerConfigurationKey.create("Serialize IR to class metadata");
-
-    public static final CompilerConfigurationKey<Boolean> VALIDATE_IR =
-            CompilerConfigurationKey.create("Validate IR");
-
-    public static final CompilerConfigurationKey<Boolean> VALIDATE_BYTECODE =
-            CompilerConfigurationKey.create("Validate generated JVM bytecode");
+            CompilerConfigurationKey.create("serialize IR to class metadata");
 }

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

@@ -33,7 +33,6 @@ enum class JvmTarget(
     JVM_14("14", Opcodes.V12 + 2),
     JVM_15("15", Opcodes.V12 + 3),
     JVM_16("16", Opcodes.V12 + 4),
-    JVM_17("17", Opcodes.V12 + 5),
     ;
 
     companion object {

compiler/daemon/daemon-client-new/build.gradle.kts

@@ -49,7 +49,7 @@ dependencies {
 
 tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
     kotlinOptions {
-        apiVersion = "1.4"
+        apiVersion = "1.3"
         freeCompilerArgs += "-Xsuppress-version-warnings"
     }
 }

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

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.daemon.client.experimental
 
-import io.ktor.network.sockets.*
+import io.ktor.network.sockets.Socket
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
@@ -438,7 +438,6 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
             .thenBy(FileAgeComparator()) { it.runFile }
         val optsCopy = daemonJVMOptions.copy()
         // if required options fit into fattest running daemon - return the daemon and required options with memory params set to actual ones in the daemon
-        @Suppress("DEPRECATION") // TODO: replace with maxWithOrNull as soon as minimal version of Gradle that we support has Kotlin 1.4+.
         aliveWithMetadata.maxWith(comparator)
             ?.takeIf { daemonJVMOptions memorywiseFitsInto it.jvmOptions }
             ?.let {

compiler/daemon/daemon-client/build.gradle.kts

@@ -40,8 +40,8 @@ dependencies {
 
 tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
     kotlinOptions {
-        // This module is being run from within Gradle, older versions of which only have older kotlin-stdlib in the runtime classpath.
-        apiVersion = "1.4"
+        // This module is being run from within Gradle, older versions of which only have kotlin-stdlib 1.3 in the runtime classpath.
+        apiVersion = "1.3"
         freeCompilerArgs += "-Xsuppress-version-warnings"
     }
 }

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

@@ -359,7 +359,6 @@ object KotlinCompilerClient {
                 .thenBy(FileAgeComparator()) { it.runFile }
         val optsCopy = daemonJVMOptions.copy()
         // if required options fit into fattest running daemon - return the daemon and required options with memory params set to actual ones in the daemon
-        @Suppress("DEPRECATION") // TODO: replace with maxWithOrNull as soon as minimal version of Gradle that we support has Kotlin 1.4+.
         return aliveWithMetadata.maxWith(comparator)?.takeIf { daemonJVMOptions memorywiseFitsInto it.jvmOptions }?.let {
                 Pair(it.daemon, optsCopy.updateMemoryUpperBounds(it.jvmOptions))
             }
@@ -378,7 +377,7 @@ object KotlinCompilerClient {
         val javaVersion = CompilerSystemProperties.JAVA_VERSION.value?.toIntOrNull()
         val javaIllegalAccessWorkaround =
             if (javaVersion != null && javaVersion >= 16)
-                listOf("--add-exports", "java.base/sun.nio.ch=ALL-UNNAMED")
+                listOf("--illegal-access=permit")
             else emptyList()
         val args = listOf(
                    javaExecutable.absolutePath, "-cp", compilerId.compilerClasspath.joinToString(File.pathSeparator)) +

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

@@ -1,9 +1,9 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
-@file:OptIn(ExperimentalPathApi::class, DelicateCoroutinesApi::class)
+@file:OptIn(ExperimentalPathApi::class)
 
 package org.jetbrains.kotlin.daemon.experimental.integration
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ClientSerializationTest.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.daemon.experimental.unit
 
 import io.ktor.network.sockets.aSocket
 import io.ktor.util.*
-import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
@@ -32,7 +31,6 @@ class TestServer(val serverPort: Int = 6999) {
     private val serverSocket = aSocket(selectorMgr).tcp().bind(InetSocketAddress(serverPort))
     private val log = Logger.getLogger("TestServer")
 
-    @OptIn(DelicateCoroutinesApi::class)
     fun awaitClient() = GlobalScope.async {
         log.info("accepting clientSocket...")
         val client = serverSocket.accept()
@@ -63,7 +61,7 @@ class ClientSerializationTest : KotlinIntegrationTestBase() {
             }
         }
         log.info("printed")
-        var client2: T?
+        var client2: T? = null
         var connected = false
         runBlocking {
             val clientAwait = testServer.awaitClient()

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

@@ -21,7 +21,9 @@ import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.impl.ZipHandler
 import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import org.jetbrains.kotlin.build.DEFAULT_KOTLIN_SOURCE_FILES_EXTENSIONS
+import org.jetbrains.kotlin.build.report.BuildReporter
 import org.jetbrains.kotlin.build.report.RemoteBuildReporter
+import org.jetbrains.kotlin.build.report.RemoteReporter
 import org.jetbrains.kotlin.cli.common.CLICompiler
 import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.ExitCode
@@ -35,15 +37,10 @@ import org.jetbrains.kotlin.cli.common.repl.ReplEvalResult
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarFileSystem
-import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarHandler
 import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.common.*
-import org.jetbrains.kotlin.daemon.report.CompileServicesFacadeMessageCollector
-import org.jetbrains.kotlin.daemon.report.DaemonMessageReporter
-import org.jetbrains.kotlin.daemon.report.DaemonMessageReporterPrintStreamAdapter
-import org.jetbrains.kotlin.daemon.report.getBuildReporter
+import org.jetbrains.kotlin.daemon.report.*
 import org.jetbrains.kotlin.incremental.*
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker

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

@@ -66,8 +66,7 @@ abstract class KotlinJvmReplServiceBase(
             val projectEnvironment =
                 KotlinCoreEnvironment.ProjectEnvironment(
                     disposable,
-                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(disposable, configuration),
-                    configuration,
+                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(disposable, configuration)
                 )
             ReplFactoryExtension.registerExtensionPoint(projectEnvironment.project)
             projectEnvironment.registerExtensionsFromPlugins(configuration)
@@ -224,4 +223,4 @@ fun CompilerConfiguration.configureScripting(compilerId: CompilerId) {
             error
         )
     }
-}
+}

compiler/daemon/src/org/jetbrains/kotlin/daemon/experimental/CompileServiceServerSideImpl.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.cli.common.repl.ReplCompileResult
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarFileSystem
 import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.CompileServiceImplBase

compiler/fir/analysis-tests/build.gradle.kts

@@ -36,7 +36,12 @@ dependencies {
         includeJars("jna", rootProject = rootProject)
     }
 
-    testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
+    Platform[202] {
+        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.3.1-1") }
+    }
+    Platform[203].orHigher {
+        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
+    }
     testRuntimeOnly(toolsJar())
 }
 

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

@@ -29,11 +29,6 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
     }
 
-    @TestMetadata("annotationOnDeclarationWithDifferentArguments.kt")
-    public void testAnnotationOnDeclarationWithDifferentArguments() throws Exception {
-        runTest("compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt");
-    }
-
     @TestMetadata("annotationUsedAsAnnotationArgument.kt")
     public void testAnnotationUsedAsAnnotationArgument() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.kt");
@@ -69,11 +64,6 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         runTest("compiler/fir/analysis-tests/testData/resolve/catchParameter.kt");
     }
 
-    @TestMetadata("classCallInLambda.kt")
-    public void testClassCallInLambda() throws Exception {
-        runTest("compiler/fir/analysis-tests/testData/resolve/classCallInLambda.kt");
-    }
-
     @TestMetadata("companion.kt")
     public void testCompanion() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/companion.kt");
@@ -621,11 +611,6 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/arguments/namedArrayInAnnotation.kt");
         }
 
-        @TestMetadata("nestedClassInAnnotationArgument.kt")
-        public void testNestedClassInAnnotationArgument() throws Exception {
-            runTest("compiler/fir/analysis-tests/testData/resolve/arguments/nestedClassInAnnotationArgument.kt");
-        }
-
         @TestMetadata("noParameterForName.kt")
         public void testNoParameterForName() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/arguments/noParameterForName.kt");
@@ -2590,11 +2575,6 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
-        @TestMetadata("anonymousInAnonymous.kt")
-        public void testAnonymousInAnonymous() throws Exception {
-            runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/anonymousInAnonymous.kt");
-        }
-
         @TestMetadata("implicitInAnonymous.kt")
         public void testImplicitInAnonymous() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/implicitInAnonymous.kt");
@@ -2701,11 +2681,6 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/overrides/protobufExt.kt");
         }
 
-        @TestMetadata("sameValueParametersDifferentReceiver.kt")
-        public void testSameValueParametersDifferentReceiver() throws Exception {
-            runTest("compiler/fir/analysis-tests/testData/resolve/overrides/sameValueParametersDifferentReceiver.kt");
-        }
-
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt");
@@ -3069,11 +3044,6 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt");
         }
 
-        @TestMetadata("incorrectSmartcastToNothing.kt")
-        public void testIncorrectSmartcastToNothing() throws Exception {
-            runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/incorrectSmartcastToNothing.kt");
-        }
-
         @TestMetadata("kt10240.kt")
         public void testKt10240() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt");

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

@@ -1,54 +0,0 @@
-FILE: annotationOnDeclarationWithDifferentArguments.kt
-    public final enum class SomeEnum : R|kotlin/Enum<SomeEnum>| {
-        private constructor(): R|SomeEnum| {
-            super<R|kotlin/Enum<SomeEnum>|>()
-        }
-
-        public final static enum entry A: R|SomeEnum|
-        public final static enum entry B: R|SomeEnum|
-        public final static fun values(): R|kotlin/Array<SomeEnum>| {
-        }
-
-        public final static fun valueOf(value: R|kotlin/String|): R|SomeEnum| {
-        }
-
-    }
-    public final annotation class MyAnnotation : R|kotlin/Annotation| {
-        public constructor(intValue: R|kotlin/Int|, stringValue: R|kotlin/String|, enumValue: R|SomeEnum|, kClasses: R|kotlin/Array<out kotlin/reflect/KClass<*>>|, annotation: R|MyOtherAnnotation|): R|MyAnnotation| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final val intValue: R|kotlin/Int| = R|<local>/intValue|
-            public get(): R|kotlin/Int|
-
-        public final val stringValue: R|kotlin/String| = R|<local>/stringValue|
-            public get(): R|kotlin/String|
-
-        public final val enumValue: R|SomeEnum| = R|<local>/enumValue|
-            public get(): R|SomeEnum|
-
-        public final val kClasses: R|kotlin/Array<out kotlin/reflect/KClass<*>>| = R|<local>/kClasses|
-            public get(): R|kotlin/Array<out kotlin/reflect/KClass<*>>|
-
-        public final val annotation: R|MyOtherAnnotation| = R|<local>/annotation|
-            public get(): R|MyOtherAnnotation|
-
-    }
-    public final annotation class MyOtherAnnotation : R|kotlin/Annotation| {
-        public constructor(intValue: R|kotlin/Int|, stringValue: R|kotlin/String|): R|MyOtherAnnotation| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final val intValue: R|kotlin/Int| = R|<local>/intValue|
-            public get(): R|kotlin/Int|
-
-        public final val stringValue: R|kotlin/String| = R|<local>/stringValue|
-            public get(): R|kotlin/String|
-
-    }
-    public final const val constInt: R|kotlin/Int| = Int(10)
-        public get(): R|kotlin/Int|
-    public final const val constString: R|kotlin/String| = String()
-        public get(): R|kotlin/String|
-    @R|MyAnnotation|(intValue = Int(10), stringValue = R|/constString|, enumValue = Q|SomeEnum|.R|/SomeEnum.A|, kClasses = <implicitArrayOf>(<getClass>(Q|kotlin/String|), <getClass>(R|/constString|)), annotation = R|/MyOtherAnnotation.MyOtherAnnotation|(intValue = R|/constInt|, stringValue = String(hello))) public final fun foo(): R|kotlin/Unit| {
-    }

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

@@ -1,30 +0,0 @@
-import kotlin.reflect.KClass
-
-enum class SomeEnum {
-    A, B
-}
-
-annotation class MyAnnotation(
-    val intValue: Int,
-    val stringValue: String,
-    val enumValue: SomeEnum,
-    val kClasses: Array<out KClass<*>>,
-    val annotation: MyOtherAnnotation
-)
-annotation class MyOtherAnnotation(val intValue: Int, val stringValue: String)
-
-const val constInt = 10
-const val constString = ""
-
-@MyAnnotation(
-    intValue = 10,
-    stringValue = constString,
-    enumValue = SomeEnum.A,
-    kClasses = [String::class, <!ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL!>constString::class<!>],
-
-    annotation = MyOtherAnnotation(
-        intValue = constInt,
-        stringValue = "hello"
-    )
-)
-fun foo() {}

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

@@ -1,26 +0,0 @@
-FILE: nestedClassInAnnotationArgument.kt
-    public final annotation class Ann : R|kotlin/Annotation| {
-        public constructor(kClass: R|kotlin/reflect/KClass<*>|): R|Ann| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final val kClass: R|kotlin/reflect/KClass<*>| = R|<local>/kClass|
-            public get(): R|kotlin/reflect/KClass<*>|
-
-    }
-    public final class A : R|kotlin/Any| {
-        public constructor(): R|A| {
-            super<R|kotlin/Any|>()
-        }
-
-        @R|Ann|(<getClass>(Q|A.EmptyList|)) public final fun foo(): R|kotlin/Unit| {
-        }
-
-        public final object EmptyList : R|kotlin/Any| {
-            private constructor(): R|A.EmptyList| {
-                super<R|kotlin/Any|>()
-            }
-
-        }
-
-    }

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

@@ -1,11 +0,0 @@
-// WITH_STDLIB
-import kotlin.reflect.KClass
-
-annotation class Ann(val kClass: KClass<*>)
-
-class A {
-    @Ann(EmptyList::class)
-    fun foo() {}
-
-    object EmptyList
-}

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

@@ -13,12 +13,12 @@ FILE: cast.kt
     }
 
         public get(): R|() -> kotlin/Unit|
-    public final val h: R|(kotlin/String) -> kotlin/Boolean| = fun <anonymous>(<unused var>: R|kotlin/String|): R|kotlin/Boolean| <inline=Unknown>  {
+    public final val h: R|(kotlin/String) -> kotlin/Boolean| = fun <anonymous>(_: R|kotlin/String|): R|kotlin/Boolean| <inline=Unknown>  {
         ^ Boolean(false)
     }
 
         public get(): R|(kotlin/String) -> kotlin/Boolean|
-    public final val hError: R|(ERROR CLASS: No type for parameter) -> kotlin/Boolean| = fun <anonymous>(<unused var>: <ERROR TYPE REF: No type for parameter>): R|kotlin/Boolean| <inline=Unknown>  {
+    public final val hError: R|(ERROR CLASS: No type for parameter) -> kotlin/Boolean| = fun <anonymous>(_: <ERROR TYPE REF: No type for parameter>): R|kotlin/Boolean| <inline=Unknown>  {
         ^ Boolean(true)
     }
 

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

@@ -1,5 +1,5 @@
 // !DUMP_CFG
-<!NOTHING_TO_INLINE!>inline<!> fun foo(vararg x: Any) {}
+inline fun foo(vararg x: Any) {}
 
 fun test(a: Any, b: Any, c: Any) {
     foo(a, { "" }, b)

compiler/fir/analysis-tests/testData/resolve/classCallInLambda.dot

@@ -1,59 +0,0 @@
-digraph classCallInLambda_kt {
-    graph [nodesep=3]
-    node [shape=box penwidth=2]
-    edge [penwidth=2]
-
-    subgraph cluster_0 {
-        color=red
-        0 [label="Enter function test" style="filled" fillcolor=red];
-        subgraph cluster_1 {
-            color=blue
-            1 [label="Enter block"];
-            2 [label="Access variable R|<local>/x|"];
-            3 [label="Postponed enter to lambda"];
-            subgraph cluster_2 {
-                color=blue
-                11 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
-                subgraph cluster_3 {
-                    color=blue
-                    12 [label="Enter block"];
-                    13 [label="Access variable R|<local>/it|"];
-                    14 [label="::class call"];
-                    15 [label="Exit block"];
-                }
-                16 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
-            }
-            4 [label="Call arguments union" style="filled" fillcolor=yellow];
-            5 [label="Postponed exit from lambda"];
-            6 [label="Function call: R|<local>/x|.R|kotlin/let|<R|kotlin/String|, R|kotlin/reflect/KClass<out kotlin/String>|>(...)"];
-            7 [label="Jump: ^test R|<local>/x|.R|kotlin/let|<R|kotlin/String|, R|kotlin/reflect/KClass<out kotlin/String>|>(<L> = let@fun <anonymous>(it: R|kotlin/String|): R|kotlin/reflect/KClass<out kotlin/String>| <inline=Inline, kind=EXACTLY_ONCE>  {
-    ^ <getClass>(R|<local>/it|)
-}
-)"];
-            8 [label="Stub" style="filled" fillcolor=gray];
-            9 [label="Exit block" style="filled" fillcolor=gray];
-        }
-        10 [label="Exit function test" style="filled" fillcolor=red];
-    }
-    0 -> {1};
-    1 -> {2};
-    2 -> {3};
-    3 -> {11};
-    3 -> {5} [color=red];
-    3 -> {11} [style=dashed];
-    4 -> {6} [color=red];
-    5 -> {6} [color=green];
-    6 -> {7};
-    7 -> {10};
-    7 -> {8} [style=dotted];
-    8 -> {9} [style=dotted];
-    9 -> {10} [style=dotted];
-    11 -> {12};
-    12 -> {13};
-    13 -> {14};
-    14 -> {15};
-    15 -> {16};
-    16 -> {4} [color=red];
-    16 -> {5} [color=green];
-
-}

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

@@ -1,7 +0,0 @@
-FILE: classCallInLambda.kt
-    public final fun test(x: R|kotlin/String|): R|kotlin/reflect/KClass<*>| {
-        ^test R|<local>/x|.R|kotlin/let|<R|kotlin/String|, R|kotlin/reflect/KClass<out kotlin/String>|>(<L> = let@fun <anonymous>(it: R|kotlin/String|): R|kotlin/reflect/KClass<out kotlin/String>| <inline=Inline, kind=EXACTLY_ONCE>  {
-            ^ <getClass>(R|<local>/it|)
-        }
-        )
-    }

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

@@ -1,7 +0,0 @@
-// WITH_STDLIB
-// DUMP_CFG
-import kotlin.reflect.KClass
-
-fun test(x: String): KClass<*> {
-    return x.let { it::class }
-}

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

@@ -20,7 +20,7 @@ abstract class K {
     <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> val i2: Int
 }
 
-private open <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class L<!> : K()
+private open <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class L<!> : K()
 private abstract class M : K()
 
 class X {

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

@@ -66,9 +66,3 @@ class Test8<S8 : Test7<S8, <!UPPER_BOUND_VIOLATED!>in Any<!>>>
 class Class<V : Any>
 typealias Alias <V1> = (Class<V1>) -> Boolean
 
-/* TODO: Should not be errors. Uncomment after fixing of https://youtrack.jetbrains.com/issue/KT-48044
-abstract class Base<T : Base<T>> {}
-class DerivedOut<out O : Base<out O>> {}
-class DerivedIn<in I : Base<in I>> {}*/
-
-

compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.fir.txt

@@ -32,7 +32,7 @@ FILE: threeReceivers.kt
             }
 
         public final fun R|FooBar|.chk(buz: R|Buz|): R|kotlin/Unit| {
-            R|<local>/buz|.<Expression 'foobar' of type 'Bar' cannot be invoked as a function>#()
+            R|<local>/buz|.<Unresolved name: foobar>#()
         }
 
     }

compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt

@@ -17,6 +17,6 @@ class Foo {
         // this@Foo is dispatch receiver of foobar
         // Foo/foobar is dispatch receiver of invoke
         // this@chk is extension receiver of invoke
-        buz.<!FUNCTION_EXPECTED!>foobar<!>()
+        buz.<!UNRESOLVED_REFERENCE!>foobar<!>()
     }
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/CanBeValChecker.kt

@@ -137,7 +137,7 @@ fun main(args: Array<String?>) {
         <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = args[0]
     } else {
         a  = args.toString()
-        if (<!SENSELESS_COMPARISON!>a != null<!> && a.equals("cde")) return
+        if (a != null && a.equals("cde")) return
     }
 }