JVM skip methods without NEW insns in UninitializedStoresProcessor

because of incorrect rebase

This reverts commit ce0a3a57

.bunch

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

.idea/dictionaries/igor.xml

@@ -0,0 +1,8 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="igor">
+    <words>
+      <w>descr</w>
+      <w>exprs</w>
+    </words>
+  </dictionary>
+</component>

.idea/dictionaries/skuzmich.xml

@@ -2,6 +2,7 @@
   <dictionary name="skuzmich">
     <words>
       <w>anyref</w>
+      <w>dataref</w>
       <w>ushr</w>
       <w>wasm</w>
     </words>

.idea/runConfigurations/Generate_FIR_Checker_Components_and_FIR_IDE_Diagnostics.xml

@@ -11,7 +11,7 @@
       <option name="taskNames">
         <list>
           <option value=":compiler:fir:checkers:generateCheckersComponents" />
-          <option value=":idea:idea-frontend-fir:generateCode" />
+          <option value=":idea-frontend-fir:generateCode" />
         </list>
       </option>
       <option name="vmOptions" value="" />

.idea/runConfigurations/IDEA.xml

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

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

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

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

@@ -1,19 +0,0 @@
-<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___Light.xml

@@ -0,0 +1,23 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Test: Commonizer / Light" type="GradleRunConfiguration" factoryName="Gradle" folderName="Tests">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value=":native:kotlin-klib-commonizer-api:test" />
+          <option value=":native:kotlin-klib-commonizer:test" />
+        </list>
+      </option>
+      <option name="vmOptions" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <method v="2" />
+  </configuration>
+</component>

ReadMe.md

@@ -35,26 +35,30 @@ Support for multiplatform programming is one of Kotlin’s key benefits. It redu
 
 ## Editing Kotlin
 
- * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html)
+ * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html) ([source code](https://github.com/JetBrains/intellij-community/tree/master/plugins/kotlin))
  * [Kotlin Eclipse Plugin](https://kotlinlang.org/docs/tutorials/getting-started-eclipse.html)
  * [Kotlin Sublime Text Package](https://github.com/vkostyukov/kotlin-sublime-package)
 
 ## Build environment requirements
 
-In order to build Kotlin distribution you need to have:
+This repository is using [Gradle toolchains](https://docs.gradle.org/current/userguide/toolchains.html) feature
+to select and auto-provision required JDKs from [AdoptOpenJdk](https://adoptopenjdk.net) project. 
 
-- JDK 1.6, 1.7, 1.8 and 9
-- Setup environment variables as following:
+Unfortunately [AdoptOpenJdk](https://adoptopenjdk.net) project does not provide required JDK 1.6 and 1.7 images,
+so you could either download them manually and provide path to installation via `JDK_16` and `JDK_17` environment variables or
+use following SDK managers:
+- [Asdf-vm](https://asdf-vm.com/)
+- [Jabba](https://github.com/shyiko/jabba)
+- [SDKMAN!](https://sdkman.io/)
 
-        JAVA_HOME="path to JDK 1.8"
-        JDK_16="path to JDK 1.6"
-        JDK_17="path to JDK 1.7"
-        JDK_18="path to JDK 1.8"
-        JDK_9="path to JDK 9"
+Alternatively, it is still possible to only provide required JDKs via environment variables 
+(see [gradle.properties](./gradle.properties#L5) for supported variable names). To ensure Gradle uses only JDKs 
+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 bytecode generation or the standard library, it's OK to have only JDK 1.8 and JDK 9 installed, and to point `JDK_16` and `JDK_17` environment variables to your JDK 1.8 installation.
-
-You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) to setup `JDK_*` variables.
+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. 
 
 Note: The JDK 6 for MacOS is not available on Oracle's site. You can install it by
 
@@ -93,13 +97,10 @@ command line parameters on the first run:
 
 - `clean` - clean build results
 - `dist` - assembles the compiler distribution into `dist/kotlinc/` folder
-- `ideaPlugin` - assembles the Kotlin IDEA plugin distribution into `dist/artifacts/ideaPlugin/Kotlin/` folder
 - `install` - build and install all public artifacts into local maven repository
-- `runIde` - build IDEA plugin and run IDEA with it
 - `coreLibsTest` - build and run stdlib, reflect and kotlin-test tests
 - `gradlePluginTest` - build and run gradle plugin tests
 - `compilerTest` - build and run all compiler tests
-- `ideaPluginTest` - build and run all IDEA plugin tests
 
 To reproduce TeamCity build use `-Pteamcity=true` flag. Local builds don't run proguard and have jar compression disabled by default.
 
@@ -139,14 +140,6 @@ To be able to run tests from IntelliJ easily, check `Delegate IDE build/run acti
 
 At this time, you can use the latest released `1.3.x` version of the Kotlin plugin for working with the code. To make sure you have the latest version installed, use `Tools` -> `Kotlin` -> `Configure Kotlin Plugin Updates`.
 
-### Compiling and running
-
-From this root project there are Run/Debug Configurations for running `IDEA` or the `Generate Compiler Tests` for example; so if you want to try out the latest and greatest IDEA plugin
-
-* `VCS` -> `Git` -> `Pull`
-* Run the `IDEA` run configuration in the project
-* A child IntelliJ IDEA with the Kotlin plugin will then startup
-
 ### Dependency verification
 
 We have a [dependencies verification](https://docs.gradle.org/current/userguide/dependency_verification.html) feature enabled in the

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
@@ -154,7 +155,7 @@ abstract class AbstractSimpleFileBenchmark {
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = createSessionForTests(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
-        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, PsiHandlingMode.COMPILER)
 
         val totalTransformer = FirTotalResolveProcessor(session)
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)

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

@@ -40,7 +40,7 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
     ): T
 
     fun create(args: CommonCompilerArguments): T {
-        val languageVersion = args.languageVersion?.let((LanguageVersion)::fromVersionString) ?: LanguageVersion.LATEST_STABLE
+        val languageVersion = args.languageVersion?.let { LanguageVersion.fromVersionString(it) } ?: LanguageVersion.LATEST_STABLE
 
         return create(
             isEAP = languageVersion.isPreRelease(),
@@ -51,7 +51,7 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
             ownVersion = OWN_VERSION,
             coroutinesVersion = COROUTINES_VERSION,
             multiplatformVersion = MULTIPLATFORM_VERSION,
-            metadataVersionArray = args.metadataVersion?.let((BinaryVersion)::parseVersionArray)
+            metadataVersionArray = args.metadataVersion?.let { BinaryVersion.parseVersionArray(it) }
         )
     }
 

build-common/src/org/jetbrains/kotlin/build/report/metrics/BuildAttribute.kt

@@ -17,6 +17,7 @@ enum class BuildAttributeKind : Serializable {
 
 enum class BuildAttribute(val kind: BuildAttributeKind) : Serializable {
     NO_BUILD_HISTORY(BuildAttributeKind.REBUILD_REASON),
+    NO_ABI_SNAPSHOT(BuildAttributeKind.REBUILD_REASON),
     CACHE_CORRUPTION(BuildAttributeKind.REBUILD_REASON),
     UNKNOWN_CHANGES_IN_GRADLE_INPUTS(BuildAttributeKind.REBUILD_REASON),
     JAVA_CHANGE_UNTRACKED_FILE_IS_REMOVED(BuildAttributeKind.REBUILD_REASON),

build-common/src/org/jetbrains/kotlin/build/report/metrics/BuildTime.kt

@@ -9,6 +9,7 @@ import java.io.Serializable
 
 @Suppress("Reformat")
 enum class BuildTime(val parent: BuildTime? = null) : Serializable {
+    GRADLE_TASK_ACTION,
     GRADLE_TASK,
         CLEAR_OUTPUT(GRADLE_TASK),
         BACKUP_OUTPUT(GRADLE_TASK),
@@ -20,6 +21,10 @@ enum class BuildTime(val parent: BuildTime? = null) : Serializable {
             NON_INCREMENTAL_COMPILATION_OUT_OF_PROCESS(RUN_COMPILER),
             NON_INCREMENTAL_COMPILATION_DAEMON(RUN_COMPILER),
             INCREMENTAL_COMPILATION(RUN_COMPILER),
+                STORE_BUILD_INFO(INCREMENTAL_COMPILATION),
+                JAR_SNAPSHOT(INCREMENTAL_COMPILATION),
+                    SET_UP_ABI_SNAPSHOTS(JAR_SNAPSHOT),
+                    IC_ANALYZE_JAR_FILES(JAR_SNAPSHOT),
                 IC_CALCULATE_INITIAL_DIRTY_SET(INCREMENTAL_COMPILATION),
                     IC_ANALYZE_CHANGES_IN_DEPENDENCIES(IC_CALCULATE_INITIAL_DIRTY_SET),
                         IC_FIND_HISTORY_FILES(IC_ANALYZE_CHANGES_IN_DEPENDENCIES),

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

@@ -30,6 +30,28 @@ class ChangesCollector {
     private val changedMembers = hashMapOf<FqName, MutableSet<String>>()
     private val areSubclassesAffected = hashMapOf<FqName, Boolean>()
 
+    //TODO for test only: ProtoData or ProtoBuf
+    private val storage = hashMapOf<FqName, ProtoData>()
+    private val removed = ArrayList<FqName>()
+
+    //TODO change to immutable map
+    fun protoDataChanges(): Map<FqName, ProtoData> = storage
+    fun protoDataRemoved(): List<FqName> = removed
+
+    companion object {
+        fun <T> T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List<MessageLite>) =
+            members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet()
+
+        fun ClassProtoData.getNonPrivateMemberNames(): Set<String> {
+            return proto.getNonPrivateNames(
+                nameResolver,
+                ProtoBuf.Class::getConstructorList,
+                ProtoBuf.Class::getFunctionList,
+                ProtoBuf.Class::getPropertyList
+            ) + proto.enumEntryList.map { nameResolver.getString(it.name) }
+        }
+    }
+
     fun changes(): List<ChangeInfo> {
         val changes = arrayListOf<ChangeInfo>()
 
@@ -57,7 +79,7 @@ class ChangesCollector {
     }
 
     private fun <T, R> MutableMap<T, MutableSet<R>>.getSet(key: T) =
-            getOrPut(key) { HashSet() }
+        getOrPut(key) { HashSet() }
 
     private fun collectChangedMember(scope: FqName, name: String) {
         changedMembers.getSet(scope).add(name)
@@ -79,11 +101,35 @@ class ChangesCollector {
         }
     }
 
-    fun collectProtoChanges(oldData: ProtoData?, newData: ProtoData?, collectAllMembersForNewClass: Boolean = false) {
+    fun collectProtoChanges(oldData: ProtoData?, newData: ProtoData?, collectAllMembersForNewClass: Boolean = false, packageProtoKey: String? = null) {
         if (oldData == null && newData == null) {
             throw IllegalStateException("Old and new value are null")
         }
 
+        if (newData != null) {
+            when (newData) {
+                is ClassProtoData -> {
+                    val fqName = newData.nameResolver.getClassId(newData.proto.fqName).asSingleFqName()
+                    storage[fqName] = newData
+                }
+                is PackagePartProtoData -> {
+                    //TODO fqName is not unique. It's package and can be present in both java and kotlin
+                    val fqName = newData.packageFqName
+                    storage[packageProtoKey?.let { FqName(it) } ?: fqName] = newData
+                }
+            }
+        } else if (oldData != null) {
+            when (oldData) {
+                is ClassProtoData -> {
+                    removed.add(oldData.nameResolver.getClassId(oldData.proto.fqName).asSingleFqName())
+                }
+                is PackagePartProtoData -> {
+                    //TODO fqName is not unique. It's package and can be present in both java and kotlin
+                    removed.add(packageProtoKey?.let { FqName(it) } ?: oldData.packageFqName)
+                }
+            }
+        }
+
         if (oldData == null) {
             newData!!.collectAll(isRemoved = false, isAdded = true, collectAllMembersForNewClass = collectAllMembersForNewClass)
             return
@@ -125,8 +171,8 @@ class ChangesCollector {
         }
     }
 
-    private fun <T> T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List<MessageLite>): Set<String> =
-            members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet()
+    fun <T> T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List<MessageLite>) =
+        members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet()
 
     //TODO remember all sealed parent classes
     private fun ProtoData.collectAll(isRemoved: Boolean, isAdded: Boolean, collectAllMembersForNewClass: Boolean = false) =
@@ -137,16 +183,15 @@ class ChangesCollector {
 
     private fun PackagePartProtoData.collectAllFromPackage(isRemoved: Boolean) {
         val memberNames =
-                proto.getNonPrivateNames(
-                        nameResolver,
-                        ProtoBuf.Package::getFunctionList,
-                        ProtoBuf.Package::getPropertyList
-                )
+            proto.getNonPrivateNames(
+                nameResolver,
+                ProtoBuf.Package::getFunctionList,
+                ProtoBuf.Package::getPropertyList
+            )
 
         if (isRemoved) {
             collectRemovedMembers(packageFqName, memberNames)
-        }
-        else {
+        } else {
             collectChangedMembers(packageFqName, memberNames)
         }
     }
@@ -161,8 +206,7 @@ class ChangesCollector {
             val collectMember = if (isRemoved) this@ChangesCollector::collectRemovedMember else this@ChangesCollector::collectChangedMember
             collectMember(classFqName.parent(), classFqName.shortName().asString())
             memberNames.forEach { collectMember(classFqName, it) }
-        }
-        else {
+        } else {
             if (!isRemoved && collectAllMembersForNewClass) {
                 val memberNames = getNonPrivateMemberNames()
                 memberNames.forEach { this@ChangesCollector.collectChangedMember(classFqName, it) }
@@ -189,15 +233,6 @@ class ChangesCollector {
         addChangedParents(fqName, changedParentsFqNames)
     }
 
-    private fun ClassProtoData.getNonPrivateMemberNames(): Set<String> {
-        return proto.getNonPrivateNames(
-                nameResolver,
-                ProtoBuf.Class::getConstructorList,
-                ProtoBuf.Class::getFunctionList,
-                ProtoBuf.Class::getPropertyList
-        ) + proto.enumEntryList.map { nameResolver.getString(it.name) }
-    }
-
     fun collectMemberIfValueWasChanged(scope: FqName, name: String, oldValue: Any?, newValue: Any?) {
         if (oldValue == null && newValue == null) {
             throw IllegalStateException("Old and new value are null for $scope#$name")
@@ -205,8 +240,7 @@ class ChangesCollector {
 
         if (oldValue != null && newValue == null) {
             collectRemovedMember(scope, name)
-        }
-        else if (oldValue != newValue) {
+        } else if (oldValue != newValue) {
             collectChangedMember(scope, name)
         }
     }

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

@@ -0,0 +1,76 @@
+/*
+ * 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.incremental
+
+import org.jetbrains.kotlin.name.FqName
+import java.io.ObjectInputStream
+import java.io.ObjectOutputStream
+import java.io.Serializable
+
+/**
+ * Changes to the classpath of the `KotlinCompile` task, used to compute the source files that need to be recompiled during an incremental
+ * run.
+ */
+sealed class ClasspathChanges : Serializable {
+
+    class Available() : ClasspathChanges() {
+
+        lateinit var lookupSymbols: List<LookupSymbol>
+            private set
+
+        lateinit var fqNames: List<FqName>
+            private set
+
+        constructor(lookupSymbols: List<LookupSymbol>, fqNames: List<FqName>) : this() {
+            this.lookupSymbols = lookupSymbols
+            this.fqNames = fqNames
+        }
+
+        private fun writeObject(out: ObjectOutputStream) {
+            out.writeInt(lookupSymbols.size)
+            lookupSymbols.forEach {
+                out.writeUTF(it.name)
+                out.writeUTF(it.scope)
+            }
+
+            out.writeInt(fqNames.size)
+            fqNames.forEach {
+                out.writeUTF(it.asString())
+            }
+        }
+
+        private fun readObject(ois: ObjectInputStream) {
+            val lookupSymbolsSize = ois.readInt()
+            val lookupSymbols = ArrayList<LookupSymbol>(lookupSymbolsSize)
+            repeat(lookupSymbolsSize) {
+                val name = ois.readUTF()
+                val scope = ois.readUTF()
+                lookupSymbols.add(LookupSymbol(name, scope))
+            }
+            this.lookupSymbols = lookupSymbols
+
+            val fqNamesSize = ois.readInt()
+            val fqNames = ArrayList<FqName>(fqNamesSize)
+            repeat(fqNamesSize) {
+                val fqNameString = ois.readUTF()
+                fqNames.add(FqName(fqNameString))
+            }
+            this.fqNames = fqNames
+        }
+
+        companion object {
+            private const val serialVersionUID = 0L
+        }
+    }
+
+    sealed class NotAvailable : ClasspathChanges() {
+        object UnableToCompute : NotAvailable()
+        object ForNonIncrementalRun : NotAvailable()
+        object ClasspathSnapshotIsDisabled : NotAvailable()
+        object ReservedForTestsOnly : NotAvailable()
+        object ForJSCompiler : NotAvailable()
+    }
+}

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

@@ -137,8 +137,8 @@ open class IncrementalJsCache(
         }
 
         for ((srcFile, irData) in incrementalResults.irFileData) {
-            val (fileData, types, signatures, strings, declarations, bodies, fqn) = irData
-            irTranslationResults.put(srcFile, fileData, types, signatures, strings, declarations, bodies, fqn)
+            val (fileData, types, signatures, strings, declarations, bodies, fqn, debugInfos) = irData
+            irTranslationResults.put(srcFile, fileData, types, signatures, strings, declarations, bodies, fqn, debugInfos)
         }
     }
 
@@ -269,6 +269,7 @@ private object IrTranslationResultValueExternalizer : DataExternalizer<IrTransla
         output.writeArray(value.declarations)
         output.writeArray(value.bodies)
         output.writeArray(value.fqn)
+        value.debugInfo?.let { output.writeArray(it) }
     }
 
     private fun DataOutput.writeArray(array: ByteArray) {
@@ -283,6 +284,17 @@ private object IrTranslationResultValueExternalizer : DataExternalizer<IrTransla
         return filedata
     }
 
+    private fun DataInput.readArrayOrNull(): ByteArray? {
+        try {
+            val dataSize = readInt()
+            val filedata = ByteArray(dataSize)
+            readFully(filedata)
+            return filedata
+        } catch (e: Throwable) {
+            return null
+        }
+    }
+
     override fun read(input: DataInput): IrTranslationResultValue {
         val fileData = input.readArray()
         val types = input.readArray()
@@ -291,8 +303,9 @@ private object IrTranslationResultValueExternalizer : DataExternalizer<IrTransla
         val declarations = input.readArray()
         val bodies = input.readArray()
         val fqn = input.readArray()
+        val debugInfos = input.readArrayOrNull()
 
-        return IrTranslationResultValue(fileData, types, signatures, strings, declarations, bodies, fqn)
+        return IrTranslationResultValue(fileData, types, signatures, strings, declarations, bodies, fqn, debugInfos)
     }
 }
 
@@ -317,10 +330,11 @@ private class IrTranslationResultMap(
         newStrings: ByteArray,
         newDeclarations: ByteArray,
         newBodies: ByteArray,
-        fqn: ByteArray
+        fqn: ByteArray,
+        debugInfos: ByteArray?
     ) {
         storage[pathConverter.toPath(sourceFile)] =
-            IrTranslationResultValue(newFiledata, newTypes, newSignatures, newStrings, newDeclarations, newBodies, fqn)
+            IrTranslationResultValue(newFiledata, newTypes, newSignatures, newStrings, newDeclarations, newBodies, fqn, debugInfos)
     }
 
     operator fun get(sourceFile: File): IrTranslationResultValue? =

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

@@ -185,7 +185,7 @@ open class IncrementalJvmCache(
         sourceToClassesMap.add(source, jvmClassName)
         val (proto, nameResolver) = serializedJavaClass.toProtoData()
         addToClassStorage(proto, nameResolver, source)
-
+//        collector.addJavaProto(ClassProtoData(proto, nameResolver))
         dirtyOutputClassesMap.notDirty(jvmClassName)
     }
 
@@ -308,7 +308,7 @@ open class IncrementalJvmCache(
             storage[key] = newData
 
             val packageFqName = kotlinClass.className.packageFqName
-            changesCollector.collectProtoChanges(oldData?.toProtoData(packageFqName), newData.toProtoData(packageFqName))
+            changesCollector.collectProtoChanges(oldData?.toProtoData(packageFqName), newData.toProtoData(packageFqName), packageProtoKey = key)
         }
 
         operator fun contains(className: JvmClassName): Boolean =

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

@@ -12,7 +12,8 @@ data class IncrementalModuleEntry(
     private val projectPath: String,
     val name: String,
     val buildDir: File,
-    val buildHistoryFile: File
+    val buildHistoryFile: File,
+    val abiSnapshot: File
 ) : Serializable {
     companion object {
         private const val serialVersionUID = 0L
@@ -26,7 +27,9 @@ class IncrementalModuleInfo(
     val nameToModules: Map<String, Set<IncrementalModuleEntry>>,
     val jarToClassListFile: Map<File, File>,
     // only for js and mpp
-    val jarToModule: Map<File, IncrementalModuleEntry>
+    val jarToModule: Map<File, IncrementalModuleEntry>,
+    //for JVM only
+    val jarToAbiSnapshot: Map<File, File>
 ) : Serializable {
     companion object {
         private const val serialVersionUID = 1L

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.incremental
 
+import com.intellij.openapi.diagnostic.Logger
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -33,6 +34,8 @@ open class LookupStorage(
     targetDataDir: File,
     pathConverter: FileToPathConverter
 ) : BasicMapsOwner(targetDataDir) {
+    val LOG = Logger.getInstance("#org.jetbrains.kotlin.jps.build.KotlinBuilder")
+
     companion object {
         private val DELETED_TO_SIZE_TRESHOLD = 0.5
         private val MINIMUM_GARBAGE_COLLECTIBLE_SIZE = 10000
@@ -41,36 +44,44 @@ open class LookupStorage(
     private val countersFile = "counters".storageFile
     private val idToFile = registerMap(IdToFileMap("id-to-file".storageFile, pathConverter))
     private val fileToId = registerMap(FileToIdMap("file-to-id".storageFile, pathConverter))
-    private val lookupMap = registerMap(LookupMap("lookups".storageFile))
+    val lookupMap = registerMap(LookupMap("lookups".storageFile))
 
     @Volatile
     private var size: Int = 0
 
-    @Volatile
-    private var deletedCount: Int = 0
-
     init {
         try {
             if (countersFile.exists()) {
                 val lines = countersFile.readLines()
                 size = lines[0].toInt()
-                deletedCount = lines[1].toInt()
             }
         } catch (e: Exception) {
             throw IOException("Could not read $countersFile", e)
         }
-
     }
 
     @Synchronized
     fun get(lookupSymbol: LookupSymbol): Collection<String> {
         val key = LookupSymbolKey(lookupSymbol.name, lookupSymbol.scope)
         val fileIds = lookupMap[key] ?: return emptySet()
+        val paths = mutableSetOf<String>()
+        val filtered = mutableSetOf<Int>()
+
+        for (fileId in fileIds) {
+            val path = idToFile[fileId]?.path
+
+            if (path != null) {
+                paths.add(path)
+                filtered.add(fileId)
+            }
 
-        return fileIds.mapNotNull {
-            // null means it's outdated
-            idToFile[it]?.path
         }
+
+        if (size > MINIMUM_GARBAGE_COLLECTIBLE_SIZE && filtered.size.toDouble() / fileIds.size.toDouble() < DELETED_TO_SIZE_TRESHOLD) {
+            lookupMap[key] = filtered
+        }
+
+        return paths
     }
 
     @Synchronized
@@ -81,8 +92,8 @@ open class LookupStorage(
             val key = LookupSymbolKey(lookupSymbol.name, lookupSymbol.scope)
             val paths = lookups[lookupSymbol]
             val fileIds = paths.mapTo(TreeSet()) { pathToId[it]!! }
-            fileIds.addAll(lookupMap[key] ?: emptySet())
-            lookupMap[key] = fileIds
+
+            lookupMap.append(key, fileIds)
         }
     }
 
@@ -92,7 +103,6 @@ open class LookupStorage(
             val id = fileToId[file] ?: continue
             idToFile.remove(id)
             fileToId.remove(file)
-            deletedCount++
         }
     }
 
@@ -103,7 +113,6 @@ open class LookupStorage(
         }
 
         size = 0
-        deletedCount = 0
 
         super.clean()
     }
@@ -111,18 +120,15 @@ open class LookupStorage(
     @Synchronized
     override fun flush(memoryCachesOnly: Boolean) {
         try {
-            removeGarbageIfNeeded()
-
             if (size > 0) {
                 if (!countersFile.exists()) {
                     countersFile.parentFile.mkdirs()
                     countersFile.createNewFile()
                 }
 
-                countersFile.writeText("$size\n$deletedCount")
+                countersFile.writeText("$size\n")
             }
-        }
-        finally {
+        } finally {
             super.flush(memoryCachesOnly)
         }
     }
@@ -137,13 +143,7 @@ open class LookupStorage(
         return id
     }
 
-    private fun removeGarbageIfNeeded(force: Boolean = false) {
-        if (force || (size > MINIMUM_GARBAGE_COLLECTIBLE_SIZE && deletedCount.toDouble() / size > DELETED_TO_SIZE_TRESHOLD)) {
-            doRemoveGarbage()
-        }
-    }
-
-    private fun doRemoveGarbage() {
+    private fun removeGarbageForTests() {
         for (hash in lookupMap.keys) {
             lookupMap[hash] = lookupMap[hash]!!.filter { it in idToFile }.toSet()
         }
@@ -153,7 +153,6 @@ open class LookupStorage(
         idToFile.clean()
         fileToId.clean()
         size = 0
-        deletedCount = 0
 
         for ((file, oldId) in oldFileToId.entries.sortedBy { it.key.path }) {
             val newId = addFileIfNeeded(file)
@@ -165,15 +164,16 @@ open class LookupStorage(
 
             if (fileIds.isEmpty()) {
                 lookupMap.remove(lookup)
-            }
-            else {
+            } else {
                 lookupMap[lookup] = fileIds
             }
         }
     }
 
-    @TestOnly fun forceGC() {
-        removeGarbageIfNeeded(force = true)
+
+    @TestOnly
+    fun forceGC() {
+        removeGarbageForTests()
         flush(false)
     }
 

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

@@ -1104,6 +1104,11 @@ open class ProtoCompareGenerated(
             if (!checkEquals(old.setter, new.setter)) return false
         }
 
+        if (old.hasDelegateMethod() != new.hasDelegateMethod()) return false
+        if (old.hasDelegateMethod()) {
+            if (!checkEquals(old.delegateMethod, new.delegateMethod)) return false
+        }
+
         return true
     }
 
@@ -2353,6 +2358,10 @@ fun JvmProtoBuf.JvmPropertySignature.hashCode(stringIndexes: (Int) -> Int, fqNam
         hashCode = 31 * hashCode + setter.hashCode(stringIndexes, fqNameIndexes, typeById)
     }
 
+    if (hasDelegateMethod()) {
+        hashCode = 31 * hashCode + delegateMethod.hashCode(stringIndexes, fqNameIndexes, typeById)
+    }
+
     return hashCode
 }
 

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

@@ -255,22 +255,23 @@ fun withSubtypes(
     typeFqName: FqName,
     caches: Iterable<IncrementalCacheCommon>
 ): Set<FqName> {
-    val types = LinkedHashSet(listOf(typeFqName))
-    val subtypes = hashSetOf<FqName>()
+    val typesToProccess = LinkedHashSet(listOf(typeFqName))
+    val proccessedTypes = hashSetOf<FqName>()
 
-    while (types.isNotEmpty()) {
-        val iterator = types.iterator()
+
+    while (typesToProccess.isNotEmpty()) {
+        val iterator = typesToProccess.iterator()
         val unprocessedType = iterator.next()
         iterator.remove()
 
         caches.asSequence()
             .flatMap { it.getSubtypesOf(unprocessedType) }
-            .filter { it !in subtypes }
-            .forEach { types.add(it) }
+            .filter { it !in proccessedTypes }
+            .forEach { typesToProccess.add(it) }
 
-        subtypes.add(unprocessedType)
+        proccessedTypes.add(unprocessedType)
     }
 
-    return subtypes
+    return proccessedTypes
 }
 

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.incremental.storage
 
 import java.io.File
 
-internal class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<Int>>(storage, LookupSymbolKeyDescriptor, IntCollectionExternalizer) {
+class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<Int>>(storage, LookupSymbolKeyDescriptor, IntCollectionExternalizer) {
     override fun dumpKey(key: LookupSymbolKey): String = key.toString()
 
     override fun dumpValue(value: Collection<Int>): String = value.toString()
@@ -27,6 +27,10 @@ internal class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<I
         storage.append(LookupSymbolKey(name, scope), listOf(fileId))
     }
 
+    fun append(lookup: LookupSymbolKey, fileIds: Collection<Int>) {
+        storage.append(lookup, fileIds)
+    }
+
     operator fun get(key: LookupSymbolKey): Collection<Int>? = storage[key]
 
     operator fun set(key: LookupSymbolKey, fileIds: Set<Int>) {

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

@@ -21,23 +21,49 @@ import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.EnumeratorStringDescriptor
 import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
+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.*
 
+/**
+ * Storage versioning:
+ * 0 - only name and value hashes are saved
+ * 1 - name and scope are saved
+ */
 object LookupSymbolKeyDescriptor : KeyDescriptor<LookupSymbolKey> {
     override fun read(input: DataInput): LookupSymbolKey {
-        val first = input.readInt()
-        val second = input.readInt()
-
-        return LookupSymbolKey(first, second)
+        val version = input.readByte()
+        return when (version.toInt()) {
+            0 -> {
+                val name = input.readUTF()
+                val scope = input.readUTF()
+                LookupSymbolKey(name.hashCode(), scope.hashCode(), name, scope)
+            }
+            1 -> {
+                val first = input.readInt()
+                val second = input.readInt()
+                LookupSymbolKey(first, second, "", "")
+            }
+            else -> throw RuntimeException("Unknown version of LookupSymbolKeyDescriptor=${version}")
+        }
     }
 
+    private val storeFullFqName = CompilerSystemProperties.COMPILE_INCREMENTAL_WITH_CLASSPATH_SHAPSHOTS.value.toBooleanLenient() ?: false
+
     override fun save(output: DataOutput, value: LookupSymbolKey) {
-        output.writeInt(value.nameHash)
-        output.writeInt(value.scopeHash)
+        if (storeFullFqName) {
+            output.writeByte(0)
+            output.writeUTF(value.name)
+            output.writeUTF(value.scope)
+        } else {
+            output.writeByte(1)
+            output.writeInt(value.nameHash)
+            output.writeInt(value.scopeHash)
+        }
     }
 
     override fun getHashCode(value: LookupSymbolKey): Int = value.hashCode()

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

@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.incremental.storage
 
-data class LookupSymbolKey(val nameHash: Int, val scopeHash: Int) : Comparable<LookupSymbolKey> {
-    constructor(name: String, scope: String) : this(name.hashCode(), scope.hashCode())
+data class LookupSymbolKey(val nameHash: Int, val scopeHash: Int, val name:String, val scope:String) : Comparable<LookupSymbolKey> {
+    constructor(name: String, scope: String) : this(name.hashCode(), scope.hashCode(), name, scope)
 
     override fun compareTo(other: LookupSymbolKey): Int {
         val nameCmp = nameHash.compareTo(other.nameHash)
@@ -26,6 +26,26 @@ data class LookupSymbolKey(val nameHash: Int, val scopeHash: Int) : Comparable<L
 
         return scopeHash.compareTo(other.scopeHash)
     }
+
+    override fun hashCode(): Int {
+        var result = nameHash
+        result = 31 * result + scopeHash
+        return result
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as LookupSymbolKey
+
+        if (nameHash != other.nameHash) return false
+        if (scopeHash != other.scopeHash) return false
+
+        return true
+    }
+
+
 }
 
 data class ProtoMapValue(val isPackageFacade: Boolean, val bytes: ByteArray, val strings: Array<String>)

build-common/test/org/jetbrains/kotlin/metadata/jvm/DebugJvmProtoBuf.java

@@ -3443,6 +3443,34 @@ public final class DebugJvmProtoBuf {
      * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature setter = 4;</code>
      */
     org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getSetterOrBuilder();
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+     *
+     * <pre>
+     * The delegate field of delegated properties may be optimized out; `getDelegate` should
+     * then call this method instead
+     * </pre>
+     */
+    boolean hasDelegateMethod();
+    /**
+     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+     *
+     * <pre>
+     * The delegate field of delegated properties may be optimized out; `getDelegate` should
+     * then call this method instead
+     * </pre>
+     */
+    org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature getDelegateMethod();
+    /**
+     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+     *
+     * <pre>
+     * The delegate field of delegated properties may be optimized out; `getDelegate` should
+     * then call this method instead
+     * </pre>
+     */
+    org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getDelegateMethodOrBuilder();
   }
   /**
    * Protobuf type {@code org.jetbrains.kotlin.metadata.jvm.JvmPropertySignature}
@@ -3548,6 +3576,19 @@ public final class DebugJvmProtoBuf {
               bitField0_ |= 0x00000008;
               break;
             }
+            case 42: {
+              org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000010) == 0x00000010)) {
+                subBuilder = delegateMethod_.toBuilder();
+              }
+              delegateMethod_ = input.readMessage(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(delegateMethod_);
+                delegateMethod_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000010;
+              break;
+            }
           }
         }
       } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -3684,11 +3725,48 @@ public final class DebugJvmProtoBuf {
       return setter_;
     }
 
+    public static final int DELEGATE_METHOD_FIELD_NUMBER = 5;
+    private org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature delegateMethod_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+     *
+     * <pre>
+     * The delegate field of delegated properties may be optimized out; `getDelegate` should
+     * then call this method instead
+     * </pre>
+     */
+    public boolean hasDelegateMethod() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+     *
+     * <pre>
+     * The delegate field of delegated properties may be optimized out; `getDelegate` should
+     * then call this method instead
+     * </pre>
+     */
+    public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature getDelegateMethod() {
+      return delegateMethod_;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+     *
+     * <pre>
+     * The delegate field of delegated properties may be optimized out; `getDelegate` should
+     * then call this method instead
+     * </pre>
+     */
+    public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getDelegateMethodOrBuilder() {
+      return delegateMethod_;
+    }
+
     private void initFields() {
       field_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmFieldSignature.getDefaultInstance();
       syntheticMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
       getter_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
       setter_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
+      delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
@@ -3715,6 +3793,9 @@ public final class DebugJvmProtoBuf {
       if (((bitField0_ & 0x00000008) == 0x00000008)) {
         output.writeMessage(4, setter_);
       }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        output.writeMessage(5, delegateMethod_);
+      }
       getUnknownFields().writeTo(output);
     }
 
@@ -3740,6 +3821,10 @@ public final class DebugJvmProtoBuf {
         size += org.jetbrains.kotlin.protobuf.CodedOutputStream
           .computeMessageSize(4, setter_);
       }
+      if (((bitField0_ & 0x00000010) == 0x00000010)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(5, delegateMethod_);
+      }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
       return size;
@@ -3853,6 +3938,7 @@ public final class DebugJvmProtoBuf {
           getSyntheticMethodFieldBuilder();
           getGetterFieldBuilder();
           getSetterFieldBuilder();
+          getDelegateMethodFieldBuilder();
         }
       }
       private static Builder create() {
@@ -3885,6 +3971,12 @@ public final class DebugJvmProtoBuf {
           setterBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000008);
+        if (delegateMethodBuilder_ == null) {
+          delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
+        } else {
+          delegateMethodBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000010);
         return this;
       }
 
@@ -3945,6 +4037,14 @@ public final class DebugJvmProtoBuf {
         } else {
           result.setter_ = setterBuilder_.build();
         }
+        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+          to_bitField0_ |= 0x00000010;
+        }
+        if (delegateMethodBuilder_ == null) {
+          result.delegateMethod_ = delegateMethod_;
+        } else {
+          result.delegateMethod_ = delegateMethodBuilder_.build();
+        }
         result.bitField0_ = to_bitField0_;
         onBuilt();
         return result;
@@ -3973,6 +4073,9 @@ public final class DebugJvmProtoBuf {
         if (other.hasSetter()) {
           mergeSetter(other.getSetter());
         }
+        if (other.hasDelegateMethod()) {
+          mergeDelegateMethod(other.getDelegateMethod());
+        }
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
@@ -4500,6 +4603,167 @@ public final class DebugJvmProtoBuf {
         return setterBuilder_;
       }
 
+      private org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
+      private org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
+          org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder> delegateMethodBuilder_;
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public boolean hasDelegateMethod() {
+        return ((bitField0_ & 0x00000010) == 0x00000010);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature getDelegateMethod() {
+        if (delegateMethodBuilder_ == null) {
+          return delegateMethod_;
+        } else {
+          return delegateMethodBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public Builder setDelegateMethod(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature value) {
+        if (delegateMethodBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          delegateMethod_ = value;
+          onChanged();
+        } else {
+          delegateMethodBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000010;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public Builder setDelegateMethod(
+          org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder builderForValue) {
+        if (delegateMethodBuilder_ == null) {
+          delegateMethod_ = builderForValue.build();
+          onChanged();
+        } else {
+          delegateMethodBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000010;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public Builder mergeDelegateMethod(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature value) {
+        if (delegateMethodBuilder_ == null) {
+          if (((bitField0_ & 0x00000010) == 0x00000010) &&
+              delegateMethod_ != org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance()) {
+            delegateMethod_ =
+              org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.newBuilder(delegateMethod_).mergeFrom(value).buildPartial();
+          } else {
+            delegateMethod_ = value;
+          }
+          onChanged();
+        } else {
+          delegateMethodBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000010;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public Builder clearDelegateMethod() {
+        if (delegateMethodBuilder_ == null) {
+          delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
+          onChanged();
+        } else {
+          delegateMethodBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000010);
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder getDelegateMethodBuilder() {
+        bitField0_ |= 0x00000010;
+        onChanged();
+        return getDelegateMethodFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getDelegateMethodOrBuilder() {
+        if (delegateMethodBuilder_ != null) {
+          return delegateMethodBuilder_.getMessageOrBuilder();
+        } else {
+          return delegateMethod_;
+        }
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
+       *
+       * <pre>
+       * The delegate field of delegated properties may be optimized out; `getDelegate` should
+       * then call this method instead
+       * </pre>
+       */
+      private org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
+          org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder> 
+          getDelegateMethodFieldBuilder() {
+        if (delegateMethodBuilder_ == null) {
+          delegateMethodBuilder_ = new org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
+              org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder>(
+                  getDelegateMethod(),
+                  getParentForChildren(),
+                  isClean());
+          delegateMethod_ = null;
+        }
+        return delegateMethodBuilder_;
+      }
+
       // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.metadata.jvm.JvmPropertySignature)
     }
 
@@ -4740,7 +5004,7 @@ public final class DebugJvmProtoBuf {
       "\020DESC_TO_CLASS_ID\020\002\"<\n\022JvmMethodSignatur" +
       "e\022\022\n\004name\030\001 \001(\005B\004\230\265\030\001\022\022\n\004desc\030\002 \001(\005B\004\230\265\030" +
       "\001\";\n\021JvmFieldSignature\022\022\n\004name\030\001 \001(\005B\004\230\265" +
-      "\030\001\022\022\n\004desc\030\002 \001(\005B\004\230\265\030\001\"\272\002\n\024JvmPropertySi" +
+      "\030\001\022\022\n\004desc\030\002 \001(\005B\004\230\265\030\001\"\212\003\n\024JvmPropertySi" +
       "gnature\022C\n\005field\030\001 \001(\01324.org.jetbrains.k" +
       "otlin.metadata.jvm.JvmFieldSignature\022O\n\020",
       "synthetic_method\030\002 \001(\01325.org.jetbrains.k" +
@@ -4748,11 +5012,13 @@ public final class DebugJvmProtoBuf {
       "\006getter\030\003 \001(\01325.org.jetbrains.kotlin.met" +
       "adata.jvm.JvmMethodSignature\022E\n\006setter\030\004" +
       " \001(\01325.org.jetbrains.kotlin.metadata.jvm" +
+      ".JvmMethodSignature\022N\n\017delegate_method\030\005" +
+      " \001(\01325.org.jetbrains.kotlin.metadata.jvm" +
       ".JvmMethodSignature:\200\001\n\025constructor_sign" +
       "ature\022*.org.jetbrains.kotlin.metadata.Co" +
-      "nstructor\030d \001(\01325.org.jetbrains.kotlin.m" +
+      "nstructor\030d \001(\01325.org.jetbrains.kotlin.m",
       "etadata.jvm.JvmMethodSignature:x\n\020method" +
-      "_signature\022\'.org.jetbrains.kotlin.metada",
+      "_signature\022\'.org.jetbrains.kotlin.metada" +
       "ta.Function\030d \001(\01325.org.jetbrains.kotlin" +
       ".metadata.jvm.JvmMethodSignature:O\n\030lamb" +
       "da_class_origin_name\022\'.org.jetbrains.kot" +
@@ -4760,9 +5026,9 @@ public final class DebugJvmProtoBuf {
       "perty_signature\022\'.org.jetbrains.kotlin.m" +
       "etadata.Property\030d \001(\01327.org.jetbrains.k" +
       "otlin.metadata.jvm.JvmPropertySignature:" +
-      "9\n\005flags\022\'.org.jetbrains.kotlin.metadata" +
+      "9\n\005flags\022\'.org.jetbrains.kotlin.metadata",
       ".Property\030e \001(\005:\0010:g\n\017type_annotation\022#." +
-      "org.jetbrains.kotlin.metadata.Type\030d \003(\013",
+      "org.jetbrains.kotlin.metadata.Type\030d \003(\013" +
       "2).org.jetbrains.kotlin.metadata.Annotat" +
       "ion:3\n\006is_raw\022#.org.jetbrains.kotlin.met" +
       "adata.Type\030e \001(\010:z\n\031type_parameter_annot" +
@@ -4770,9 +5036,9 @@ public final class DebugJvmProtoBuf {
       "peParameter\030d \003(\0132).org.jetbrains.kotlin" +
       ".metadata.Annotation:E\n\021class_module_nam" +
       "e\022$.org.jetbrains.kotlin.metadata.Class\030" +
-      "e \001(\005B\004\230\265\030\001:k\n\024class_local_variable\022$.or" +
+      "e \001(\005B\004\230\265\030\001:k\n\024class_local_variable\022$.or",
       "g.jetbrains.kotlin.metadata.Class\030f \003(\0132" +
-      "\'.org.jetbrains.kotlin.metadata.Property",
+      "\'.org.jetbrains.kotlin.metadata.Property" +
       ":P\n\034anonymous_object_origin_name\022$.org.j" +
       "etbrains.kotlin.metadata.Class\030g \001(\005B\004\230\265" +
       "\030\001:@\n\017jvm_class_flags\022$.org.jetbrains.ko" +
@@ -4780,7 +5046,7 @@ public final class DebugJvmProtoBuf {
       "module_name\022&.org.jetbrains.kotlin.metad" +
       "ata.Package\030e \001(\005B\004\230\265\030\001:o\n\026package_local" +
       "_variable\022&.org.jetbrains.kotlin.metadat" +
-      "a.Package\030f \003(\0132\'.org.jetbrains.kotlin.m" +
+      "a.Package\030f \003(\0132\'.org.jetbrains.kotlin.m",
       "etadata.PropertyB\022B\020DebugJvmProtoBuf"
     };
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
@@ -4826,7 +5092,7 @@ public final class DebugJvmProtoBuf {
     internal_static_org_jetbrains_kotlin_metadata_jvm_JvmPropertySignature_fieldAccessorTable = new
       org.jetbrains.kotlin.protobuf.GeneratedMessage.FieldAccessorTable(
         internal_static_org_jetbrains_kotlin_metadata_jvm_JvmPropertySignature_descriptor,
-        new java.lang.String[] { "Field", "SyntheticMethod", "Getter", "Setter", });
+        new java.lang.String[] { "Field", "SyntheticMethod", "Getter", "Setter", "DelegateMethod", });
     constructorSignature.internalInit(descriptor.getExtensions().get(0));
     methodSignature.internalInit(descriptor.getExtensions().get(1));
     lambdaClassOriginName.internalInit(descriptor.getExtensions().get(2));

build.gradle.kts

@@ -1,7 +1,6 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.crypto.checksum.Checksum
 import org.gradle.plugins.ide.idea.model.IdeaModel
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import proguard.gradle.ProGuardTask
 
 buildscript {
@@ -30,7 +29,7 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.30")
+        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")
@@ -56,13 +55,6 @@ pill {
 
 val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
 
-val configuredJdks: List<JdkId> =
-    getConfiguredJdks().also {
-        it.forEach { jdkId ->
-            logger.info("Using ${jdkId.majorVersion} home: ${jdkId.homeDir}")
-        }
-    }
-
 val defaultSnapshotVersion: String by extra
 val buildNumber by extra(findProperty("build.number")?.toString() ?: defaultSnapshotVersion)
 val kotlinVersion by extra(
@@ -114,37 +106,6 @@ subprojects {
     extra["kotlinNativeVersion"] = kotlinNativeVersionObject
 }
 
-// Work-around necessary to avoid setting null javaHome. Will be removed after support of lazy task configuration
-val jdkNotFoundConst = "JDK NOT FOUND"
-
-if (isTeamcityBuild) {
-    extra["JDK_16"] = jdkPath("1.6")
-    extra["JDK_17"] = jdkPath("1.7")
-} else {
-    extra["JDK_16"] = jdkPath("1.6", "1.8")
-    extra["JDK_17"] = jdkPath("1.7", "1.8")
-}
-extra["JDK_18"] = jdkPath("1.8")
-extra["JDK_9"] = jdkPath("9")
-extra["JDK_10"] = jdkPath("10")
-extra["JDK_11"] = jdkPath("11")
-extra["JDK_15"] = jdkPath("15")
-
-// allow opening the project without setting up all env variables (see KT-26413)
-if (!kotlinBuildProperties.isInIdeaSync) {
-    checkJDK()
-}
-
-fun checkJDK() {
-    val missingEnvVars = JdkMajorVersion.values()
-        .filter { it.isMandatory() && extra[it.name] == jdkNotFoundConst }
-        .mapTo(ArrayList()) { it.name }
-
-    if (missingEnvVars.isNotEmpty()) {
-        throw GradleException("Required environment variables are missing: ${missingEnvVars.joinToString()}")
-    }
-}
-
 rootProject.apply {
     from(rootProject.file("gradle/versions.gradle.kts"))
     from(rootProject.file("gradle/report.gradle.kts"))
@@ -167,8 +128,9 @@ extra["versions.junit"] = "4.12"
 extra["versions.javaslang"] = "2.0.6"
 extra["versions.ant"] = "1.10.7"
 extra["versions.android"] = "2.3.1"
-extra["versions.kotlinx-coroutines-core"] = "1.3.8"
-extra["versions.kotlinx-coroutines-jdk8"] = "1.3.8"
+extra["versions.kotlinx-coroutines-core"] = "1.5.0"
+extra["versions.kotlinx-coroutines-core-jvm"] = "1.5.0"
+extra["versions.kotlinx-coroutines-jdk8"] = "1.5.0"
 extra["versions.json"] = "20160807"
 extra["versions.native-platform"] = "0.14"
 extra["versions.robolectric"] = "4.0"
@@ -186,12 +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.5.30-dev-1916"
+    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 useJvmIrBackend by extra(project.kotlinBuildProperties.useIR)
 val useJvmFir by extra(project.kotlinBuildProperties.useFir)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
@@ -200,7 +161,11 @@ extra["intellijSeparateSdks"] = intellijSeparateSdks
 
 extra["IntellijCoreDependencies"] =
     listOf(
-        "asm-all-8.0.1",
+        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",
@@ -252,6 +217,7 @@ extra["compilerModules"] = arrayOf(
     ":compiler:incremental-compilation-impl",
     ":compiler:compiler.version",
     ":js:js.ast",
+    ":js:js.sourcemap",
     ":js:js.serializer",
     ":js:js.parser",
     ":js:js.config",
@@ -333,6 +299,11 @@ extra["compilerArtifactsForIde"] = listOf(
     ":prepare:ide-plugin-dependencies:lombok-compiler-plugin-for-ide",
     ":prepare:ide-plugin-dependencies:kotlin-compiler-tests-for-ide",
     ":prepare:ide-plugin-dependencies:kotlin-compiler-testdata-for-ide",
+    ":prepare:ide-plugin-dependencies:kotlin-stdlib-minimal-for-test-for-ide",
+    ":prepare:ide-plugin-dependencies:low-level-api-fir-for-ide",
+    ":prepare:ide-plugin-dependencies:high-level-api-for-ide",
+    ":prepare:ide-plugin-dependencies:high-level-api-fir-for-ide",
+    ":prepare:ide-plugin-dependencies:high-level-api-fir-tests-for-ide",
     ":kotlin-script-runtime",
     ":kotlin-script-util",
     ":kotlin-scripting-common",
@@ -383,7 +354,12 @@ val coreLibProjects = listOfNotNull(
 val projectsWithDisabledFirBootstrap = coreLibProjects + listOf(
     ":kotlin-gradle-plugin",
     ":kotlinx-metadata",
-    ":kotlinx-metadata-jvm"
+    ":kotlinx-metadata-jvm",
+    // For some reason stdlib isn't imported correctly for this module
+    // Probably it's related to kotlin-test module usage
+    ":kotlin-gradle-statistics",
+    // Requires serialization plugin
+    ":wasm:wasm.ir"
 )
 
 val gradlePluginProjects = listOf(
@@ -417,8 +393,6 @@ fun Task.listConfigurationContents(configName: String) {
     }
 }
 
-val defaultJvmTarget = "1.8"
-val defaultJavaHome = jdkPath(if (Platform[203].orHigher()) "11" else defaultJvmTarget)
 val ignoreTestFailures by extra(project.kotlinBuildProperties.ignoreTestFailures)
 
 allprojects {
@@ -464,17 +438,16 @@ allprojects {
         }
     }
 
-    jvmTarget = defaultJvmTarget
-    javaHome = defaultJavaHome
-
     // There are problems with common build dir:
     //  - some tests (in particular js and binary-compatibility-validator depend on the fixed (default) location
     //  - idea seems unable to exclude common buildDir from indexing
     // therefore it is disabled by default
     // buildDir = File(commonBuildDir, project.name)
 
-
-    configureJvmProject(javaHome!!, jvmTarget!!)
+    project.configureJvmDefaultToolchain()
+    plugins.withId("java-base") {
+        project.configureShadowJarSubstitutionInCompileClasspath()
+    }
 
     val commonCompilerArgs = listOfNotNull(
         "-Xopt-in=kotlin.RequiresOptIn",
@@ -501,11 +474,7 @@ allprojects {
         kotlinOptions {
             freeCompilerArgs = commonCompilerArgs + jvmCompilerArgs
 
-            if (useJvmIrBackend) {
-                useIR = true
-            }
-
-            if (useJvmFir && this@allprojects.name !in projectsWithDisabledFirBootstrap) {
+            if (useJvmFir && this@allprojects.path !in projectsWithDisabledFirBootstrap) {
                 freeCompilerArgs += "-Xuse-fir"
                 freeCompilerArgs += "-Xabi-stability=stable"
             }
@@ -572,12 +541,9 @@ allprojects {
         register("checkBuild")
     }
 
-    afterEvaluate {
-        if (javaHome != defaultJavaHome || jvmTarget != defaultJvmTarget) {
-            logger.info("configuring project $name to compile to the target jvm version $jvmTarget using jdk: $javaHome")
-            configureJvmProject(javaHome!!, jvmTarget!!)
-        } // else we will actually fail during the first task execution. We could not fail before configuration is done due to impact on import in IDE
+    apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
 
+    afterEvaluate {
         fun File.toProjectRootRelativePathOrSelf() = (relativeToOrNull(rootDir)?.takeUnless { it.startsWith("..") } ?: this).path
 
         fun FileCollection.printClassPath(role: String) =
@@ -606,7 +572,6 @@ allprojects {
                 ?.exclude("org.jetbrains.kotlin", "kotlin-scripting-compiler-embeddable")
         }
 
-        apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
         apply(from = "$rootDir/gradle/testRetry.gradle.kts")
     }
 }
@@ -769,8 +734,6 @@ 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")
         dependsOn(":kotlin-scripting-js-test:test")
     }
 
@@ -814,6 +777,7 @@ tasks {
 
     register("distTest") {
         dependsOn("compilerTest")
+        dependsOn("frontendApiTests")
         dependsOn("toolsTest")
         dependsOn("gradlePluginTest")
         dependsOn("examplesTest")
@@ -875,14 +839,23 @@ tasks {
         dependsOn("dist")
         dependsOn(
             ":idea:idea-fir:test",
-            ":idea:idea-frontend-api:test",
-            ":idea:idea-frontend-fir:test",
-            ":idea:idea-frontend-fir:idea-fir-low-level-api:test",
+            ":idea:idea-frontend-fir:fir-low-level-api-ide-impl:test",
             ":plugins:uast-kotlin-fir:test",
             ":idea:idea-fir-fe10-binding:test"
         )
     }
 
+    register("frontendApiTests") {
+        dependsOn("dist")
+        dependsOn(
+            ":idea-frontend-api:test",
+            ":idea-frontend-fir:test",
+            ":idea-frontend-fir:idea-fir-low-level-api:test"
+        )
+    }
+
+
+
     register("android-ide-tests") {
         dependsOn("dist")
         dependsOn(
@@ -1082,66 +1055,6 @@ configure<IdeaModel> {
     }
 }
 
-fun jdkPathOrNull(version: String): String? {
-    val jdkName = "JDK_${version.replace(".", "")}"
-    val jdkMajorVersion = JdkMajorVersion.valueOf(jdkName)
-    return configuredJdks.find { it.majorVersion == jdkMajorVersion }?.homeDir?.canonicalPath
-}
-
-fun jdkPath(version: String, vararg replacementVersions: String): String {
-    return jdkPathOrNull(version) ?: run {
-        replacementVersions.asSequence().map { jdkPathOrNull(it) }.find { it != null }
-    } ?: jdkNotFoundConst
-}
-
-fun Project.configureJvmProject(javaHome: String, javaVersion: String) {
-    val currentJavaHome = File(System.getProperty("java.home")!!).canonicalPath
-    val shouldFork = !currentJavaHome.startsWith(File(javaHome).canonicalPath)
-
-    tasks.withType<JavaCompile> {
-        if (name != "compileJava9Java") {
-            sourceCompatibility = javaVersion
-            targetCompatibility = javaVersion
-            options.isFork = shouldFork
-            options.forkOptions.javaHome = file(javaHome)
-            options.compilerArgs.add("-proc:none")
-            options.encoding = "UTF-8"
-        }
-    }
-
-    tasks.withType<KotlinCompile> {
-        kotlinOptions.jdkHome = javaHome.takeUnless { kotlinBuildProperties.suppressJdkHomeWarning }
-        kotlinOptions.jvmTarget = javaVersion
-        kotlinOptions.freeCompilerArgs += "-Xjvm-default=compatibility"
-    }
-
-    tasks.withType<Test> {
-        executable = File(javaHome, "bin/java").canonicalPath
-    }
-
-    plugins.withId("java-base") {
-        configureShadowJarSubstitutionInCompileClasspath()
-    }
-}
-
-fun Project.configureShadowJarSubstitutionInCompileClasspath() {
-    val substitutionMap = mapOf(":kotlin-reflect" to ":kotlin-reflect-api")
-
-    fun configureSubstitution(substitution: DependencySubstitution) {
-        val requestedProject = (substitution.requested as? ProjectComponentSelector)?.projectPath ?: return
-        val replacementProject = substitutionMap[requestedProject] ?: return
-        substitution.useTarget(project(replacementProject), "Non-default shadow jars should not be used in compile classpath")
-    }
-
-    sourceSets.all {
-        for (configName in listOf(compileOnlyConfigurationName, compileClasspathConfigurationName)) {
-            configurations.getByName(configName).resolutionStrategy.dependencySubstitution {
-                all(::configureSubstitution)
-            }
-        }
-    }
-}
-
 tasks.register("findShadowJarsInClasspath") {
     doLast {
         fun Collection<File>.printSorted(indent: String = "    ") {
@@ -1209,3 +1122,19 @@ if (disableVerificationTasks) {
         }
     }
 }
+
+plugins.withType(org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin::class) {
+    extensions.configure(org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension::class.java) {
+        nodeVersion = "16.2.0"
+    }
+}
+
+afterEvaluate {
+    val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
+    if (cacheRedirectorEnabled) {
+        rootProject.plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin::class.java) {
+            rootProject.the<org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension>().downloadBaseUrl =
+                "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.30")
+        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.30")
+    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")}")
@@ -155,10 +155,10 @@ dependencies {
     implementation("net.sf.proguard:proguard-gradle:6.2.2")
     implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
 
-    implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
+    implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:1.0.1")
 
     implementation("org.gradle:test-retry-gradle-plugin:1.2.0")
-    implementation("com.gradle.enterprise:test-distribution-gradle-plugin:1.2.1")
+    implementation("com.gradle.enterprise:test-distribution-gradle-plugin:2.1")
 
     compileOnly(gradleApi())
 

buildSrc/src/main/kotlin/BuildPropertiesExt.kt

@@ -21,4 +21,5 @@ val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignore
 
 val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)
 
-val KotlinBuildProperties.suppressJdkHomeWarning: Boolean get() = getBoolean("kotlin.suppress.jdkHome.warning", false)
+val KotlinBuildProperties.isObsoleteJdkOverrideEnabled: Boolean
+    get() = getBoolean("kotlin.build.isObsoleteJdkOverrideEnabled", false)

buildSrc/src/main/kotlin/CacheableProguradTask.kt

@@ -4,32 +4,36 @@
  */
 
 import groovy.lang.Closure
+import org.gradle.api.JavaVersion
 import org.gradle.api.file.FileCollection
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
-import org.gradle.internal.jvm.Jvm
-import org.gradle.internal.jvm.inspection.JvmVersionDetector
+import org.gradle.jvm.toolchain.JavaLauncher
+import org.gradle.kotlin.dsl.property
 import proguard.ClassSpecification
 import java.io.File
-import javax.inject.Inject
-
 
 @CacheableTask
-open class CacheableProguardTask @Inject constructor(
-    private val jvmVersionDetector: JvmVersionDetector
-) : proguard.gradle.ProGuardTask() {
+open class CacheableProguardTask : proguard.gradle.ProGuardTask() {
 
-    @Internal
-    var jdkHome: File? = null
+    @get:Internal
+    val javaLauncher: Property<JavaLauncher> = project.objects.property()
+
+    @get:Internal
+    val jdkHomePath: Provider<File> = javaLauncher.map { it.metadata.installationPath.asFile }
 
     @get:Optional
     @get:Input
-    internal val jdkMajorVersion: String?
-        get() = jdkHome?.let { jvmVersionDetector.getJavaVersion(Jvm.forHome(jdkHome)) }?.majorVersion
+    internal val jdkMajorVersion: Provider<JavaVersion> = javaLauncher.map {
+        JavaVersion.toVersion(it.metadata.languageVersion.toString())
+    }
 
     @CompileClasspath
-    override fun getLibraryJarFileCollection(): FileCollection = super.getLibraryJarFileCollection().filter { libraryFile ->
-        jdkHome?.let { !libraryFile.absoluteFile.startsWith(it.absoluteFile) } ?: true
-    }
+    override fun getLibraryJarFileCollection(): FileCollection = super.getLibraryJarFileCollection()
+        .filter { libraryFile ->
+            jdkHomePath.orNull?.let { !libraryFile.absoluteFile.startsWith(it.absoluteFile) } ?: true
+        }
 
     @InputFiles
     @PathSensitive(PathSensitivity.RELATIVE)

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -86,4 +86,7 @@ val Project.isConfigurationCacheDisabled
     get() = (gradle.startParameter as? org.gradle.api.internal.StartParameterInternal)?.isConfigurationCache != true
 
 val Project.isIdeaActive
-    get() = providers.systemProperty("idea.active").forUseAtConfigurationTime().isPresent
+    get() = providers.systemProperty("idea.active").forUseAtConfigurationTime().isPresent
+
+val Project.intellijCommunityDir: File
+    get() = rootDir.resolve("kotlin-ide/intellij/community").takeIf { it.isDirectory } ?: rootDir.resolve("kotlin-ide/intellij")

buildSrc/src/main/kotlin/ComponentsXmlResourceTransformerPatched.kt

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+import com.github.jengelman.gradle.plugins.shadow.relocation.RelocateClassContext
+import com.github.jengelman.gradle.plugins.shadow.transformers.Transformer
+import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
+import org.gradle.api.file.FileTreeElement
+import shadow.org.apache.tools.zip.ZipEntry
+import shadow.org.apache.tools.zip.ZipOutputStream
+import shadow.org.codehaus.plexus.util.IOUtil
+import shadow.org.codehaus.plexus.util.ReaderFactory
+import shadow.org.codehaus.plexus.util.WriterFactory
+import shadow.org.codehaus.plexus.util.xml.Xpp3Dom
+import shadow.org.codehaus.plexus.util.xml.Xpp3DomBuilder
+import shadow.org.codehaus.plexus.util.xml.Xpp3DomWriter
+import java.io.*
+import java.lang.Exception
+import java.util.LinkedHashMap
+
+/**
+ * A resource processor that aggregates plexus `components.xml` files.
+ *
+ * Fixed version of [com.github.jengelman.gradle.plugins.shadow.transformers.ComponentsXmlResourceTransformer],
+ * may be dropped after [the fix in ShadowJAR](https://github.com/johnrengelman/shadow/pull/678/files) will be accepted
+ */
+class ComponentsXmlResourceTransformerPatched : Transformer {
+    private val components: MutableMap<String, Xpp3Dom> =
+        LinkedHashMap<String, Xpp3Dom>()
+
+    override fun canTransformResource(element: FileTreeElement): Boolean {
+        val path = element.relativePath.pathString
+        return COMPONENTS_XML_PATH == path
+    }
+
+    override fun transform(context: TransformerContext) {
+        val newDom: Xpp3Dom = try {
+            val bis: BufferedInputStream = object : BufferedInputStream(context.getIs()) {
+                override fun close() {
+                    // leave ZIP open
+                }
+            }
+            val reader: Reader = ReaderFactory.newXmlReader(bis)
+            Xpp3DomBuilder.build(reader)
+        } catch (e: Exception) {
+            throw (IOException("Error parsing components.xml in " + context.getIs()).initCause(e) as IOException)
+        }
+
+        // Only try to merge in components if there are some elements in the component-set
+        if (newDom.getChild("components") == null) {
+            return
+        }
+        val children: Array<Xpp3Dom>? = newDom.getChild("components")?.getChildren("component")
+        children?.forEach { component ->
+            var role: String? = getValue(component, "role")
+            role = getRelocatedClass(role, context)
+            setValue(component, "role", role)
+            val roleHint = getValue(component, "role-hint")
+            var impl: String? = getValue(component, "implementation")
+            impl = getRelocatedClass(impl, context)
+            setValue(component, "implementation", impl)
+            val key = "$role:$roleHint"
+            if (components.containsKey(key)) {
+                // configuration carry over
+                val dom: Xpp3Dom? = components[key]
+                if (dom?.getChild("configuration") != null) {
+                    component.addChild(dom.getChild("configuration"))
+                }
+            }
+            val requirements: Xpp3Dom? = component.getChild("requirements")
+            if (requirements != null && requirements.childCount > 0) {
+                for (r in requirements.childCount - 1 downTo 0) {
+                    val requirement: Xpp3Dom = requirements.getChild(r)
+                    var requiredRole: String? = getValue(requirement, "role")
+                    requiredRole = getRelocatedClass(requiredRole, context)
+                    setValue(requirement, "role", requiredRole)
+                }
+            }
+            components[key] = component
+        }
+    }
+
+    override fun modifyOutputStream(os: ZipOutputStream, preserveFileTimestamps: Boolean) {
+        val data = transformedResource
+        val entry = ZipEntry(COMPONENTS_XML_PATH)
+        entry.time = TransformerContext.getEntryTimestamp(preserveFileTimestamps, entry.time)
+        os.putNextEntry(entry)
+        IOUtil.copy(data, os)
+        components.clear()
+    }
+
+    override fun hasTransformedResource(): Boolean {
+        return components.isNotEmpty()
+    }
+
+    private val transformedResource: ByteArray
+        get() {
+            val baos = ByteArrayOutputStream(1024 * 4)
+            val writer: Writer = WriterFactory.newXmlWriter(baos)
+            try {
+                val dom = Xpp3Dom("component-set")
+                val componentDom = Xpp3Dom("components")
+                dom.addChild(componentDom)
+                for (component in components.values) {
+                    componentDom.addChild(component)
+                }
+                Xpp3DomWriter.write(writer, dom)
+            } finally {
+                IOUtil.close(writer)
+            }
+            return baos.toByteArray()
+        }
+
+    companion object {
+        private const val COMPONENTS_XML_PATH = "META-INF/plexus/components.xml"
+        private fun getRelocatedClass(className: String?, context: TransformerContext): String? {
+            val relocators = context.relocators
+            val stats = context.stats
+            if (className != null && className.isNotEmpty() && relocators != null) {
+                for (relocator in relocators) {
+                    if (relocator.canRelocateClass(className)) {
+                        val relocateClassContext = RelocateClassContext(className, stats)
+                        return relocator.relocateClass(relocateClassContext)
+                    }
+                }
+            }
+            return className
+        }
+
+        private fun getValue(dom: Xpp3Dom, element: String): String {
+            val child: Xpp3Dom? = dom.getChild(element)
+            return if (child?.value != null) child.value else ""
+        }
+
+        private fun setValue(dom: Xpp3Dom, element: String, value: String?) {
+            val child: Xpp3Dom? = dom.getChild(element)
+            if (value == null || value.isEmpty()) {
+                return
+            }
+            child?.value = value
+        }
+    }
+}

buildSrc/src/main/kotlin/JvmToolchain.kt

@@ -0,0 +1,183 @@
+@file:JvmName("JvmToolchain")
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.jvm.toolchain.*
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinTopLevelExtension
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+enum class JdkMajorVersion(
+    val majorVersion: Int,
+    val targetName: String = majorVersion.toString(),
+    val overrideMajorVersion: Int? = null,
+    private val mandatory: Boolean = true
+) {
+    JDK_1_6(6, targetName = "1.6", overrideMajorVersion = 8),
+    JDK_1_7(7, targetName = "1.7", overrideMajorVersion = 8),
+    JDK_1_8(8, targetName = "1.8"),
+    JDK_9(9, overrideMajorVersion = 11),
+    JDK_10(10, mandatory = false, overrideMajorVersion = 11),
+    JDK_11(11, mandatory = false),
+    JDK_15(15, mandatory = false),
+    JDK_16(16, mandatory = false);
+
+    fun isMandatory(): Boolean = mandatory
+
+    companion object {
+        fun fromMajorVersion(majorVersion: Int) = values().first { it.majorVersion == majorVersion }
+    }
+}
+
+fun Project.configureJvmDefaultToolchain() {
+    configureJvmToolchain(JdkMajorVersion.JDK_1_8)
+}
+
+fun Project.shouldOverrideObsoleteJdk(
+    jdkVersion: JdkMajorVersion
+): Boolean = kotlinBuildProperties.isObsoleteJdkOverrideEnabled &&
+        jdkVersion.overrideMajorVersion != null
+
+fun Project.configureJvmToolchain(
+    jdkVersion: JdkMajorVersion
+) {
+    // Ensure java only modules also set default toolchain
+    configureJavaOnlyToolchain(jdkVersion)
+
+    plugins.withId("org.jetbrains.kotlin.jvm") {
+        val kotlinExtension = extensions.getByType<KotlinTopLevelExtension>()
+
+        if (shouldOverrideObsoleteJdk(jdkVersion)) {
+            kotlinExtension.jvmToolchain {
+                (this as JavaToolchainSpec).languageVersion
+                    .set(JavaLanguageVersion.of(jdkVersion.overrideMajorVersion!!))
+            }
+            updateJvmTarget(jdkVersion.targetName)
+        } else {
+            kotlinExtension.jvmToolchain {
+                (this as JavaToolchainSpec).languageVersion
+                    .set(JavaLanguageVersion.of(jdkVersion.majorVersion))
+            }
+        }
+
+        tasks
+            .matching { it.name != "compileJava9Java" && it is JavaCompile }
+            .configureEach {
+                with(this as JavaCompile) {
+                    options.compilerArgs.add("-proc:none")
+                    options.encoding = "UTF-8"
+                }
+            }
+
+        tasks.withType<KotlinCompile>().configureEach {
+            kotlinOptions.freeCompilerArgs += "-Xjvm-default=compatibility"
+        }
+    }
+}
+
+fun Project.configureJavaOnlyToolchain(
+    jdkVersion: JdkMajorVersion
+) {
+    plugins.withId("java-base") {
+        val javaExtension = extensions.getByType<JavaPluginExtension>()
+        if (shouldOverrideObsoleteJdk(jdkVersion)) {
+            javaExtension.toolchain {
+                languageVersion.set(
+                    JavaLanguageVersion.of(jdkVersion.overrideMajorVersion!!)
+                )
+            }
+            tasks.withType<JavaCompile>().configureEach {
+                targetCompatibility = jdkVersion.targetName
+                sourceCompatibility = jdkVersion.targetName
+            }
+        } else {
+            javaExtension.toolchain {
+                languageVersion.set(
+                    JavaLanguageVersion.of(jdkVersion.majorVersion)
+                )
+            }
+        }
+    }
+}
+
+fun KotlinCompile.configureTaskToolchain(
+    jdkVersion: JdkMajorVersion
+) {
+    if (project.shouldOverrideObsoleteJdk(jdkVersion)) {
+        kotlinJavaToolchain.toolchain.use(
+            project.getToolchainLauncherFor(
+                JdkMajorVersion.fromMajorVersion(
+                    jdkVersion.overrideMajorVersion!!
+                )
+            )
+        )
+        kotlinOptions {
+            jvmTarget = jdkVersion.targetName
+        }
+    } else {
+        kotlinJavaToolchain.toolchain.use(
+            project.getToolchainLauncherFor(jdkVersion)
+        )
+    }
+}
+
+fun JavaCompile.configureTaskToolchain(
+    jdkVersion: JdkMajorVersion
+) {
+    if (project.shouldOverrideObsoleteJdk(jdkVersion)) {
+        javaCompiler.set(
+            project.getToolchainCompilerFor(
+                JdkMajorVersion.fromMajorVersion(
+                    jdkVersion.overrideMajorVersion!!
+                )
+            )
+        )
+        targetCompatibility = jdkVersion.targetName
+        sourceCompatibility = jdkVersion.targetName
+    } else {
+        javaCompiler.set(project.getToolchainCompilerFor(jdkVersion))
+    }
+}
+
+fun Project.updateJvmTarget(
+    jvmTarget: String
+) {
+    tasks.withType<KotlinCompile>().configureEach {
+        kotlinOptions.jvmTarget = jvmTarget
+    }
+
+    tasks.withType<JavaCompile>().configureEach {
+        sourceCompatibility = jvmTarget
+        targetCompatibility = jvmTarget
+    }
+}
+
+private fun Project.getToolchainCompilerFor(
+    jdkVersion: JdkMajorVersion
+): Provider<JavaCompiler> {
+    val service = project.extensions.getByType<JavaToolchainService>()
+    return service.compilerFor {
+        this.languageVersion.set(JavaLanguageVersion.of(jdkVersion.majorVersion))
+    }
+}
+
+fun Project.getToolchainLauncherFor(
+    jdkVersion: JdkMajorVersion
+): Provider<JavaLauncher> {
+    val service = project.extensions.getByType<JavaToolchainService>()
+    val jdkVersionWithOverride = project.getJdkVersionWithOverride(jdkVersion)
+    return service.launcherFor {
+        this.languageVersion.set(JavaLanguageVersion.of(jdkVersionWithOverride.majorVersion))
+    }
+}
+
+
+fun Project.getJdkVersionWithOverride(jdkVersion: JdkMajorVersion): JdkMajorVersion {
+    return if (project.shouldOverrideObsoleteJdk(jdkVersion)) {
+        JdkMajorVersion.fromMajorVersion(jdkVersion.overrideMajorVersion!!)
+    } else {
+        jdkVersion
+    }
+}

buildSrc/src/main/kotlin/LibrariesCommon.kt

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+@file:JvmName("LibrariesCommon")
+
+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(
+    moduleName: String,
+    moduleOutputs: Collection<FileCollection> = setOf(sourceSets["main"].output)
+) {
+    configurations["java9CompileClasspath"].extendsFrom(configurations["compileClasspath"])
+
+    tasks.named("compileJava9Java", JavaCompile::class.java) {
+        dependsOn(moduleOutputs)
+
+        targetCompatibility = JavaVersion.VERSION_1_9.toString()
+        sourceCompatibility = JavaVersion.VERSION_1_9.toString()
+        configureTaskToolchain(JdkMajorVersion.JDK_9)
+
+        // module-info.java should be in java9 source set by convention
+        val java9SourceSet = sourceSets["java9"].java
+        destinationDir = file("${java9SourceSet.outputDir}/META-INF/versions/9")
+        options.sourcepath = files(java9SourceSet.srcDirs)
+        val compileClasspath = configurations["java9CompileClasspath"]
+        val moduleFiles = objects.fileCollection().from(moduleOutputs)
+        val modulePath = compileClasspath.filter { it !in moduleFiles.files }
+        classpath = objects.fileCollection().from()
+        options.compilerArgumentProviders.add(
+            Java9AdditionalArgumentsProvider(
+                moduleName,
+                moduleFiles,
+                modulePath
+            )
+        )
+    }
+}
+
+private class Java9AdditionalArgumentsProvider(
+    private val moduleName: String,
+    private val moduleFiles: FileCollection,
+    private val modulePath: FileCollection
+) : CommandLineArgumentProvider {
+    override fun asArguments(): Iterable<String> = listOf(
+        "--module-path", modulePath.asPath,
+        "--patch-module", "$moduleName=${moduleFiles.asPath}",
+        "-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/artifacts.kt

@@ -1,6 +1,6 @@
 @file:Suppress("unused") // usages in build scripts are not tracked properly
 
-import org.gradle.api.GradleException
+import com.gradle.publish.PublishTask
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.artifacts.ConfigurablePublishArtifact
@@ -22,12 +22,12 @@ import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.publish.tasks.GenerateModuleMetadata
 import org.gradle.api.tasks.TaskProvider
-import org.gradle.api.tasks.Upload
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.*
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
 import plugins.KotlinBuildPublishingPlugin
+import plugins.mainPublicationName
 
 
 private const val MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME = "testJar"
@@ -62,8 +62,6 @@ fun Project.removeArtifacts(configuration: Configuration, task: Task) {
 
 fun Project.noDefaultJar() {
     tasks.named("jar").configure {
-        enabled = false
-        actions = emptyList()
         configurations.forEach { cfg ->
             removeArtifacts(cfg, this)
         }
@@ -112,6 +110,8 @@ fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {})
         addVariantsFromConfiguration(runtimeJar) { }
     }
 
+    (components.findByName("java") as AdhocComponentWithVariants?)?.addVariantsFromConfiguration(runtimeJar) { }
+
     return task
 }
 
@@ -225,10 +225,23 @@ fun Project.publish(moduleMetadata: Boolean = false, configure: MavenPublication
 
     val publication = extensions.findByType<PublishingExtension>()
         ?.publications
-        ?.findByName(KotlinBuildPublishingPlugin.PUBLICATION_NAME) as MavenPublication
+        ?.findByName(mainPublicationName) as MavenPublication
     publication.configure()
 }
 
+fun Project.publishGradlePlugin() {
+    mainPublicationName = "pluginMaven"
+    publish()
+
+    afterEvaluate {
+        tasks.withType<PublishTask> {
+            // Makes plugin publication task reuse poms and metadata from publication named "pluginMaven"
+            useAutomatedPublishing()
+            useGradleModuleMetadataIfAvailable()
+        }
+    }
+}
+
 fun Project.idePluginDependency(block: () -> Unit) {
     val shouldActivate = rootProject.findProperty("publish.ide.plugin.dependencies")?.toString()?.toBoolean() == true
     if (shouldActivate) {

buildSrc/src/main/kotlin/dependencies.kt

@@ -9,15 +9,15 @@
 
 import org.gradle.api.GradleException
 import org.gradle.api.Project
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.artifacts.ExternalModuleDependency
-import org.gradle.api.artifacts.ModuleDependency
-import org.gradle.api.artifacts.ProjectDependency
+import org.gradle.api.artifacts.*
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
+import org.gradle.internal.jvm.Jvm
+import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.kotlin.dsl.accessors.runtime.addDependencyTo
 import org.gradle.kotlin.dsl.closureOf
+import org.gradle.kotlin.dsl.exclude
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import java.io.File
@@ -124,6 +124,14 @@ fun DependencyHandler.add(configurationName: String, dependencyNotation: Any, co
     }
 }
 
+fun Project.disableDependencyVerification() {
+    configurations.all {
+        resolutionStrategy {
+            disableDependencyVerification()
+        }
+    }
+}
+
 fun DependencyHandler.jpsLikeJarDependency(
     dependencyNotation: Any,
     scope: JpsDepScope,
@@ -281,14 +289,16 @@ fun Project.firstFromJavaHomeThatExists(vararg paths: String, jdkHome: File = Fi
 
 fun Project.toolsJarApi(): Any =
     if (kotlinBuildProperties.isInJpsBuildIdeaSync)
-        files(toolsJarFile() ?: error("tools.jar is not found!"))
+        toolsJar()
     else
         dependencies.project(":dependencies:tools-jar-api")
 
-fun Project.toolsJar(): FileCollection = files(toolsJarFile() ?: error("tools.jar is not found!"))
-
-fun Project.toolsJarFile(jdkHome: File = File(this.property("JDK_18") as String)): File? =
-    firstFromJavaHomeThatExists("lib/tools.jar", jdkHome = jdkHome)
+fun Project.toolsJar(): FileCollection = files(
+    getToolchainLauncherFor(JdkMajorVersion.JDK_1_8)
+        .map {
+            Jvm.forHome(it.metadata.installationPath.asFile).toolsJar ?: throw GradleException("tools.jar not found!")
+        }
+)
 
 val compilerManifestClassPath
     get() = "annotations-13.0.jar kotlin-stdlib.jar kotlin-reflect.jar kotlin-script-runtime.jar trove4j.jar"

buildSrc/src/main/kotlin/embeddable.kt

@@ -2,6 +2,8 @@
 
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.Project
+import org.gradle.api.artifacts.DependencySubstitution
+import org.gradle.api.artifacts.component.ProjectComponentSelector
 import org.gradle.api.file.DuplicatesStrategy
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.jvm.tasks.Jar
@@ -80,6 +82,24 @@ private fun Project.compilerShadowJar(taskName: String, body: ShadowJar.() -> Un
     }
 }
 
+fun Project.configureShadowJarSubstitutionInCompileClasspath() {
+    val substitutionMap = mapOf(":kotlin-reflect" to ":kotlin-reflect-api")
+
+    fun configureSubstitution(substitution: DependencySubstitution) {
+        val requestedProject = (substitution.requested as? ProjectComponentSelector)?.projectPath ?: return
+        val replacementProject = substitutionMap[requestedProject] ?: return
+        substitution.useTarget(project(replacementProject), "Non-default shadow jars should not be used in compile classpath")
+    }
+
+    sourceSets.all {
+        for (configName in listOf(compileOnlyConfigurationName, compileClasspathConfigurationName)) {
+            configurations.getByName(configName).resolutionStrategy.dependencySubstitution {
+                all(::configureSubstitution)
+            }
+        }
+    }
+}
+
 fun Project.embeddableCompiler(taskName: String = "embeddable", body: ShadowJar.() -> Unit = {}): TaskProvider<out ShadowJar> =
     compilerShadowJar(taskName) {
         configureEmbeddableCompilerRelocation()
@@ -93,7 +113,6 @@ fun Project.compilerDummyForDependenciesRewriting(
         exclude(packagesToExcludeFromDummy)
         body()
     }
-
 const val COMPILER_DUMMY_JAR_CONFIGURATION_NAME = "compilerDummyJar"
 
 fun Project.compilerDummyJar(task: TaskProvider<out Jar>, body: Jar.() -> Unit = {}) {

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

@@ -8,7 +8,7 @@ plugins {
     kotlin("jvm")
 }
 
-publish()
+publishGradlePlugin()
 standardPublicJars()
 
 extensions.extraProperties["kotlin.stdlib.default.dependency"] = "false"
@@ -42,7 +42,8 @@ tasks.withType<KotlinCompile> {
     kotlinOptions.freeCompilerArgs += listOf(
         "-Xskip-prerelease-check",
         "-Xskip-runtime-version-check",
-        "-Xsuppress-version-warnings"
+        "-Xsuppress-version-warnings",
+        "-Xuse-ir" // Needed as long as languageVersion is less than 1.5.
     )
 }
 

buildSrc/src/main/kotlin/ideaExtKotlinDsl.kt

@@ -24,16 +24,16 @@ fun ProjectSettings.compiler(block: IdeaCompilerConfiguration.() -> Unit) =
 fun ProjectSettings.delegateActions(block: ActionDelegationConfig.() -> Unit) =
     (this@delegateActions as ExtensionAware).extensions.configure(block)
 
-fun ProjectSettings.runConfigurations(block: DefaultRunConfigurationContainer.() -> Unit) =
+fun ProjectSettings.runConfigurations(block: RunConfigurationContainer.() -> Unit) =
     (this@runConfigurations as ExtensionAware).extensions.configure("runConfigurations", block)
 
-inline fun <reified T: RunConfiguration> DefaultRunConfigurationContainer.defaults(noinline block: T.() -> Unit) =
+inline fun <reified T: RunConfiguration> RunConfigurationContainer.defaults(noinline block: T.() -> Unit) =
     defaults(T::class.java, block)
 
-fun DefaultRunConfigurationContainer.junit(name: String, block: JUnit.() -> Unit) =
+fun RunConfigurationContainer.junit(name: String, block: JUnit.() -> Unit) =
     create(name, JUnit::class.java, block)
 
-fun DefaultRunConfigurationContainer.application(name: String, block: Application.() -> Unit) =
+fun RunConfigurationContainer.application(name: String, block: Application.() -> Unit) =
     create(name, Application::class.java, block)
 
 fun ProjectSettings.ideArtifacts(block: NamedDomainObjectContainer<org.jetbrains.gradle.ext.TopLevelArtifact>.() -> Unit) =

buildSrc/src/main/kotlin/jdksFinder.kt

@@ -1,198 +0,0 @@
-@file:Suppress("unused") // usages in build scripts are not tracked properly
-
-import net.rubygrapefruit.platform.Native
-import net.rubygrapefruit.platform.WindowsRegistry
-import org.gradle.api.GradleException
-import org.gradle.api.Project
-import java.nio.file.Paths
-import java.io.File
-import net.rubygrapefruit.platform.WindowsRegistry.Key.HKEY_LOCAL_MACHINE
-import org.gradle.internal.os.OperatingSystem
-
-enum class JdkMajorVersion(private val mandatory: Boolean = true) {
-    JDK_16, JDK_17, JDK_18, JDK_9, JDK_10(false), JDK_11(false), /*15.0*/JDK_15(false);
-
-    fun isMandatory(): Boolean = mandatory
-}
-
-val jdkAlternativeVarNames = mapOf(JdkMajorVersion.JDK_9 to listOf("JDK_19"), JdkMajorVersion.JDK_15 to listOf("JDK_15_0"))
-
-data class JdkId(val explicit: Boolean, val majorVersion: JdkMajorVersion, var version: String, var homeDir: File)
-
-fun Project.getConfiguredJdks(): List<JdkId> {
-    val res = arrayListOf<JdkId>()
-    for (jdkMajorVersion in JdkMajorVersion.values()) {
-        val explicitJdkEnvVal = findProperty(jdkMajorVersion.name)?.toString()
-                ?: System.getenv(jdkMajorVersion.name)
-                ?: jdkAlternativeVarNames[jdkMajorVersion]?.mapNotNull { System.getenv(it) }?.firstOrNull()
-                ?: continue
-        val explicitJdk = Paths.get(explicitJdkEnvVal).toRealPath().toFile()
-        if (!explicitJdk.isDirectory) {
-            throw GradleException("Invalid environment value $jdkMajorVersion: $explicitJdkEnvVal, expecting JDK home path")
-        }
-        res.add(JdkId(true, jdkMajorVersion, "X", explicitJdk))
-    }
-    if (res.size < JdkMajorVersion.values().size) {
-        res.discoverJdks(this)
-    }
-    return res
-}
-
-// see JEP 223
-private val javaMajorVersionRegex = Regex("""(?:1\.)?(\d+).*""")
-private val javaVersionRegex = Regex("""(?:1\.)?(\d+)(\.\d+)?([+-_]\w+){0,3}""")
-
-fun MutableCollection<JdkId>.addIfBetter(project: Project, version: String, id: String, homeDir: File): Boolean {
-    val matchString = javaMajorVersionRegex.matchEntire(version)?.groupValues?.get(1)
-    val majorJdkVersion = when (matchString) {
-        "6" -> JdkMajorVersion.JDK_16
-        "7" -> JdkMajorVersion.JDK_17
-        "8" -> JdkMajorVersion.JDK_18
-        "9" -> JdkMajorVersion.JDK_9
-        else -> {
-            project.logger.info("Cannot recognize version string '$version' (found version '$matchString')")
-            return false
-        }
-    }
-    val prev = find { it.majorVersion == majorJdkVersion }
-    if (prev == null) {
-        add(JdkId(false, majorJdkVersion, version, homeDir))
-        return true
-    }
-    if (prev.explicit) return false
-    val versionsComparisonRes = compareVersions(prev.version, version)
-    if (versionsComparisonRes < 0 || (versionsComparisonRes == 0 && id.contains("64"))) { // prefer 64-bit
-        prev.version = version
-        prev.homeDir = homeDir
-        return true
-    }
-    return false
-}
-
-private fun compareVersions(left: String, right: String): Int {
-    if (left == right) return 0
-    fun MatchResult.extractNumVer(): List<Int> =
-            groups.drop(2).map {
-                it?.value?.filter { it in '0'..'9' }?.toIntOrNull() ?: 0
-            }
-    val lmi = (javaVersionRegex.matchEntire(left)?.extractNumVer() ?: emptyList()).iterator()
-    val rmi = (javaVersionRegex.matchEntire(right)?.extractNumVer() ?: emptyList()).iterator()
-    while (lmi.hasNext() && rmi.hasNext()) {
-        val l = lmi.next()
-        val r = rmi.next()
-        when {
-            l < r -> return -1
-            l > r -> return 1
-        }
-    }
-    return when {
-        rmi.hasNext() -> -1
-        lmi.hasNext() -> 1
-        else -> 0
-    }
-}
-
-fun MutableCollection<JdkId>.discoverJdks(project: Project) {
-    val os = OperatingSystem.current()
-    when {
-        os.isWindows -> discoverJdksOnWindows(project)
-        os.isMacOsX -> discoverJdksOnMacOS(project)
-        else -> discoverJdksOnUnix(project)
-    }
-}
-
-private val macOsJavaHomeOutRegexes =
-    listOf(
-        Regex("""\s+(\S+),\s+(\S+):\s+".*?"\s+(.+)"""),
-        Regex("""\s+(\S+)\s+\((.*?)\):\s+(.+)"""),
-        Regex("""\s+(\S+)\s+\((.*?)\)\s+"[^"]*"\s+-\s+"[^"]*"\s(.+)"""),
-        Regex("""\s+(\S+)\s+\((.+)\)\s+".+"\s+-\s+".+"\s+(.+)"""))
-
-fun MutableCollection<JdkId>.discoverJdksOnMacOS(project: Project) {
-    val procBuilder = ProcessBuilder("/usr/libexec/java_home", "-V").redirectErrorStream(true)
-    val process = procBuilder.start()
-    val retCode = process.waitFor()
-    if (retCode != 0) throw GradleException("Unable to run 'java_home', return code $retCode")
-    process.inputStream.bufferedReader().forEachLine { line ->
-        for (rex in macOsJavaHomeOutRegexes) {
-            val matchResult = rex.matchEntire(line)
-            if (matchResult != null) {
-                val jdkHomeDir = File(matchResult.groupValues[3])
-                // Filter out JRE installed at /Library/Internet Plug-Ins/JavaAppletPlugin.plugin/
-                // and shown by the java_home tool
-                if (!jdkHomeDir.path.contains("JavaAppletPlugin.plugin")) {
-                    addIfBetter(project, matchResult.groupValues[1], matchResult.groupValues[0], jdkHomeDir)
-                    break
-                }
-            }
-        }
-    }
-}
-
-private val unixConventionalJdkLocations = listOf(
-        "/usr/lib/jvm",       // *deb, Arch
-        "/opt",               // *rpm, Gentoo, HP/UX
-        "/usr/lib",           // Slackware 32
-        "/usr/lib64",         // Slackware 64
-        "/usr/local",         // OpenBSD, FreeBSD
-        "/usr/pkg/java",      // NetBSD
-        "/usr/jdk/instances") // Solaris
-
-private val unixConventionalJdkDirRex = Regex("jdk|jre|java|zulu")
-
-fun MutableCollection<JdkId>.discoverJdksOnUnix(project: Project) {
-    for (loc in unixConventionalJdkLocations) {
-        val installedJdks = File(loc).listFiles { dir ->
-            dir.isDirectory &&
-            unixConventionalJdkDirRex.containsMatchIn(dir.name) &&
-            fileFrom(dir, "bin", "java").isFile
-        } ?: continue
-        for (dir in installedJdks) {
-            val versionMatch = javaVersionRegex.find(dir.name)
-            if (versionMatch == null) {
-                project.logger.info("Unable to extract version from possible JDK dir: $dir")
-            }
-            else {
-                addIfBetter(project, versionMatch.value, dir.name, dir)
-            }
-        }
-    }
-}
-
-private val windowsConventionalJdkRegistryPaths = listOf(
-        "SOFTWARE\\JavaSoft\\Java Development Kit",
-        "SOFTWARE\\Wow6432Node\\JavaSoft\\Java Development Kit",
-        "SOFTWARE\\JavaSoft\\JDK",
-        "SOFTWARE\\Wow6432Node\\JavaSoft\\JDK")
-
-fun MutableCollection<JdkId>.discoverJdksOnWindows(project: Project) {
-    val registry = Native.get(WindowsRegistry::class.java)
-    for (regPath in windowsConventionalJdkRegistryPaths) {
-        val jdkKeys = try {
-            registry.getSubkeys(HKEY_LOCAL_MACHINE, regPath)
-        } catch (e: RuntimeException) {
-            // ignore missing nodes
-            continue
-        }
-        for (jdkKey in jdkKeys) {
-            try {
-                val javaHome = registry.getStringValue(HKEY_LOCAL_MACHINE, regPath + "\\" + jdkKey, "JavaHome")
-                val versionMatch = javaVersionRegex.find(jdkKey)
-                if (versionMatch == null) {
-                    project.logger.info("Unable to extract version from possible JDK location: $javaHome ($jdkKey)")
-                }
-                else {
-                    javaHome.takeIf { it.isNotEmpty() }
-                            ?.let { File(it) }
-                            ?.takeIf { it.isDirectory && fileFrom(it, "bin", "java.exe").isFile }
-                            ?.let {
-                                addIfBetter(project, versionMatch.value, jdkKey, it)
-                            }
-                }
-            }
-            catch (e: RuntimeException) {
-                // Ignore
-            }
-        }
-    }
-}

buildSrc/src/main/kotlin/localDependencies.kt

@@ -17,16 +17,11 @@
 // 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 =
@@ -146,70 +141,4 @@ fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFi
         rootProject = project.rootProject
     )
 
-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()
-    }
-}
+fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -14,6 +14,7 @@ import org.gradle.api.tasks.bundling.Jar
 import org.gradle.kotlin.dsl.*
 import plugins.KotlinBuildPublishingPlugin
 import plugins.configureRepository
+import plugins.mainPublicationName
 import java.util.*
 
 internal const val PLUGIN_MARKER_SUFFIX = ".gradle.plugin"
@@ -26,7 +27,7 @@ fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
 
     val pluginDevelopment = extensions.getByType<PluginBundleExtension>()
     val publishingExtension = extensions.getByType<PublishingExtension>()
-    val mainPublication = publishingExtension.publications[KotlinBuildPublishingPlugin.PUBLICATION_NAME] as MavenPublication
+    val mainPublication = publishingExtension.publications[mainPublicationName] as MavenPublication
 
     pluginDevelopment.plugins.forEach { declaration ->
         val markerPublication = createMavenMarkerPublication(declaration, mainPublication, publishingExtension.publications)

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

@@ -68,7 +68,7 @@ class KotlinBuildPublishingPlugin @Inject constructor(
 
         configure<PublishingExtension> {
             publications {
-                create<MavenPublication>(PUBLICATION_NAME) {
+                create<MavenPublication>(project.mainPublicationName) {
                     from(kotlinLibraryComponent)
 
                     configureKotlinPomAttributes(project)
@@ -79,16 +79,26 @@ class KotlinBuildPublishingPlugin @Inject constructor(
     }
 
     companion object {
-        const val PUBLICATION_NAME = "Main"
+        const val DEFAULT_MAIN_PUBLICATION_NAME = "Main"
+        const val MAIN_PUBLICATION_NAME_PROPERTY = "MainPublicationName"
         const val REPOSITORY_NAME = "Maven"
         const val ADHOC_COMPONENT_NAME = "kotlinLibrary"
 
         const val COMPILE_CONFIGURATION = "publishedCompile"
         const val RUNTIME_CONFIGURATION = "publishedRuntime"
-
     }
 }
 
+var Project.mainPublicationName: String
+    get() {
+        return if (project.extra.has(KotlinBuildPublishingPlugin.MAIN_PUBLICATION_NAME_PROPERTY))
+            project.extra.get(KotlinBuildPublishingPlugin.MAIN_PUBLICATION_NAME_PROPERTY) as String
+        else KotlinBuildPublishingPlugin.DEFAULT_MAIN_PUBLICATION_NAME
+    }
+    set(value) {
+        project.extra.set(KotlinBuildPublishingPlugin.MAIN_PUBLICATION_NAME_PROPERTY, value)
+    }
+
 @OptIn(ExperimentalStdlibApi::class)
 private fun humanReadableName(name: String) =
     name.split("-").joinToString(separator = " ") { it.capitalize(Locale.ROOT) }

buildSrc/src/main/kotlin/testDistribution.kt

@@ -9,13 +9,13 @@ import org.gradle.internal.os.OperatingSystem
 
 
 fun Test.configureTestDistribution(configure: TestDistributionExtension.() -> Unit = {}) {
-    if (extensions.findByType(TestDistributionExtension::class.java) == null) return
-
     val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
+    val testDistributionEnabled =
+        project.findProperty("kotlin.build.test.distribution.enabled")?.toString()?.toBoolean() ?: false
 
     useJUnitPlatform()
     extensions.configure(TestDistributionExtension::class.java) {
-        enabled.set(true)
+        enabled.set(testDistributionEnabled)
         maxRemoteExecutors.set(20)
         if (isTeamcityBuild) {
             requirements.set(setOf("os=${OperatingSystem.current().familyName}"))

compiler/android-tests/build.gradle.kts

@@ -24,7 +24,6 @@ dependencies {
     testApi(projectTests(":compiler:tests-compiler-utils"))
     testApi(projectTests(":compiler:tests-common-new"))
 
-    testCompile(projectTests(":jps-plugin"))
     testCompile(commonDep("junit:junit"))
 
     testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", rootProject = rootProject) }
@@ -34,6 +33,9 @@ dependencies {
     testCompile(jpsStandalone()) { includeJars("jps-model") }
     testCompile(jpsBuildTest())
 
+    testRuntimeOnly(compile(intellijCoreDep()) { includeJars("intellij-core") })
+    testRuntimeOnly(compile(intellijDep()) { includeJars("jna", rootProject = rootProject) })
+
     testCompile("org.junit.platform:junit-platform-launcher:${commonVer("org.junit.platform", "")}")
 }
 

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

@@ -5,13 +5,10 @@
 
 package org.jetbrains.kotlin.backend.common
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.resolve.sam.getAbstractMembers
-import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithNothing
+import org.jetbrains.kotlin.types.KotlinType
 
 class SamType constructor(val type: KotlinType) {
 
@@ -37,54 +34,3 @@ class SamType constructor(val type: KotlinType) {
     }
 }
 
-open class SamTypeFactory {
-    fun createByValueParameter(valueParameter: ValueParameterDescriptor): SamType? {
-        val singleArgumentType: KotlinType
-        val originalSingleArgumentType: KotlinType?
-        val varargElementType = valueParameter.varargElementType
-        if (varargElementType != null) {
-            singleArgumentType = varargElementType
-            originalSingleArgumentType = valueParameter.original.varargElementType
-            assert(originalSingleArgumentType != null) {
-                "Value parameter and original value parameter have inconsistent varargs: " +
-                        valueParameter + "; " + valueParameter.original
-            }
-        } else {
-            singleArgumentType = valueParameter.type
-            originalSingleArgumentType = valueParameter.original.type
-        }
-        if (singleArgumentType.isError || originalSingleArgumentType!!.isError) {
-            return null
-        }
-        // This can be true in case when the value parameter is in the method of a generic type with out-projection.
-        // We approximate Inv<Captured#1> to Nothing, while Inv itself can be a SAM interface safe to call here
-        // (see testData genericSamProjectedOut.kt for details)
-        // In such a case we can't have a proper supertype since wildcards are not allowed there,
-        // so we use Nothing arguments instead that leads to a raw type used for a SAM wrapper.
-        // See org.jetbrains.kotlin.codegen.state.KotlinTypeMapper#writeGenericType to understand how
-        // raw types and Nothing arguments relate.
-        val originalTypeToUse =
-            if (KotlinBuiltIns.isNothing(singleArgumentType))
-                originalSingleArgumentType.replaceArgumentsWithNothing()
-            else singleArgumentType
-        return create(originalTypeToUse.removeExternalProjections())
-    }
-
-    open fun isSamType(type: KotlinType): Boolean {
-        val descriptor = type.constructor.declarationDescriptor
-        return descriptor is ClassDescriptor && descriptor.isFun
-    }
-
-    fun create(originalType: KotlinType): SamType? {
-        return if (isSamType(originalType)) SamType(originalType) else null
-    }
-
-    private fun KotlinType.removeExternalProjections(): KotlinType {
-        val newArguments = arguments.map { TypeProjectionImpl(Variance.INVARIANT, it.type) }
-        return replace(newArguments)
-    }
-
-    companion object {
-        val INSTANCE = SamTypeFactory()
-    }
-}

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

@@ -0,0 +1,76 @@
+/*
+ * 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.backend.common
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.intersectWrappedTypes
+import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithNothing
+
+class SamTypeApproximator(builtIns: KotlinBuiltIns, languageVersionSettings: LanguageVersionSettings) {
+    private val typeApproximator = TypeApproximator(builtIns, languageVersionSettings)
+
+    fun getSamTypeForValueParameter(valueParameter: ValueParameterDescriptor): KotlinType? {
+        val singleArgumentType: KotlinType
+        val originalSingleArgumentType: KotlinType?
+        val varargElementType = valueParameter.varargElementType
+        if (varargElementType != null) {
+            singleArgumentType = varargElementType
+            originalSingleArgumentType = valueParameter.original.varargElementType
+            assert(originalSingleArgumentType != null) {
+                "Value parameter and original value parameter have inconsistent varargs: " +
+                        valueParameter + "; " + valueParameter.original
+            }
+        } else {
+            singleArgumentType = valueParameter.type
+            originalSingleArgumentType = valueParameter.original.type
+        }
+        if (singleArgumentType.isError || originalSingleArgumentType!!.isError) {
+            return null
+        }
+
+        // This can be true in case when the value parameter is in the method of a generic type with out-projection.
+        // We approximate Inv<Captured#1> to Nothing, while Inv itself can be a SAM interface safe to call here
+        // (see testData genericSamProjectedOut.kt for details)
+        // In such a case we can't have a proper supertype since wildcards are not allowed there,
+        // so we use Nothing arguments instead that leads to a raw type used for a SAM wrapper.
+        // See org.jetbrains.kotlin.codegen.state.KotlinTypeMapper#writeGenericType to understand how
+        // raw types and Nothing arguments relate.
+        val originalTypeToUse =
+            if (KotlinBuiltIns.isNothing(singleArgumentType))
+                originalSingleArgumentType.replaceArgumentsWithNothing()
+            else
+                singleArgumentType
+        val approximatedOriginalTypeToUse =
+            typeApproximator.approximateToSubType(
+                originalTypeToUse,
+                TypeApproximatorConfiguration.UpperBoundAwareIntersectionTypeApproximator
+            ) ?: originalTypeToUse
+        approximatedOriginalTypeToUse as KotlinType
+
+        return approximatedOriginalTypeToUse.removeExternalProjections()
+    }
+
+    private fun KotlinType.removeExternalProjections(): KotlinType {
+        val newArguments = arguments.map { TypeProjectionImpl(Variance.INVARIANT, it.type) }
+        return replace(newArguments)
+    }
+
+}
+
+open class SamTypeFactory {
+    open fun isSamType(type: KotlinType): Boolean {
+        val descriptor = type.constructor.declarationDescriptor
+        return descriptor is ClassDescriptor && descriptor.isFun
+    }
+
+    fun create(originalType: KotlinType): SamType? {
+        return if (isSamType(originalType)) SamType(originalType) else null
+    }
+}

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

@@ -19,7 +19,9 @@ interface TypeMappingContext<Writer : JvmDescriptorTypeWriter<Type>> {
 
     fun getClassInternalName(typeConstructor: TypeConstructorMarker): String
     fun getScriptInternalName(typeConstructor: TypeConstructorMarker): String
-    fun Writer.writeGenericType(type: SimpleTypeMarker, asmType: Type, mode: TypeMappingMode)
+
+    // NB: The counterpart, [KotlinTypeMapper#writeGenericType], doesn't have restriction on [type]
+    fun Writer.writeGenericType(type: KotlinTypeMarker, asmType: Type, mode: TypeMappingMode)
 }
 
 object AbstractTypeMapper {
@@ -44,6 +46,7 @@ object AbstractTypeMapper {
         sw: Writer? = null
     ): Type = context.typeContext.mapType(context, type, mode, sw)
 
+    // NB: The counterpart, [descriptorBasedTypeSignatureMapping#mapType] doesn't have restriction on [type].
     @OptIn(ExperimentalStdlibApi::class)
     private fun <Writer : JvmDescriptorTypeWriter<Type>> TypeSystemCommonBackendContextForTypeMapping.mapType(
         context: TypeMappingContext<Writer>,
@@ -51,10 +54,7 @@ object AbstractTypeMapper {
         mode: TypeMappingMode = TypeMappingMode.DEFAULT,
         sw: Writer? = null
     ): Type {
-        if (type !is SimpleTypeMarker) {
-            error("Unexpected type: $type (original Kotlin type=$type of ${type.let { it::class }})")
-        }
-        if (type.isSuspendFunction()) {
+        if (type is SimpleTypeMarker && type.isSuspendFunction()) {
             val argumentsCount = type.argumentsCount()
             val argumentsList = type.asArgumentList()
 
@@ -79,7 +79,7 @@ object AbstractTypeMapper {
         val typeConstructor = type.typeConstructor()
 
         when {
-            type.isArrayOrNullableArray() -> {
+            type is SimpleTypeMarker && type.isArrayOrNullableArray() -> {
                 val typeArgument = type.asArgumentList()[0]
                 val (variance, memberType) = when {
                     typeArgument.isStarProjection() -> Variance.OUT_VARIANCE to nullableAnyType()
@@ -99,7 +99,7 @@ object AbstractTypeMapper {
                 return AsmUtil.getArrayType(arrayElementType)
             }
 
-            typeConstructor.isClassTypeConstructor() -> {
+            type is SimpleTypeMarker && typeConstructor.isClassTypeConstructor() -> {
                 if (typeConstructor.isInlineClass() && !mode.needInlineClassWrapping) {
                     val expandedType = computeExpandedTypeForInlineClass(type)
                     require(expandedType is SimpleTypeMarker?)

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

@@ -20,14 +20,12 @@ import org.jetbrains.kotlin.codegen.inline.NameGenerator
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner.Companion.putReifiedOperationMarker
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner.OperationKind
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeParametersUsages
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.model.TypeParameterMarker
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
 interface BaseExpressionCodegen {
-
     val frameMap: FrameMapBase<*>
 
     val visitor: InstructionAdapter
@@ -40,24 +38,14 @@ interface BaseExpressionCodegen {
 
     fun propagateChildReifiedTypeParametersUsages(reifiedTypeParametersUsages: ReifiedTypeParametersUsages)
 
-    fun pushClosureOnStack(
-        classDescriptor: ClassDescriptor,
-        putThis: Boolean,
-        callGenerator: CallGenerator,
-        functionReferenceReceiver: StackValue?
-    )
-
     fun markLineNumberAfterInlineIfNeeded(registerLineNumberAfterwards: Boolean)
 
     fun consumeReifiedOperationMarker(typeParameter: TypeParameterMarker)
-
-    fun putReifiedOperationMarkerIfTypeIsReifiedParameter(type: KotlinTypeMarker, operationKind: OperationKind) {
-        with(typeSystem) {
-            val (typeParameter, second) = extractReificationArgument(type) ?: return
-            if (typeParameter.isReified()) {
-                consumeReifiedOperationMarker(typeParameter)
-                putReifiedOperationMarker(operationKind, second, visitor)
-            }
-        }
-    }
+}
+
+fun BaseExpressionCodegen.putReifiedOperationMarkerIfTypeIsReifiedParameter(type: KotlinTypeMarker, operationKind: OperationKind): Boolean {
+    val (typeParameter, second) = typeSystem.extractReificationArgument(type) ?: return false
+    consumeReifiedOperationMarker(typeParameter)
+    putReifiedOperationMarker(operationKind, second, visitor)
+    return true
 }

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
+import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
 import org.jetbrains.kotlin.types.upperIfFlexible
 import org.jetbrains.org.objectweb.asm.Type
@@ -51,7 +52,7 @@ class CallBasedArgumentGenerator(
         callGenerator.putValueIfNeeded(
             getJvmKotlinType(i),
             StackValue.createDefaultValue(valueParameterTypes[i]),
-            ValueKind.DEFAULT_PARAMETER,
+            if (InlineUtil.isInlineParameter(valueParameters[i])) ValueKind.DEFAULT_INLINE_PARAMETER else ValueKind.DEFAULT_PARAMETER,
             i
         )
     }

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

@@ -15,10 +15,9 @@ enum class ValueKind {
     GENERAL,
     GENERAL_VARARG,
     DEFAULT_PARAMETER,
+    DEFAULT_INLINE_PARAMETER,
     DEFAULT_MASK,
     METHOD_HANDLE_IN_DEFAULT,
-    CAPTURED,
-    DEFAULT_LAMBDA_CAPTURED_PARAMETER,
     NON_INLINEABLE_ARGUMENT_FOR_INLINE_PARAMETER_CALLED_IN_SUSPEND,
     NON_INLINEABLE_ARGUMENT_FOR_INLINE_SUSPEND_PARAMETER
 }
@@ -40,13 +39,9 @@ interface CallGenerator {
             }
         }
 
-        override fun processAndPutHiddenParameters(justProcess: Boolean) {
+        override fun processHiddenParameters() {}
 
-        }
-
-        override fun putHiddenParamsIntoLocals() {
-
-        }
+        override fun putHiddenParamsIntoLocals() {}
 
         override fun genValueAndPut(
             valueParameterDescriptor: ValueParameterDescriptor?,
@@ -141,9 +136,8 @@ interface CallGenerator {
         paramIndex: Int
     )
 
-    fun processAndPutHiddenParameters(justProcess: Boolean)
+    fun processHiddenParameters()
 
-    /*should be called if justProcess = true in processAndPutHiddenParameters*/
     fun putHiddenParamsIntoLocals()
 
     fun reorderArgumentsIfNeeded(actualArgsWithDeclIndex: List<ArgumentAndDeclIndex>, valueParameterTypes: List<Type>)

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

@@ -27,24 +27,16 @@ import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.config.AnalysisFlags;
 import org.jetbrains.kotlin.config.JvmAnalysisFlags;
-import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.DescriptorUtilKt;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.load.kotlin.ModuleMappingUtilKt;
 import org.jetbrains.kotlin.metadata.ProtoBuf;
 import org.jetbrains.kotlin.metadata.jvm.JvmModuleProtoBuf;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMapping;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMappingKt;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.PackageParts;
-import org.jetbrains.kotlin.metadata.serialization.StringTable;
-import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration;
-import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.serialization.StringTableImpl;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -52,7 +44,6 @@ import org.jetbrains.org.objectweb.asm.Type;
 import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
 
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.getMappingFileName;
 
@@ -134,11 +125,6 @@ public class ClassFileFactory implements OutputFileCollection {
         StringTableImpl stringTable = new StringTableImpl();
         ClassFileUtilsKt.addDataFromCompiledModule(builder, packagePartRegistry, stringTable, state);
 
-        List<String> experimental = state.getLanguageVersionSettings().getFlag(AnalysisFlags.getExperimental());
-        if (!experimental.isEmpty()) {
-            writeExperimentalMarkers(state.getModule(), builder, experimental, stringTable);
-        }
-
         Pair<ProtoBuf.StringTable, ProtoBuf.QualifiedNameTable> tables = stringTable.buildProto();
         builder.setStringTable(tables.getFirst());
         builder.setQualifiedNameTable(tables.getSecond());
@@ -162,26 +148,6 @@ public class ClassFileFactory implements OutputFileCollection {
         });
     }
 
-    private static void writeExperimentalMarkers(
-            @NotNull ModuleDescriptor module,
-            @NotNull JvmModuleProtoBuf.Module.Builder builder,
-            @NotNull List<String> experimental,
-            @NotNull StringTable stringTable
-    ) {
-        for (String fqName : experimental) {
-            ClassDescriptor descriptor =
-                    DescriptorUtilKt.resolveClassByFqName(module, new FqName(fqName), NoLookupLocation.FOR_ALREADY_TRACKED);
-            if (descriptor != null) {
-                ProtoBuf.Annotation.Builder annotation = ProtoBuf.Annotation.newBuilder();
-                ClassId classId = DescriptorUtilsKt.getClassId(descriptor);
-                if (classId != null) {
-                    annotation.setId(stringTable.getQualifiedClassNameIndex(classId.asString(), false));
-                    builder.addAnnotation(annotation);
-                }
-            }
-        }
-    }
-
     @NotNull
     @Override
     public List<OutputFile> asList() {

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

@@ -6,19 +6,17 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
-import org.jetbrains.kotlin.codegen.inline.InlineCodegen
-import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
+import org.jetbrains.kotlin.codegen.inline.loadCompiledInlineFunction
+import org.jetbrains.kotlin.codegen.optimization.nullCheck.usesLocalExceptParameterNullCheck
 import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.FunctionImportedFromObject
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
 
 class DelegatedPropertiesCodegenHelper(private val state: GenerationState) {
 
@@ -65,27 +63,15 @@ class DelegatedPropertiesCodegenHelper(private val state: GenerationState) {
             this
 
     private fun isDelegatedPropertyMetadataRequiredForFunctionFromBinaries(calleeDescriptor: FunctionDescriptor): Boolean {
-        assert(calleeDescriptor is DescriptorWithContainerSource) {
+        require(calleeDescriptor is DescriptorWithContainerSource) {
             "Function descriptor from binaries expected: $calleeDescriptor"
         }
-
         val metadataParameterIndex = getMetadataParameterIndex(calleeDescriptor)
-        val methodNode = InlineCodegen.createSpecialInlineMethodNodeFromBinaries(calleeDescriptor, state)
-
-        return isMetadataParameterUsedInCompiledMethodBody(metadataParameterIndex, methodNode)
-    }
-
-    private fun isMetadataParameterUsedInCompiledMethodBody(metadataParameterIndex: Int, methodNode: MethodNode): Boolean =
-        methodNode.instructions.toArray().any { insn ->
-            insn is VarInsnNode && insn.opcode == Opcodes.ALOAD && insn.`var` == metadataParameterIndex &&
-                    !isParameterNullCheckArgument(insn)
-        }
-
-    private fun isParameterNullCheckArgument(insn: AbstractInsnNode): Boolean {
-        val next1 = insn.next
-        val next2 = next1.next
-        return next1 != null && next2 != null &&
-                next1.opcode == Opcodes.LDC && next2.isCheckParameterIsNotNull()
+        val containerId = KotlinTypeMapper.getContainingClassesForDeserializedCallable(calleeDescriptor).implClassId
+        val asmMethod = state.typeMapper.mapAsmMethod(calleeDescriptor)
+        val isMangled = requiresFunctionNameManglingForReturnType(calleeDescriptor)
+        val methodNode = loadCompiledInlineFunction(containerId, asmMethod, calleeDescriptor.isSuspend, isMangled, state).node
+        return methodNode.usesLocalExceptParameterNullCheck(metadataParameterIndex)
     }
 
     private fun getMetadataParameterIndex(calleeDescriptor: FunctionDescriptor): Int {

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

@@ -107,6 +107,7 @@ import java.util.stream.Collectors;
 import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isInt;
 import static org.jetbrains.kotlin.codegen.AsmUtil.boxType;
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.codegen.BaseExpressionCodegenKt.putReifiedOperationMarkerIfTypeIsReifiedParameter;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.*;
 import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.boxType;
 import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
@@ -1261,9 +1262,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             if (closure.isSuspendLambda()) {
                 // When inlining crossinline lambda, the ACONST_NULL is never popped.
                 // Thus, do not generate it. Otherwise, it leads to VerifyError on run-time.
-                boolean isCrossinlineLambda = (callGenerator instanceof InlineCodegen<?>) &&
-                                              Objects.requireNonNull(((InlineCodegen) callGenerator).getActiveLambda(),
-                                                                     "no active lambda found").isCrossInline;
+                boolean isCrossinlineLambda = (callGenerator instanceof PsiInlineCodegen) &&
+                                              Objects.requireNonNull(((PsiInlineCodegen) callGenerator).getActiveLambda(),
+                                                                     "no active lambda found").isCrossInline();
                 if (!isCrossinlineLambda) {
                     v.aconst(null);
                 }
@@ -2780,7 +2781,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             putReceiverAndInlineMarkerIfNeeded(callableMethod, resolvedCall, receiver, maybeSuspensionPoint, isConstructor);
         }
 
-        callGenerator.processAndPutHiddenParameters(false);
+        callGenerator.processHiddenParameters();
+        callGenerator.putHiddenParamsIntoLocals();
 
         List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
         assert valueArguments != null : "Failed to arrange value arguments by index: " + resolvedCall.getResultingDescriptor();
@@ -2949,13 +2951,12 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                         bindingContext, state
                 );
 
-        PsiSourceCompilerForInline sourceCompiler = new PsiSourceCompilerForInline(this, callElement);
         FunctionDescriptor functionDescriptor =
                 InlineUtil.isArrayConstructorWithLambda(original)
                 ? FictitiousArrayConstructor.create((ConstructorDescriptor) original) : original.getOriginal();
+        PsiSourceCompilerForInline sourceCompiler = new PsiSourceCompilerForInline(this, callElement, functionDescriptor);
 
-        sourceCompiler.initializeInlineFunctionContext(functionDescriptor);
-        JvmMethodSignature signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContextKind());
+        JvmMethodSignature signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContext().getContextKind());
         if (signature.getAsmMethod().getName().contains("-") &&
             !state.getConfiguration().getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME)
         ) {
@@ -2963,17 +2964,17 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     InlineClassesCodegenUtilKt.classFileContainsMethod(functionDescriptor, state, signature.getAsmMethod());
             if (classFileContainsMethod != null && !classFileContainsMethod) {
                 typeMapper.setUseOldManglingRulesForFunctionAcceptingInlineClass(true);
-                signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContextKind());
+                signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContext().getContextKind());
                 typeMapper.setUseOldManglingRulesForFunctionAcceptingInlineClass(false);
             }
         }
-        Type methodOwner = typeMapper.mapImplementationOwner(functionDescriptor);
         if (isDefaultCompilation) {
-            return new InlineCodegenForDefaultBody(functionDescriptor, this, state, methodOwner, signature, sourceCompiler);
-        }
-        else {
-            return new PsiInlineCodegen(this, state, functionDescriptor, methodOwner, signature, typeParameterMappings, sourceCompiler,
-                                        typeMapper.mapOwner(descriptor));
+            return new InlineCodegenForDefaultBody(functionDescriptor, this, state, signature, sourceCompiler);
+        } else {
+            return new PsiInlineCodegen(
+                    this, state, functionDescriptor, signature, typeParameterMappings, sourceCompiler,
+                    typeMapper.mapImplementationOwner(functionDescriptor), typeMapper.mapOwner(descriptor), callElement
+            );
         }
     }
 
@@ -3557,7 +3558,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                 if (TypeUtils.isTypeParameter(type)) {
                     assert TypeUtils.isReifiedTypeParameter(type) :
                             "Non-reified type parameter under ::class should be rejected by type checker: " + type;
-                    putReifiedOperationMarkerIfTypeIsReifiedParameter(type, ReifiedTypeInliner.OperationKind.JAVA_CLASS);
+                    putReifiedOperationMarkerIfTypeIsReifiedParameter(this, type, ReifiedTypeInliner.OperationKind.JAVA_CLASS);
                 }
 
                 putJavaLangClassInstance(v, typeMapper.mapType(type), type, typeMapper);
@@ -4930,10 +4931,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     public void newArrayInstruction(@NotNull KotlinType arrayType) {
         if (KotlinBuiltIns.isArray(arrayType)) {
             KotlinType elementJetType = arrayType.getArguments().get(0).getType();
-            putReifiedOperationMarkerIfTypeIsReifiedParameter(
-                    elementJetType,
-                    ReifiedTypeInliner.OperationKind.NEW_ARRAY
-            );
+            putReifiedOperationMarkerIfTypeIsReifiedParameter(this, elementJetType, ReifiedTypeInliner.OperationKind.NEW_ARRAY);
             v.newarray(boxType(typeMapper.mapTypeAsDeclaration(elementJetType)));
         }
         else {
@@ -5237,7 +5235,7 @@ The "returned" value of try expression with no finally is either the last expres
 
             boolean safeAs = opToken == KtTokens.AS_SAFE;
             if (TypeUtils.isReifiedTypeParameter(rightKotlinType)) {
-                putReifiedOperationMarkerIfTypeIsReifiedParameter(rightKotlinType,
+                putReifiedOperationMarkerIfTypeIsReifiedParameter(this, rightKotlinType,
                                                                   safeAs ? ReifiedTypeInliner.OperationKind.SAFE_AS
                                                                          : ReifiedTypeInliner.OperationKind.AS);
                 v.checkcast(boxedRightType);
@@ -5294,7 +5292,7 @@ The "returned" value of try expression with no finally is either the last expres
 
             Type type = boxType(typeMapper.mapTypeAsDeclaration(rhsKotlinType));
             if (TypeUtils.isReifiedTypeParameter(rhsKotlinType)) {
-                putReifiedOperationMarkerIfTypeIsReifiedParameter(rhsKotlinType, ReifiedTypeInliner.OperationKind.IS);
+                putReifiedOperationMarkerIfTypeIsReifiedParameter(this, rhsKotlinType, ReifiedTypeInliner.OperationKind.IS);
                 v.instanceOf(type);
                 return null;
             }
@@ -5546,11 +5544,4 @@ The "returned" value of try expression with no finally is either the last expres
             parentCodegen.getReifiedTypeParametersUsages().addUsedReifiedParameter(typeParameterDescriptor.getName().asString());
         }
     }
-
-    @Override
-    public void putReifiedOperationMarkerIfTypeIsReifiedParameter(
-            @NotNull KotlinTypeMarker type, @NotNull ReifiedTypeInliner.OperationKind operationKind
-    ) {
-        BaseExpressionCodegen.DefaultImpls.putReifiedOperationMarkerIfTypeIsReifiedParameter(this, type, operationKind);
-    }
 }

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

@@ -68,6 +68,13 @@ open class FrameMapBase<T : Any> {
         return Mark(currentSize)
     }
 
+    fun skipTo(target: Int): Mark {
+        return mark().also {
+            if (currentSize < target)
+                currentSize = target
+        }
+    }
+
     inner class Mark(private val myIndex: Int) {
 
         fun dropTo() {

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

@@ -5,10 +5,11 @@
 
 package org.jetbrains.kotlin.codegen
 
+import org.jetbrains.kotlin.backend.common.SamTypeFactory
 import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.backend.common.SamTypeFactory
 
-object JvmSamTypeFactory : SamTypeFactory() {
-    override fun isSamType(type: KotlinType) = JavaSingleAbstractMethodUtils.isSamType(type)
+class JvmSamTypeFactory : SamTypeFactory() {
+    override fun isSamType(type: KotlinType) =
+        JavaSingleAbstractMethodUtils.isSamType(type)
 }

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

@@ -45,7 +45,6 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.types.SimpleType;
-import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.Opcodes;
@@ -1329,8 +1328,8 @@ public abstract class StackValue {
             StackValue newReceiver = StackValue.receiver(call, receiver, codegen, callable);
             ArgumentGenerator generator = createArgumentGenerator();
             newReceiver.put(newReceiver.type, newReceiver.kotlinType, v);
-            callGenerator.processAndPutHiddenParameters(false);
-
+            callGenerator.processHiddenParameters();
+            callGenerator.putHiddenParamsIntoLocals();
             defaultArgs = generator.generate(valueArguments, valueArguments, call.getResultingDescriptor());
         }
 
@@ -1748,7 +1747,8 @@ public abstract class StackValue {
                 assert getterDescriptor != null : "Getter descriptor should be not null for " + descriptor;
                 if (resolvedCall != null && getterDescriptor.isInline()) {
                     CallGenerator callGenerator = codegen.getOrCreateCallGenerator(resolvedCall, ((PropertyDescriptor)resolvedCall.getResultingDescriptor()).getGetter());
-                    callGenerator.processAndPutHiddenParameters(false);
+                    callGenerator.processHiddenParameters();
+                    callGenerator.putHiddenParamsIntoLocals();
                     callGenerator.genCall(getter, resolvedCall, false, codegen);
                 }
                 else {
@@ -1832,7 +1832,7 @@ public abstract class StackValue {
                 if (!skipReceiver) {
                     putReceiver(v, false);
                 }
-                callGenerator.processAndPutHiddenParameters(true);
+                callGenerator.processHiddenParameters();
                 callGenerator.putValueIfNeeded(new JvmKotlinType(
                                                        CollectionsKt.last(setter.getValueParameters()).getAsmType(),
                                                        CollectionsKt.last(setterDescriptor.getValueParameters()).getType()),

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

@@ -22,7 +22,9 @@ import java.lang.StringBuilder
 class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapter) {
 
     private val template = StringBuilder("")
+    private val specialSymbolsInTemplate = arrayListOf<String>()
     private val paramTypes = arrayListOf<Type>()
+    private var paramSlots = 0
     private var justFlushed = false
 
     @JvmOverloads
@@ -42,7 +44,16 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
         if (mode == JvmStringConcat.INDY_WITH_CONSTANTS) {
             when (stackValue) {
                 is StackValue.Constant -> {
-                    template.append(stackValue.value)
+                    val value = stackValue.value
+                    if (value is String && (value.contains("\u0001") || value.contains("\u0002"))) {
+                        template.append("\u0002") //reference to special symbols added on next line
+                        specialSymbolsInTemplate.add(value)
+                    } else if (value is Char && (value == 1.toChar() || value == 2.toChar())) {
+                        template.append("\u0002") //reference to special symbols added on next line
+                        specialSymbolsInTemplate.add(value.toString())
+                    } else {
+                        template.append(value)
+                    }
                     return
                 }
                 TRUE -> {
@@ -74,8 +85,9 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
         } else {
             justFlushed = false
             paramTypes.add(type)
+            paramSlots += type.size
             template.append("\u0001")
-            if (paramTypes.size == 200) {
+            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"
@@ -104,7 +116,7 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
                     "makeConcatWithConstants",
                     Type.getMethodDescriptor(JAVA_STRING_TYPE, *paramTypes.toTypedArray()),
                     bootstrap,
-                    arrayOf(template.toString())
+                    arrayOf(template.toString()) + specialSymbolsInTemplate
                 )
             } else {
                 val bootstrap = Handle(
@@ -122,10 +134,15 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
                     arrayOf()
                 )
             }
+            //clear old template
             template.clear()
+            specialSymbolsInTemplate.clear()
             paramTypes.clear()
+
+            //add just flushed string
             paramTypes.add(JAVA_STRING_TYPE)
             template.append("\u0001")
+            paramSlots = JAVA_STRING_TYPE.size
         }
     }
 

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

@@ -15,6 +15,7 @@ import kotlin.Pair;
 import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.backend.common.SamTypeApproximator;
 import org.jetbrains.kotlin.builtins.FunctionTypesKt;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.builtins.ReflectionTypes;
@@ -34,6 +35,7 @@ import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
 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.psi.*;
@@ -90,6 +92,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
     private final ClassBuilderMode classBuilderMode;
     private final DelegatedPropertiesCodegenHelper delegatedPropertiesCodegenHelper;
     private final JvmDefaultMode jvmDefaultMode;
+    private final SamTypeApproximator samTypeApproximator;
 
     public CodegenAnnotatingVisitor(@NotNull GenerationState state) {
         this.bindingTrace = state.getBindingTrace();
@@ -100,7 +103,8 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         this.languageVersionSettings = state.getLanguageVersionSettings();
         this.classBuilderMode = state.getClassBuilderMode();
         this.delegatedPropertiesCodegenHelper = new DelegatedPropertiesCodegenHelper(state);
-        jvmDefaultMode = state.getJvmDefaultMode();
+        this.jvmDefaultMode = state.getJvmDefaultMode();
+        this.samTypeApproximator = new SamTypeApproximator(state.getModule().getBuiltIns(), state.getLanguageVersionSettings());
     }
 
     @NotNull
@@ -855,6 +859,20 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         }
     }
 
+    @Nullable
+    private SamType createSamType(KotlinType kotlinType) {
+        if (!JavaSingleAbstractMethodUtils.isSamType(kotlinType)) return null;
+        return new SamType(kotlinType);
+    }
+
+    @Nullable
+    private SamType createSamTypeByValueParameter(ValueParameterDescriptor valueParameterDescriptor) {
+        KotlinType kotlinSamType = samTypeApproximator.getSamTypeForValueParameter(valueParameterDescriptor);
+        if (kotlinSamType == null) return null;
+        if (!JavaSingleAbstractMethodUtils.isSamType(kotlinSamType)) return null;
+        return new SamType(kotlinSamType);
+    }
+
     private void writeSamValueForValueParameters(
             @NotNull Collection<ValueParameterDescriptor> valueParametersWithSAMConversion,
             @Nullable List<ResolvedValueArgument> valueArguments
@@ -862,7 +880,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         if (valueArguments == null) return;
 
         for (ValueParameterDescriptor valueParameter : valueParametersWithSAMConversion) {
-            SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(valueParameter);
+            SamType samType = createSamTypeByValueParameter(valueParameter);
             if (samType == null) continue;
 
             ResolvedValueArgument resolvedValueArgument = valueArguments.get(valueParameter.getIndex());
@@ -874,7 +892,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
     }
 
     private void recordSamTypeOnArgumentExpression(ValueParameterDescriptor valueParameter, ValueArgument valueArgument) {
-        SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(valueParameter);
+        SamType samType = createSamTypeByValueParameter(valueParameter);
         if (samType == null) return;
 
         recordSamTypeOnArgumentExpression(samType, valueArgument);
@@ -955,8 +973,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         KtExpression argumentExpression = argument.getArgumentExpression();
         bindingTrace.record(SAM_CONSTRUCTOR_TO_ARGUMENT, expression, argumentExpression);
 
-        //noinspection ConstantConditions
-        SamType samType = JvmSamTypeFactory.INSTANCE.create(callableDescriptor.getReturnType());
+        SamType samType = createSamType(callableDescriptor.getReturnType());
         bindingTrace.record(SAM_VALUE, argumentExpression, samType);
     }
 
@@ -973,7 +990,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter((FunctionDescriptor) operationDescriptor);
         if (original == null) return;
 
-        SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(original.getValueParameters().get(0));
+        SamType samType = createSamTypeByValueParameter(original.getValueParameters().get(0));
         if (samType == null) return;
 
         IElementType token = expression.getOperationToken();
@@ -1002,7 +1019,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         List<KtExpression> indexExpressions = expression.getIndexExpressions();
         List<ValueParameterDescriptor> parameters = original.getValueParameters();
         for (ValueParameterDescriptor valueParameter : parameters) {
-            SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(valueParameter);
+            SamType samType = createSamTypeByValueParameter(valueParameter);
             if (samType == null) continue;
 
             if (isSetter && valueParameter.getIndex() == parameters.size() - 1) {

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

@@ -393,13 +393,12 @@ fun TypeSystemCommonBackendContext.extractReificationArgument(initialType: Kotli
     while (type.isArrayOrNullableArray()) {
         arrayDepth++
         val argument = type.getArgument(0)
-        type =
-            if (argument.isStarProjection()) nullableAnyType()
-            else argument.getType()
+        if (argument.isStarProjection()) return null
+        type = argument.getType()
     }
 
     val typeParameter = type.typeConstructor().getTypeParameterClassifier() ?: return null
-
+    if (!typeParameter.isReified()) return null
     return Pair(typeParameter, ReificationArgument(typeParameter.getName().asString(), isNullable, arrayDepth))
 }
 

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

@@ -136,8 +136,6 @@ class CoroutineTransformerMethodVisitor(
 
         UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
 
-        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
-
         val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)
 
         val suspendMarkerVarIndex = methodNode.maxLocals++
@@ -194,6 +192,8 @@ class CoroutineTransformerMethodVisitor(
         dropUnboxInlineClassMarkers(methodNode, suspensionPoints)
         methodNode.removeEmptyCatchBlocks()
 
+        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
+
         if (languageVersionSettings.isReleaseCoroutines()) {
             writeDebugMetadata(methodNode, suspensionPointLineNumbers, spilledToVariableMapping)
         }
@@ -791,19 +791,30 @@ class CoroutineTransformerMethodVisitor(
         // Mutate method node
 
         fun generateSpillAndUnspill(suspension: SuspensionPoint, slot: Int, spillableVariable: SpillableVariable?) {
-            if (spillableVariable == null) {
-                with(instructions) {
-                    insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                        aconst(null)
-                        store(slot, AsmTypes.OBJECT_TYPE)
-                    })
+            fun splitLvtRecord(local: LocalVariableNode?, localRestart: LabelNode) {
+                // Split the local variable range for the local so that it is visible until the next state label, but is
+                // not visible until it has been unspilled from the continuation on the reentry path.
+                if (local != null) {
+                    val previousEnd = local.end
+                    local.end = suspension.stateLabel
+                    // Add the local back, but end it at the next state label.
+                    methodNode.localVariables.add(local)
+                    // Add a new entry that starts after the local variable is restored from the continuation.
+                    methodNode.localVariables.add(
+                        LocalVariableNode(
+                            local.name,
+                            local.desc,
+                            local.signature,
+                            localRestart,
+                            previousEnd,
+                            local.index
+                        )
+                    )
                 }
-                return
             }
 
             // Find and remove the local variable node, if any, in the local variable table corresponding to the slot that is spilled.
             var local: LocalVariableNode? = null
-            val localRestart = LabelNode().linkWithLabel()
             val iterator = methodNode.localVariables.listIterator()
             while (iterator.hasNext()) {
                 val node = iterator.next()
@@ -817,6 +828,19 @@ class CoroutineTransformerMethodVisitor(
                 }
             }
 
+            if (spillableVariable == null) {
+                with(instructions) {
+                    insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                        aconst(null)
+                        store(slot, AsmTypes.OBJECT_TYPE)
+                    })
+                }
+                val newStart = suspension.tryCatchBlocksContinuationLabel.findNextOrNull { it is LabelNode } as? LabelNode ?: return
+                splitLvtRecord(local, newStart)
+                return
+            }
+
+            val localRestart = LabelNode().linkWithLabel()
             with(instructions) {
                 // store variable before suspension call
                 insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
@@ -846,25 +870,7 @@ class CoroutineTransformerMethodVisitor(
                 })
             }
 
-            // Split the local variable range for the local so that it is visible until the next state label, but is
-            // not visible until it has been unspilled from the continuation on the reentry path.
-            if (local != null) {
-                val previousEnd = local.end
-                local.end = suspension.stateLabel
-                // Add the local back, but end it at the next state label.
-                methodNode.localVariables.add(local)
-                // Add a new entry that starts after the local variable is restored from the continuation.
-                methodNode.localVariables.add(
-                    LocalVariableNode(
-                        local.name,
-                        local.desc,
-                        local.signature,
-                        localRestart,
-                        previousEnd,
-                        local.index
-                    )
-                )
-            }
+            splitLvtRecord(local, localRestart)
         }
 
         fun cleanUpField(suspension: SuspensionPoint, fieldIndex: Int) {
@@ -1254,6 +1260,9 @@ internal fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, contin
     }
 }
 
+private fun MethodNode.nodeTextWithLiveness(liveness: List<VariableLivenessFrame>): String =
+    liveness.zip(this.instructions.asSequence().toList()).joinToString("\n") { (a, b) -> "$a|${b.insnText}" }
+
 /* We do not want to spill dead variables, thus, we shrink its LVT record to region, where the variable is alive,
  * so, the variable will not be visible in debugger. User can still prolong life span of the variable by using it.
  *
@@ -1288,9 +1297,6 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
     fun min(a: LabelNode, b: LabelNode): LabelNode =
         if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) a else b
 
-    fun max(a: LabelNode, b: LabelNode): LabelNode =
-        if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) b else a
-
     val oldLvt = arrayListOf<LocalVariableNode>()
     for (record in method.localVariables) {
         oldLvt += record
@@ -1298,7 +1304,6 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
     method.localVariables.clear()
     // Skip `this` for suspend lambda
     val start = if (isForNamedFunction) 0 else 1
-    val oldLvtNodeToLatestNewLvtNode = mutableMapOf<LocalVariableNode, LocalVariableNode>()
     for (variableIndex in start until method.maxLocals) {
         if (oldLvt.none { it.index == variableIndex }) continue
         var startLabel: LabelNode? = null
@@ -1310,7 +1315,7 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
             if (isAlive(insnIndex, variableIndex) && !isAlive(insnIndex + 1, variableIndex)) {
                 // No variable in LVT -> do not add one
                 val lvtRecord = oldLvt.findRecord(insnIndex, variableIndex) ?: continue
-                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME) continue
+                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME || lvtRecord.name == SUSPEND_CALL_RESULT_NAME) continue
                 // End the local when it is no longer live. Since it is not live, we will not spill and unspill it across
                 // suspension points. It is tempting to keep it alive until the next suspension point to leave it visible in
                 // the debugger for as long as possible. However, in the case of loops, the resumption after suspension can
@@ -1337,14 +1342,32 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
                 // startLabel can be null in case of parameters
                 @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
                 val node = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
-                if (lvtRecord !in oldLvtNodeToLatestNewLvtNode) {
-                    method.localVariables.add(node)
-                }
-                oldLvtNodeToLatestNewLvtNode[lvtRecord] = node
+                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/RedundantLocalsEliminationMethodTransformer.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.codegen.coroutines
 
 import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
-import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.common.removeAll
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
@@ -85,7 +85,7 @@ private class UnitSourceInterpreter(private val localVariables: Set<Int>) : Basi
     }
 
     fun run(internalClassName: String, methodNode: MethodNode): Array<Frame<BasicValue>?> {
-        val frames = MethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
+        val frames = FastMethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
         // The ASM analyzer does not visit POP instructions, so we do so here.
         for ((insn, frame) in methodNode.instructions.asSequence().zip(frames.asSequence())) {
             if (frame != null && insn.opcode == Opcodes.POP) {

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.codegen.coroutines
 
 import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -130,11 +130,11 @@ internal fun performSpilledVariableFieldTypesAnalysis(
     thisName: String
 ): Array<out Frame<BasicValue>?> {
     val interpreter = IntLikeCoerceInterpreter()
-    MethodAnalyzer(thisName, methodNode, interpreter).analyze()
+    FastMethodAnalyzer(thisName, methodNode, interpreter).analyze()
     for ((insn, type) in interpreter.needsToBeCoerced) {
         methodNode.instructions.insert(insn, withInstructionAdapter { coerceInt(type, this) })
     }
-    return MethodAnalyzer(thisName, methodNode, OptimizationBasicInterpreter()).analyze()
+    return FastMethodAnalyzer(thisName, methodNode, OptimizationBasicInterpreter()).analyze()
 }
 
 private fun coerceInt(to: Type, v: InstructionAdapter) {

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

@@ -159,8 +159,8 @@ internal class MethodNodeExaminer(
      * @return indices of safely reachable returns for each instruction in the method node
      */
     private fun findSafelyReachableReturns(): Array<Set<Int>?> {
-        val insns = methodNode.instructions
-        val reachableReturnsIndices = Array(insns.size()) init@{ index ->
+        val insns = methodNode.instructions.toArray()
+        val reachableReturnsIndices = Array(insns.size) init@{ index ->
             val insn = insns[index]
 
             if (insn.opcode == Opcodes.ARETURN && !insn.isAreturnAfterSafeUnitInstance()) {
@@ -182,7 +182,7 @@ internal class MethodNodeExaminer(
         var changed: Boolean
         do {
             changed = false
-            for (index in 0 until insns.size()) {
+            for (index in insns.indices.reversed()) {
                 if (insns[index].opcode == Opcodes.ARETURN) continue
 
                 @Suppress("RemoveExplicitTypeArguments")

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)
 
-        val frames = CustomFramesMethodAnalyzer(
-                "fake", methodNode, interpreter,
-                this::UninitializedNewValueFrame
-        ).analyze()
+        if (methodNode.instructions.toArray().none { it.opcode == Opcodes.NEW })
+            return
+
+        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,10 +138,7 @@ 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
@@ -174,11 +171,10 @@ 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"
@@ -188,8 +184,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')"
     }
@@ -236,7 +232,8 @@ 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

@@ -9,7 +9,6 @@ import com.intellij.util.ArrayUtil
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.coroutines.DEBUG_METADATA_ANNOTATION_ASM_TYPE
 import org.jetbrains.kotlin.codegen.coroutines.isCoroutineSuperClass
-import org.jetbrains.kotlin.codegen.coroutines.isResumeImplMethodName
 import org.jetbrains.kotlin.codegen.inline.coroutines.CoroutineTransformer
 import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.serialization.JvmCodegenStringTable
@@ -27,6 +26,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.Companion.NO_ORIGIN
 import org.jetbrains.org.objectweb.asm.*
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.*
 import java.util.*
 
@@ -272,7 +272,7 @@ class AnonymousObjectTransformer(
         // Since $$forInline functions are not generated if retransformation is the last one (i.e. call site is not inline)
         // link to the function in OUTERCLASS field becomes invalid. However, since $$forInline function always has no-inline
         // companion without the suffix, use it.
-        visitor.visitOuterClass(info.ownerClassName, info.functionName?.removeSuffix(FOR_INLINE_SUFFIX), info.functionDesc)
+        visitor.visitOuterClass(info.ownerClassName, info.method.name.removeSuffix(FOR_INLINE_SUFFIX), info.method.descriptor)
     }
 
     private fun inlineMethodAndUpdateGlobalResult(
@@ -295,7 +295,6 @@ class AnonymousObjectTransformer(
         capturedBuilder: ParametersBuilder,
         isConstructor: Boolean
     ): InlineResult {
-        val typeParametersToReify = inliningContext.root.inlineMethodReifier.reifyInstructions(sourceNode)
         val parameters =
             if (isConstructor) capturedBuilder.buildParameters() else getMethodParametersWithCaptured(capturedBuilder, sourceNode)
 
@@ -304,7 +303,10 @@ class AnonymousObjectTransformer(
             transformationInfo.capturedLambdasToInline, parentRemapper, isConstructor
         )
 
-        val inliner = MethodInliner(
+        val reifiedTypeParametersUsages = if (inliningContext.shouldReifyTypeParametersInObjects)
+            inliningContext.root.inlineMethodReifier.reifyInstructions(sourceNode)
+        else null
+        val result = MethodInliner(
             sourceNode,
             parameters,
             inliningContext.subInline(transformationInfo.nameGenerator),
@@ -314,26 +316,17 @@ class AnonymousObjectTransformer(
             SourceMapCopier(sourceMapper, sourceMap),
             InlineCallSiteInfo(
                 transformationInfo.oldClassName,
-                sourceNode.name,
-                if (isConstructor) transformationInfo.newConstructorDescriptor else sourceNode.desc,
+                Method(sourceNode.name, if (isConstructor) transformationInfo.newConstructorDescriptor else sourceNode.desc),
                 inliningContext.callSiteInfo.isInlineOrInsideInline,
-                isSuspendFunctionOrLambda(sourceNode),
-                inliningContext.root.sourceCompilerForInline.inlineCallSiteInfo.lineNumber
+                inliningContext.callSiteInfo.file,
+                inliningContext.callSiteInfo.lineNumber
             ), null
-        )
-
-        val result = inliner.doInline(deferringVisitor, LocalVarRemapper(parameters, 0), false, mapOf())
-        result.reifiedTypeParametersUsages.mergeAll(typeParametersToReify)
+        ).doInline(deferringVisitor, LocalVarRemapper(parameters, 0), false, mapOf())
+        reifiedTypeParametersUsages?.let(result.reifiedTypeParametersUsages::mergeAll)
         deferringVisitor.visitMaxs(-1, -1)
         return result
     }
 
-    private fun isSuspendFunctionOrLambda(sourceNode: MethodNode): Boolean =
-        (sourceNode.desc.endsWith(";Lkotlin/coroutines/Continuation;)Ljava/lang/Object;") ||
-                sourceNode.desc.endsWith(";Lkotlin/coroutines/experimental/Continuation;)Ljava/lang/Object;")) &&
-                (CoroutineTransformer.findFakeContinuationConstructorClassName(sourceNode) != null ||
-                        languageVersionSettings.isResumeImplMethodName(sourceNode.name.removeSuffix(FOR_INLINE_SUFFIX)))
-
     private fun generateConstructorAndFields(
         classBuilder: ClassBuilder,
         allCapturedBuilder: ParametersBuilder,
@@ -428,11 +421,13 @@ class AnonymousObjectTransformer(
     }
 
     private fun getMethodParametersWithCaptured(capturedBuilder: ParametersBuilder, sourceNode: MethodNode): Parameters {
-        val builder = ParametersBuilder.initializeBuilderFrom(
-            oldObjectType,
-            sourceNode.desc,
-            isStatic = sourceNode.access and Opcodes.ACC_STATIC != 0
-        )
+        val builder = ParametersBuilder.newBuilder()
+        if (sourceNode.access and Opcodes.ACC_STATIC == 0) {
+            builder.addThis(oldObjectType, skipped = false)
+        }
+        for (type in Type.getArgumentTypes(sourceNode.desc)) {
+            builder.addNextParameter(type, false)
+        }
         for (param in capturedBuilder.listCaptured()) {
             builder.addCapturedParamCopy(param)
         }

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

@@ -23,7 +23,7 @@ import org.jetbrains.org.objectweb.asm.commons.Method
 data class MethodId(val ownerInternalName: String, val method: Method)
 
 class InlineCache {
-    val classBytes: SLRUMap<ClassId, ByteArray> = SLRUMap(30, 20)
+    val classBytes: SLRUMap<String, ByteArray> = SLRUMap(30, 20)
     val methodNodeById: SLRUMap<MethodId, SMAPAndMethodNode> = SLRUMap(60, 50)
 }
 

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

@@ -1,15 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.inline
-
-class InlineCallSiteInfo(
-    val ownerClassName: String,
-    val functionName: String?,
-    val functionDesc: String?,
-    val isInlineOrInsideInline: Boolean,
-    val isSuspend: Boolean,
-    val lineNumber: Int
-)

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

@@ -6,213 +6,94 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive
-import org.jetbrains.kotlin.codegen.context.ClosureContext
-import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
-import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicArrayConstructors
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.incremental.components.Position
-import org.jetbrains.kotlin.incremental.components.ScopeKind
-import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.jetbrains.kotlin.descriptors.ParameterDescriptor
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.ImportedFromObjectCallableDescriptor
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
-import org.jetbrains.kotlin.resolve.inline.isInlineOnly
 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.TypeSystemCommonBackendContext
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral
-import org.jetbrains.kotlin.types.expressions.LabelResolver
-import org.jetbrains.kotlin.types.model.TypeParameterMarker
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
-import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.*
 import kotlin.math.max
 
 abstract class InlineCodegen<out T : BaseExpressionCodegen>(
     protected val codegen: T,
     protected val state: GenerationState,
-    protected val functionDescriptor: FunctionDescriptor,
-    protected val methodOwner: Type,
     protected val jvmSignature: JvmMethodSignature,
     private val typeParameterMappings: TypeParameterMappings<*>,
     protected val sourceCompiler: SourceCompilerForInline,
     private val reifiedTypeInliner: ReifiedTypeInliner<*>
 ) {
-    init {
-        assert(InlineUtil.isInline(functionDescriptor)) {
-            "InlineCodegen can inline only inline functions: $functionDescriptor"
-        }
-    }
-
-    // TODO: implement AS_FUNCTION inline strategy
-    private val asFunctionInline = false
-
     private val initialFrameSize = codegen.frameMap.currentSize
 
-    private val isSameModule: Boolean
-
     protected val invocationParamBuilder = ParametersBuilder.newBuilder()
-
     protected val expressionMap = linkedMapOf<Int, FunctionalArgument>()
-
-    var activeLambda: LambdaInfo? = null
-        protected set
-
-    private val sourceMapper = sourceCompiler.lazySourceMapper
-
-    protected var delayedHiddenWriting: Function0<Unit>? = null
-
-    protected val maskValues = ArrayList<Int>()
-    protected var maskStartIndex = -1
-    protected var methodHandleInDefaultMethodIndex = -1
-
-    init {
-        isSameModule = sourceCompiler.isCallInsideSameModuleAsDeclared(functionDescriptor)
-
-        if (functionDescriptor !is FictitiousArrayConstructor) {
-            //track changes for property accessor and @JvmName inline functions/property accessors
-            if (jvmSignature.asmMethod.name != functionDescriptor.name.asString()) {
-                trackLookup(functionDescriptor)
-            }
-        }
-    }
-
-
-    protected fun throwCompilationException(
-        nodeAndSmap: SMAPAndMethodNode?, e: Exception, generateNodeText: Boolean
-    ): CompilationException {
-        val contextDescriptor = sourceCompiler.compilationContextDescriptor
-        val element = DescriptorToSourceUtils.descriptorToDeclaration(contextDescriptor)
-        val node = nodeAndSmap?.node
-        throw CompilationException(
-            "Couldn't inline method call '" + functionDescriptor.name + "' into\n" +
-                    DescriptorRenderer.DEBUG_TEXT.render(contextDescriptor) + "\n" +
-                    (element?.text ?: "<no source>") +
-                    if (generateNodeText) "\nCause: " + node.nodeText else "",
-            e, sourceCompiler.callElement as? PsiElement
-        )
-    }
+    private val maskValues = ArrayList<Int>()
+    private var maskStartIndex = -1
+    private var methodHandleInDefaultMethodIndex = -1
 
     protected fun generateStub(text: String, codegen: BaseExpressionCodegen) {
         leaveTemps()
-        AsmUtil.genThrow(codegen.v, "java/lang/UnsupportedOperationException", "Call is part of inline cycle: $text")
+        AsmUtil.genThrow(codegen.visitor, "java/lang/UnsupportedOperationException", "Call is part of inline cycle: $text")
     }
 
-    protected fun endCall(result: InlineResult, registerLineNumberAfterwards: Boolean) {
-        leaveTemps()
-
-        codegen.propagateChildReifiedTypeParametersUsages(result.reifiedTypeParametersUsages)
-
-        state.factory.removeClasses(result.calcClassesToRemove())
-
-        codegen.markLineNumberAfterInlineIfNeeded(registerLineNumberAfterwards)
-    }
-
-    fun performInline(
-        typeArguments: List<TypeParameterMarker>?,
-        inlineDefaultLambdas: Boolean,
-        mapDefaultSignature: Boolean,
-        typeSystem: TypeSystemCommonBackendContext,
-        registerLineNumberAfterwards: Boolean,
-    ) {
+    fun performInline(registerLineNumberAfterwards: Boolean, isInlineOnly: Boolean) {
         var nodeAndSmap: SMAPAndMethodNode? = null
         try {
-            nodeAndSmap = createInlineMethodNode(mapDefaultSignature, typeArguments, typeSystem)
-            endCall(inlineCall(nodeAndSmap, inlineDefaultLambdas), registerLineNumberAfterwards)
+            nodeAndSmap = sourceCompiler.compileInlineFunction(jvmSignature).apply {
+                node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
+            }
+            val result = inlineCall(nodeAndSmap, isInlineOnly)
+            leaveTemps()
+            codegen.propagateChildReifiedTypeParametersUsages(result.reifiedTypeParametersUsages)
+            codegen.markLineNumberAfterInlineIfNeeded(registerLineNumberAfterwards)
+            state.factory.removeClasses(result.calcClassesToRemove())
         } catch (e: CompilationException) {
             throw e
         } catch (e: InlineException) {
-            throw throwCompilationException(nodeAndSmap, e, false)
+            throw CompilationException(
+                "Couldn't inline method call: ${sourceCompiler.callElementText}",
+                e, sourceCompiler.callElement as? PsiElement
+            )
         } catch (e: Exception) {
-            throw throwCompilationException(nodeAndSmap, e, true)
+            throw CompilationException(
+                "Couldn't inline method call: ${sourceCompiler.callElementText}\nMethod: ${nodeAndSmap?.node?.nodeText}",
+                e, sourceCompiler.callElement as? PsiElement
+            )
         }
     }
 
-    private fun canSkipStackSpillingOnInline(methodNode: MethodNode): Boolean {
-        // Stack spilling before inline function 'f' call is required if:
-        //  - 'f' is a suspend function
-        //  - 'f' has try-catch blocks
-        //  - 'f' has loops
-        //
-        // Instead of checking for loops precisely, we just check if there are any backward jumps -
-        // that is, a jump from instruction #i to instruction #j where j < i
-
-        if (functionDescriptor.isSuspend) return false
-        if (methodNode.tryCatchBlocks.isNotEmpty()) return false
-
-        fun isBackwardJump(fromIndex: Int, toLabel: LabelNode) =
-            methodNode.instructions.indexOf(toLabel) < fromIndex
-
-        val insns = methodNode.instructions.toArray()
-        for (i in insns.indices) {
-            val insn = insns[i]
-            when (insn) {
-                is JumpInsnNode ->
-                    if (isBackwardJump(i, insn.label)) return false
-
-                is LookupSwitchInsnNode -> {
-                    insn.dflt?.let {
-                        if (isBackwardJump(i, it)) return false
-                    }
-                    if (insn.labels.any { isBackwardJump(i, it) }) return false
-                }
-
-                is TableSwitchInsnNode -> {
-                    insn.dflt?.let {
-                        if (isBackwardJump(i, it)) return false
-                    }
-                    if (insn.labels.any { isBackwardJump(i, it) }) return false
-                }
-            }
-        }
-
-        return true
-    }
-
-    private fun continuationValue(): StackValue {
-        assert(codegen is ExpressionCodegen) { "Expected ExpressionCodegen in coroutineContext inlining" }
-        codegen as ExpressionCodegen
-
-        val parentContext = codegen.context.parentContext
-        return if (parentContext is ClosureContext) {
-            val originalSuspendLambdaDescriptor =
-                parentContext.originalSuspendLambdaDescriptor ?: error("No original lambda descriptor found")
-            codegen.genCoroutineInstanceForSuspendLambda(originalSuspendLambdaDescriptor)
-                ?: error("No stack value for coroutine instance of lambda found")
-        } else
-            codegen.getContinuationParameterFromEnclosingSuspendFunctionDescriptor(codegen.context.functionDescriptor)
-                ?: error("No stack value for continuation parameter of suspend function")
-    }
-
-    private fun inlineCall(nodeAndSmap: SMAPAndMethodNode, inlineDefaultLambda: Boolean): InlineResult {
-        assert(delayedHiddenWriting == null) { "'putHiddenParamsIntoLocals' should be called after 'processAndPutHiddenParameters(true)'" }
+    private fun inlineCall(nodeAndSmap: SMAPAndMethodNode, isInlineOnly: Boolean): InlineResult {
         val node = nodeAndSmap.node
-        if (inlineDefaultLambda) {
-            for (lambda in extractDefaultLambdas(node)) {
-                invocationParamBuilder.buildParameters().getParameterByDeclarationSlot(lambda.offset).functionalArgument = lambda
-                val prev = expressionMap.put(lambda.offset, lambda)
-                assert(prev == null) { "Lambda with offset ${lambda.offset} already exists: $prev" }
+        if (maskStartIndex != -1) {
+            val parameters = invocationParamBuilder.buildParameters()
+            val infos = expandMaskConditionsAndUpdateVariableNodes(
+                node, maskStartIndex, maskValues, methodHandleInDefaultMethodIndex,
+                parameters.parameters.filter { it.functionalArgument === DefaultValueOfInlineParameter }
+                    .mapTo(mutableSetOf()) { parameters.getDeclarationSlot(it) }
+            )
+            for (info in infos) {
+                val lambda = DefaultLambda(info, sourceCompiler)
+                parameters.getParameterByDeclarationSlot(info.offset).functionalArgument = lambda
+                val prev = expressionMap.put(info.offset, lambda)
+                assert(prev == null) { "Lambda with offset ${info.offset} already exists: $prev" }
+                if (info.needReification) {
+                    lambda.reifiedTypeParametersUsages.mergeAll(reifiedTypeInliner.reifyInstructions(lambda.node.node))
+                }
+                for (captured in lambda.capturedVars) {
+                    val param = invocationParamBuilder.addCapturedParam(captured, captured.fieldName, false)
+                    param.remapValue = StackValue.local(codegen.frameMap.enterTemp(param.type), param.type)
+                    param.isSynthetic = true
+                }
             }
         }
-        val reificationResult = reifiedTypeInliner.reifyInstructions(node)
-        generateClosuresBodies()
 
-        //through generation captured parameters will be added to invocationParamBuilder
-        putClosureParametersOnStack()
+        val reificationResult = reifiedTypeInliner.reifyInstructions(node)
 
         val parameters = invocationParamBuilder.buildParameters()
 
@@ -221,13 +102,14 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
             sourceCompiler, sourceCompiler.inlineCallSiteInfo, reifiedTypeInliner, typeParameterMappings
         )
 
+        val sourceMapper = sourceCompiler.sourceMapper
         val sourceInfo = sourceMapper.sourceInfo!!
         val callSite = SourcePosition(codegen.lastLineNumber, sourceInfo.sourceFileName!!, sourceInfo.pathOrCleanFQN)
         val inliner = MethodInliner(
-            node, parameters, info, FieldRemapper(null, null, parameters), isSameModule,
+            node, parameters, info, FieldRemapper(null, null, parameters), sourceCompiler.isCallInsideSameModuleAsCallee,
             "Method inlining " + sourceCompiler.callElementText,
             SourceMapCopier(sourceMapper, nodeAndSmap.classSMAP, callSite),
-            info.callSiteInfo, if (functionDescriptor.isInlineOnly()) InlineOnlySmapSkipper(codegen) else null,
+            info.callSiteInfo, if (isInlineOnly) InlineOnlySmapSkipper(codegen) else null,
             !isInlinedToInlineFunInKotlinRuntime()
         ) //with captured
 
@@ -242,43 +124,37 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
 
         val infos = MethodInliner.processReturns(adapter, sourceCompiler.getContextLabels(), null)
         generateAndInsertFinallyBlocks(
-            adapter, infos, (remapper.remap(parameters.argsSizeOnStack + 1).value as StackValue.Local).index
+            adapter, infos, (remapper.remap(parameters.argsSizeOnStack).value as StackValue.Local).index
         )
-        if (!sourceCompiler.isFinallyMarkerRequired()) {
+        if (!sourceCompiler.isFinallyMarkerRequired) {
             removeFinallyMarkers(adapter)
         }
 
-        // In case `codegen.v` is `<clinit>`, initializer for the `$assertionsDisabled` field
+        // In case `codegen.visitor` is `<clinit>`, initializer for the `$assertionsDisabled` field
         // needs to be inserted before the code that actually uses it.
-        generateAssertFieldIfNeeded(info)
-
-        val shouldSpillStack = !canSkipStackSpillingOnInline(node)
-        if (shouldSpillStack) {
-            addInlineMarker(codegen.v, true)
+        if (info.generateAssertField) {
+            generateAssertField()
         }
-        adapter.accept(MethodBodyVisitor(codegen.v))
+
+        val shouldSpillStack = node.requiresEmptyStackOnEntry()
         if (shouldSpillStack) {
-            addInlineMarker(codegen.v, false)
+            addInlineMarker(codegen.visitor, true)
+        }
+        adapter.accept(MethodBodyVisitor(codegen.visitor))
+        if (shouldSpillStack) {
+            addInlineMarker(codegen.visitor, false)
         }
         return result
     }
 
-    abstract fun extractDefaultLambdas(node: MethodNode): List<DefaultLambda>
-
-    abstract fun descriptorIsDeserialized(memberDescriptor: CallableMemberDescriptor): Boolean
-
-    fun generateAndInsertFinallyBlocks(
+    private fun generateAndInsertFinallyBlocks(
         intoNode: MethodNode,
         insertPoints: List<MethodInliner.PointForExternalFinallyBlocks>,
         offsetForFinallyLocalVar: Int
     ) {
         if (!sourceCompiler.hasFinallyBlocks()) return
 
-        val extensionPoints = HashMap<AbstractInsnNode, MethodInliner.PointForExternalFinallyBlocks>()
-        for (insertPoint in insertPoints) {
-            extensionPoints.put(insertPoint.beforeIns, insertPoint)
-        }
-
+        val extensionPoints = insertPoints.associateBy { it.beforeIns }
         val processor = DefaultProcessor(intoNode, offsetForFinallyLocalVar)
 
         var curFinallyDepth = 0
@@ -292,47 +168,35 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
 
             val extension = extensionPoints[curInstr]
             if (extension != null) {
-                val start = Label()
+                var nextFreeLocalIndex = processor.nextFreeLocalIndex
+                for (local in processor.localVarsMetaInfo.currentIntervals) {
+                    val size = Type.getType(local.node.desc).size
+                    nextFreeLocalIndex = max(offsetForFinallyLocalVar + local.node.index + size, nextFreeLocalIndex)
+                }
 
+                val start = Label()
                 val finallyNode = createEmptyMethodNode()
                 finallyNode.visitLabel(start)
-
-                val finallyCodegen =
-                    sourceCompiler.createCodegenForExternalFinallyBlockGenerationOnNonLocalReturn(finallyNode, curFinallyDepth)
-
-                val frameMap = finallyCodegen.frameMap
-                val mark = frameMap.mark()
-                var marker = -1
-                val intervals = processor.localVarsMetaInfo.currentIntervals
-                for (interval in intervals) {
-                    marker = max(interval.node.index + 1, marker)
-                }
-                while (frameMap.currentSize < max(processor.nextFreeLocalIndex, offsetForFinallyLocalVar + marker)) {
-                    frameMap.enterTemp(Type.INT_TYPE)
-                }
-
-                sourceCompiler.generateFinallyBlocksIfNeeded(
-                    finallyCodegen, extension.returnType, extension.finallyIntervalEnd.label, extension.jumpTarget
+                val mark = codegen.frameMap.skipTo(nextFreeLocalIndex)
+                sourceCompiler.generateFinallyBlocks(
+                    finallyNode, curFinallyDepth, extension.returnType, extension.finallyIntervalEnd.label, extension.jumpTarget
                 )
-
-                //Exception table for external try/catch/finally blocks will be generated in original codegen after exiting this method
+                mark.dropTo()
                 insertNodeBefore(finallyNode, intoNode, curInstr)
 
                 val splitBy = SimpleInterval(start.info as LabelNode, extension.finallyIntervalEnd)
                 processor.tryBlocksMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true)
-                processor.localVarsMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true);
-
-                mark.dropTo()
+                processor.localVarsMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true)
             }
 
             curInstr = curInstr.next
         }
 
         processor.substituteTryBlockNodes(intoNode)
-        processor.substituteLocalVarTable(intoNode);
+        processor.substituteLocalVarTable(intoNode)
     }
 
-    protected abstract fun generateAssertFieldIfNeeded(info: RootInliningContext)
+    protected abstract fun generateAssertField()
 
     private fun isInlinedToInlineFunInKotlinRuntime(): Boolean {
         val codegen = this.codegen as? ExpressionCodegen ?: return false
@@ -345,90 +209,52 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         }
     }
 
-    private fun generateClosuresBodies() {
-        for (info in expressionMap.values) {
-            if (info is LambdaInfo) {
-                info.generateLambdaBody(sourceCompiler, reifiedTypeInliner)
-            }
+    protected fun rememberClosure(parameterType: Type, index: Int, lambdaInfo: LambdaInfo) {
+        val closureInfo = invocationParamBuilder.addNextValueParameter(parameterType, true, null, index)
+        closureInfo.functionalArgument = lambdaInfo
+        expressionMap[closureInfo.index] = lambdaInfo
+    }
+
+    protected fun putCapturedToLocalVal(stackValue: StackValue, capturedParam: CapturedParamDesc, kotlinType: KotlinType?) {
+        val info = invocationParamBuilder.addCapturedParam(capturedParam, capturedParam.fieldName, false)
+        if (stackValue.isLocalWithNoBoxing(JvmKotlinType(info.type, kotlinType))) {
+            info.remapValue = stackValue
+        } else {
+            stackValue.put(info.type, kotlinType, codegen.visitor)
+            val local = StackValue.local(codegen.frameMap.enterTemp(info.type), info.type)
+            local.store(StackValue.onStack(info.type), codegen.visitor)
+            info.remapValue = local
+            info.isSynthetic = true
         }
     }
 
-    protected fun putArgumentOrCapturedToLocalVal(
-        jvmKotlinType: JvmKotlinType,
-        stackValue: StackValue,
-        capturedParamIndex: Int,
-        parameterIndex: Int,
-        kind: ValueKind
-    ) {
-        val isDefaultParameter = kind === ValueKind.DEFAULT_PARAMETER
-        val jvmType = jvmKotlinType.type
-        val kotlinType = jvmKotlinType.kotlinType
-        if (!isDefaultParameter && shouldPutGeneralValue(jvmType, kotlinType, stackValue)) {
-            stackValue.put(jvmType, kotlinType, codegen.v)
+    protected fun putArgumentToLocalVal(jvmKotlinType: JvmKotlinType, stackValue: StackValue, parameterIndex: Int, kind: ValueKind) {
+        if (kind === ValueKind.DEFAULT_MASK || kind === ValueKind.METHOD_HANDLE_IN_DEFAULT) {
+            return processDefaultMaskOrMethodHandler(stackValue, kind)
         }
 
-        if (!asFunctionInline && Type.VOID_TYPE !== jvmType) {
-            //TODO remap only inlinable closure => otherwise we could get a lot of problem
-            val couldBeRemapped = !shouldPutGeneralValue(jvmType, kotlinType, stackValue) && kind !== ValueKind.DEFAULT_PARAMETER
-            val remappedValue = if (couldBeRemapped) stackValue else null
-
-            val info: ParameterInfo
-            if (capturedParamIndex >= 0) {
-                val capturedParamInfoInLambda = activeLambda!!.capturedVars[capturedParamIndex]
-                info = invocationParamBuilder.addCapturedParam(capturedParamInfoInLambda, capturedParamInfoInLambda.fieldName, false)
-                info.remapValue = remappedValue
-            } else {
-                info = invocationParamBuilder.addNextValueParameter(jvmType, false, remappedValue, parameterIndex)
-                info.functionalArgument = when (kind) {
-                    ValueKind.NON_INLINEABLE_ARGUMENT_FOR_INLINE_PARAMETER_CALLED_IN_SUSPEND ->
-                        NonInlineableArgumentForInlineableParameterCalledInSuspend
-                    ValueKind.NON_INLINEABLE_ARGUMENT_FOR_INLINE_SUSPEND_PARAMETER -> NonInlineableArgumentForInlineableSuspendParameter
-                    else -> null
-                }
-            }
-
-            recordParameterValueInLocalVal(
-                false,
-                isDefaultParameter || kind === ValueKind.DEFAULT_LAMBDA_CAPTURED_PARAMETER,
-                info
-            )
+        val info = invocationParamBuilder.addNextValueParameter(jvmKotlinType.type, false, null, parameterIndex)
+        info.functionalArgument = when (kind) {
+            ValueKind.NON_INLINEABLE_ARGUMENT_FOR_INLINE_PARAMETER_CALLED_IN_SUSPEND ->
+                NonInlineableArgumentForInlineableParameterCalledInSuspend
+            ValueKind.NON_INLINEABLE_ARGUMENT_FOR_INLINE_SUSPEND_PARAMETER ->
+                NonInlineableArgumentForInlineableSuspendParameter
+            ValueKind.DEFAULT_INLINE_PARAMETER ->
+                DefaultValueOfInlineParameter
+            else -> null
         }
-    }
-
-    protected fun recordParameterValueInLocalVal(
-        delayedWritingToLocals: Boolean,
-        skipStore: Boolean,
-        vararg infos: ParameterInfo
-    ): Function0<Unit>? {
-        val index = IntArray(infos.size) { i ->
-            if (!infos[i].isSkippedOrRemapped) {
-                codegen.frameMap.enterTemp(infos[i].type)
-            } else -1
-        }
-
-        val possibleLazyTask = {
-            for (i in infos.indices.reversed()) {
-                val info = infos[i]
-                if (!info.isSkippedOrRemapped) {
-                    val type = info.type
-                    val local = StackValue.local(index[i], type)
-                    if (!skipStore) {
-                        local.store(StackValue.onStack(info.typeOnStack), codegen.v)
-                    }
-                    if (info is CapturedParamInfo) {
-                        info.remapValue = local
-                        info.isSynthetic = true
-                    }
-                }
+        when {
+            kind === ValueKind.DEFAULT_PARAMETER || kind === ValueKind.DEFAULT_INLINE_PARAMETER ->
+                codegen.frameMap.enterTemp(info.type) // the inline function will put the value into this slot
+            stackValue.isLocalWithNoBoxing(jvmKotlinType) ->
+                info.remapValue = stackValue
+            else -> {
+                stackValue.put(info.type, jvmKotlinType.kotlinType, codegen.visitor)
+                codegen.visitor.store(codegen.frameMap.enterTemp(info.type), info.type)
             }
         }
-
-        if (delayedWritingToLocals) return possibleLazyTask
-        possibleLazyTask()
-        return null
     }
 
-
     private fun leaveTemps() {
         invocationParamBuilder.listAllParams().asReversed().forEach { param ->
             if (!param.isSkippedOrRemapped || CapturedParamInfo.isSynthetic(param)) {
@@ -437,45 +263,11 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         }
     }
 
-    private fun putClosureParametersOnStack() {
-        for (next in expressionMap.values) {
-            //closure parameters for bounded callable references are generated inplace
-            if (next is LambdaInfo) {
-                if (next is ExpressionLambda && next.isBoundCallableReference) continue
-                putClosureParametersOnStack(next, null)
-            }
-        }
-    }
-
-    abstract protected fun putClosureParametersOnStack(next: LambdaInfo, functionReferenceReceiver: StackValue?)
-
-    protected fun rememberCapturedForDefaultLambda(defaultLambda: DefaultLambda) {
-        for ((paramIndex, captured) in defaultLambda.capturedVars.withIndex()) {
-            putArgumentOrCapturedToLocalVal(
-                JvmKotlinType(captured.type),
-                //HACK: actually parameter would be placed on stack in default function
-                // also see ValueKind.DEFAULT_LAMBDA_CAPTURED_PARAMETER check
-                StackValue.onStack(captured.type),
-                paramIndex,
-                paramIndex,
-                ValueKind.DEFAULT_LAMBDA_CAPTURED_PARAMETER
-            )
-
-            defaultLambda.parameterOffsetsInDefault.add(invocationParamBuilder.nextParameterOffset)
-        }
-    }
-
-
-    protected fun processDefaultMaskOrMethodHandler(value: StackValue, kind: ValueKind): Boolean {
-        if (kind !== ValueKind.DEFAULT_MASK && kind !== ValueKind.METHOD_HANDLE_IN_DEFAULT) {
-            return false
-        }
-        assert(value is StackValue.Constant) {
-            "Additional default method argument should be constant, but " + value
-        }
+    private fun processDefaultMaskOrMethodHandler(value: StackValue, kind: ValueKind) {
+        assert(value is StackValue.Constant) { "Additional default method argument should be constant, but $value" }
         val constantValue = (value as StackValue.Constant).value
         if (kind === ValueKind.DEFAULT_MASK) {
-            assert(constantValue is Int) { "Mask should be of Integer type, but " + constantValue }
+            assert(constantValue is Int) { "Mask should be of Integer type, but $constantValue" }
             maskValues.add(constantValue as Int)
             if (maskStartIndex == -1) {
                 maskStartIndex = invocationParamBuilder.listAllParams().sumOf {
@@ -486,228 +278,40 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
             assert(constantValue == null) { "Additional method handle for default argument should be null, but " + constantValue!! }
             methodHandleInDefaultMethodIndex = maskStartIndex + maskValues.size
         }
-        return true
     }
 
-    private fun trackLookup(functionOrAccessor: FunctionDescriptor) {
-        val functionOrAccessorName = jvmSignature.asmMethod.name
-        val lookupTracker = state.configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: return
-        val location = sourceCompiler.lookupLocation.location ?: return
-        val position = if (lookupTracker.requiresPosition) location.position else Position.NO_POSITION
-        val classOrPackageFragment = functionOrAccessor.containingDeclaration
-        lookupTracker.record(
-            location.filePath,
-            position,
-            DescriptorUtils.getFqName(classOrPackageFragment).asString(),
-            ScopeKind.CLASSIFIER,
-            functionOrAccessorName
-        )
-    }
-
-
-    internal fun createInlineMethodNode(
-        callDefault: Boolean,
-        typeArguments: List<TypeParameterMarker>?,
-        typeSystem: TypeSystemCommonBackendContext
-    ): SMAPAndMethodNode {
-        val intrinsic = generateInlineIntrinsic(state, functionDescriptor, typeArguments, typeSystem)
-        if (intrinsic != null) {
-            return SMAPAndMethodNode(intrinsic, createDefaultFakeSMAP())
-        }
-
-        var asmMethod = mapMethod(callDefault)
-        if (asmMethod.name.contains("-") &&
-            !state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) &&
-            classFileContainsMethod(functionDescriptor, state, asmMethod) == false
-        ) {
-            state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = true
-            asmMethod = mapMethod(callDefault)
-            state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = false
-        }
-
-        val directMember = getDirectMemberAndCallableFromObject(functionDescriptor)
-        if (!isBuiltInArrayIntrinsic(functionDescriptor) && !descriptorIsDeserialized(directMember)) {
-            val node = sourceCompiler.doCreateMethodNodeFromSource(functionDescriptor, jvmSignature, callDefault, asmMethod)
-            node.node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
-            return node
-        }
-
-        return getCompiledMethodNodeInner(functionDescriptor, directMember, asmMethod, methodOwner, state, jvmSignature)
-    }
-
-    private fun mapMethod(callDefault: Boolean): Method =
-        if (callDefault) state.typeMapper.mapDefaultMethod(functionDescriptor, sourceCompiler.contextKind)
-        else mangleSuspendInlineFunctionAsmMethodIfNeeded(functionDescriptor, jvmSignature.asmMethod)
-
     companion object {
+        private fun StackValue.isLocalWithNoBoxing(expected: JvmKotlinType): Boolean =
+            isPrimitive(expected.type) == isPrimitive(type) &&
+                    !StackValue.requiresInlineClassBoxingOrUnboxing(type, kotlinType, expected.type, expected.kotlinType) &&
+                    (this is StackValue.Local || isCapturedInlineParameter())
 
-        internal fun createSpecialInlineMethodNodeFromBinaries(functionDescriptor: FunctionDescriptor, state: GenerationState): MethodNode {
-            val directMember = getDirectMemberAndCallableFromObject(functionDescriptor)
-            assert(directMember is DescriptorWithContainerSource) {
-                "Function is not in binaries: $functionDescriptor"
-            }
-            assert(directMember is FunctionDescriptor && directMember.isOperator) {
-                "Operator function expected: $directMember"
-            }
-
-            val methodOwner = state.typeMapper.mapImplementationOwner(functionDescriptor)
-            val jvmSignature = state.typeMapper.mapSignatureWithGeneric(functionDescriptor, OwnerKind.IMPLEMENTATION)
-
-            val asmMethod = mangleSuspendInlineFunctionAsmMethodIfNeeded(functionDescriptor, jvmSignature.asmMethod)
-
-            return getCompiledMethodNodeInner(functionDescriptor, directMember, asmMethod, methodOwner, state, jvmSignature).node
+        private fun StackValue.isCapturedInlineParameter(): Boolean {
+            val field = if (this is StackValue.FieldForSharedVar) receiver else this
+            return field is StackValue.Field && field.descriptor is ParameterDescriptor &&
+                    InlineUtil.isInlineParameter(field.descriptor) &&
+                    InlineUtil.isInline(field.descriptor.containingDeclaration)
         }
 
-        private fun getCompiledMethodNodeInner(
-            functionDescriptor: FunctionDescriptor,
-            directMember: CallableMemberDescriptor,
-            asmMethod: Method,
-            methodOwner: Type,
-            state: GenerationState,
-            jvmSignature: JvmMethodSignature
-        ): SMAPAndMethodNode {
-            val methodId = MethodId(methodOwner.internalName, asmMethod)
+        // Stack spilling before inline function call is required if the inlined bytecode has:
+        //   1. try-catch blocks - otherwise the stack spilling before and after them will not be correct;
+        //   2. suspension points - again, the stack spilling around them is otherwise wrong;
+        //   3. loops - OpenJDK cannot JIT-optimize between loop iterations if the stack is not empty.
+        // Instead of checking for loops precisely, we just check if there are any backward jumps -
+        // that is, a jump from instruction #i to instruction #j where j < i.
+        private fun MethodNode.requiresEmptyStackOnEntry(): Boolean = tryCatchBlocks.isNotEmpty() ||
+                instructions.toArray().any { isBeforeSuspendMarker(it) || isBeforeInlineSuspendMarker(it) || isBackwardsJump(it) }
 
-            val resultInCache = state.inlineCache.methodNodeById.getOrPut(methodId) {
-                val result = doCreateMethodNodeFromCompiled(directMember, state, asmMethod)
-                    ?: if (functionDescriptor.isSuspend)
-                        doCreateMethodNodeFromCompiled(directMember, state, jvmSignature.asmMethod)
-                    else
-                        null
-                result ?:
-                throw IllegalStateException("Couldn't obtain compiled function body for $functionDescriptor")
-            }
-
-            return SMAPAndMethodNode(cloneMethodNode(resultInCache.node), resultInCache.classSMAP)
+        private fun MethodNode.isBackwardsJump(insn: AbstractInsnNode): Boolean = when (insn) {
+            is JumpInsnNode -> isBackwardsJump(insn, insn.label)
+            is LookupSwitchInsnNode ->
+                insn.dflt?.let { to -> isBackwardsJump(insn, to) } == true || insn.labels.any { to -> isBackwardsJump(insn, to) }
+            is TableSwitchInsnNode ->
+                insn.dflt?.let { to -> isBackwardsJump(insn, to) } == true || insn.labels.any { to -> isBackwardsJump(insn, to) }
+            else -> false
         }
 
-        private fun createDefaultFakeSMAP() = SMAPParser.parseOrCreateDefault(null, null, "fake", -1, -1)
-
-        // For suspend inline functions we generate two methods:
-        // 1) normal one: with state machine to call directly
-        // 2) for inliner: with mangled name and without state machine
-        private fun mangleSuspendInlineFunctionAsmMethodIfNeeded(functionDescriptor: FunctionDescriptor, asmMethod: Method): Method {
-            if (!functionDescriptor.isSuspend) return asmMethod
-            return Method("${asmMethod.name}$FOR_INLINE_SUFFIX", asmMethod.descriptor)
-        }
-
-        private fun getDirectMemberAndCallableFromObject(functionDescriptor: FunctionDescriptor): CallableMemberDescriptor {
-            val directMember = JvmCodegenUtil.getDirectMember(functionDescriptor)
-            return (directMember as? ImportedFromObjectCallableDescriptor<*>)?.callableFromObject ?: directMember
-        }
-
-        private fun doCreateMethodNodeFromCompiled(
-            callableDescriptor: CallableMemberDescriptor,
-            state: GenerationState,
-            asmMethod: Method
-        ): SMAPAndMethodNode? {
-            if (isBuiltInArrayIntrinsic(callableDescriptor)) {
-                val body = when {
-                    callableDescriptor is FictitiousArrayConstructor -> IntrinsicArrayConstructors.generateArrayConstructorBody(asmMethod)
-                    callableDescriptor.name.asString() == "emptyArray" -> IntrinsicArrayConstructors.generateEmptyArrayBody(asmMethod)
-                    callableDescriptor.name.asString() == "arrayOf" -> IntrinsicArrayConstructors.generateArrayOfBody(asmMethod)
-                    else -> throw UnsupportedOperationException("Not an array intrinsic: $callableDescriptor")
-                }
-                return SMAPAndMethodNode(body, SMAP(listOf()))
-            }
-
-            assert(callableDescriptor is DescriptorWithContainerSource) { "Not a deserialized function or proper: $callableDescriptor" }
-
-            val containingClasses =
-                KotlinTypeMapper.getContainingClassesForDeserializedCallable(callableDescriptor as DescriptorWithContainerSource)
-
-            val containerId = containingClasses.implClassId
-
-            val bytes = state.inlineCache.classBytes.getOrPut(containerId) {
-                findVirtualFile(state, containerId)?.contentsToByteArray()
-                    ?: throw IllegalStateException("Couldn't find declaration file for $containerId")
-            }
-
-            val classType = AsmUtil.asmTypeByClassId(containerId)
-            val methodNode = getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, classType)
-            if (methodNode == null && requiresFunctionNameManglingForReturnType(callableDescriptor)) {
-                val nameWithoutManglingSuffix = asmMethod.name.stripManglingSuffixOrNull()
-                if (nameWithoutManglingSuffix != null) {
-                    val methodWithoutMangling = getMethodNode(bytes, nameWithoutManglingSuffix, asmMethod.descriptor, classType)
-                    if (methodWithoutMangling != null) return methodWithoutMangling
-                }
-                return getMethodNode(bytes, "$nameWithoutManglingSuffix-impl", asmMethod.descriptor, classType)
-            }
-
-            return methodNode
-        }
-
-        private fun String.stripManglingSuffixOrNull(): String? {
-            val dashIndex = indexOf('-')
-            return if (dashIndex < 0) null else substring(0, dashIndex)
-        }
-
-        private fun isBuiltInArrayIntrinsic(callableDescriptor: CallableMemberDescriptor): Boolean {
-            if (callableDescriptor is FictitiousArrayConstructor) return true
-            val name = callableDescriptor.name.asString()
-            return (name == "arrayOf" || name == "emptyArray") && callableDescriptor.containingDeclaration.let { container ->
-                container is PackageFragmentDescriptor && container.fqName == StandardNames.BUILT_INS_PACKAGE_FQ_NAME
-            }
-        }
-
-        /*descriptor is null for captured vars*/
-        private fun shouldPutGeneralValue(type: Type, kotlinType: KotlinType?, stackValue: StackValue): Boolean {
-            //remap only inline functions (and maybe non primitives)
-            //TODO - clean assertion and remapping logic
-
-            // don't remap boxing/unboxing primitives
-            if (isPrimitive(type) != isPrimitive(stackValue.type)) {
-                return true
-            }
-
-            // don't remap boxing/unboxing inline classes
-            if (StackValue.requiresInlineClassBoxingOrUnboxing(stackValue.type, stackValue.kotlinType, type, kotlinType)) {
-                return true
-            }
-
-            if (stackValue is StackValue.Local) {
-                return false
-            }
-
-            var field = stackValue
-            if (stackValue is StackValue.FieldForSharedVar) {
-                field = stackValue.receiver
-            }
-
-            //check that value corresponds to captured inlining parameter
-            if (field is StackValue.Field) {
-                val varDescriptor = field.descriptor
-                //check that variable is inline function parameter
-                return !(varDescriptor is ParameterDescriptor &&
-                        InlineUtil.isInlineParameter(varDescriptor) &&
-                        InlineUtil.isInline(varDescriptor.containingDeclaration))
-            }
-
-            return true
-        }
-
-
-        fun getDeclarationLabels(lambdaOrFun: PsiElement?, descriptor: DeclarationDescriptor): Set<String> {
-            val result = HashSet<String>()
-
-            if (lambdaOrFun != null) {
-                val label = LabelResolver.getLabelNameIfAny(lambdaOrFun)
-                if (label != null) {
-                    result.add(label.asString())
-                }
-            }
-
-            if (!isFunctionLiteral(descriptor)) {
-                if (!descriptor.name.isSpecial) {
-                    result.add(descriptor.name.asString())
-                }
-                result.add(FIRST_FUN_LABEL)
-            }
-            return result
-        }
+        private fun MethodNode.isBackwardsJump(from: AbstractInsnNode, to: LabelNode): Boolean =
+            instructions.indexOf(to) < instructions.indexOf(from)
     }
-
 }
-
-val BaseExpressionCodegen.v: InstructionAdapter
-    get() = visitor

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

@@ -15,15 +15,13 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 class InlineCodegenForDefaultBody(
     private val function: FunctionDescriptor,
     codegen: ExpressionCodegen,
     val state: GenerationState,
-    private val methodOwner: Type,
     private val jvmSignature: JvmMethodSignature,
-    private val sourceCompilerForInline: SourceCompilerForInline
+    private val sourceCompilerForInline: PsiSourceCompilerForInline
 ) : CallGenerator {
     private val sourceMapper: SourceMapper = codegen.parentCodegen.orCreateSourceMapper
 
@@ -39,32 +37,22 @@ class InlineCodegenForDefaultBody(
     }
 
     override fun genCallInner(callableMethod: Callable, resolvedCall: ResolvedCall<*>?, callDefault: Boolean, codegen: ExpressionCodegen) {
-        val nodeAndSmap = PsiInlineCodegen(
-            codegen, state, function, methodOwner, jvmSignature, TypeParameterMappings(), sourceCompilerForInline
-        ).createInlineMethodNode(
-            callDefault, null, codegen.typeSystem
-        )
-        val childSourceMapper = SourceMapCopier(sourceMapper, nodeAndSmap.classSMAP)
-
-        val node = nodeAndSmap.node
-        val transformedMethod = MethodNode(
-            node.access,
-            node.name,
-            node.desc,
-            node.signature,
-            node.exceptions.toTypedArray()
-        )
+        assert(!callDefault) { "inlining default stub into another default stub" }
+        val (node, smap) = sourceCompilerForInline.compileInlineFunction(jvmSignature)
+        val childSourceMapper = SourceMapCopier(sourceMapper, smap)
 
         val argsSize =
             (Type.getArgumentsAndReturnSizes(jvmSignature.asmMethod.descriptor) ushr 2) - if (callableMethod.isStaticCall()) 1 else 0
-        node.accept(object : InlineAdapter(transformedMethod, 0, childSourceMapper) {
-            override fun visitLocalVariable(name: String, desc: String, signature: String?, start: Label, end: Label, index: Int) {
-                val startLabel = if (index < argsSize) methodStartLabel else start
-                super.visitLocalVariable(name, desc, signature, startLabel, end, index)
-            }
-        })
+        // `$default` is only for Kotlin use so it has no `$$forInline` version - this *is* what the inliner will use.
+        node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
+        node.accept(object : MethodBodyVisitor(codegen.visitor) {
+            // The LVT was not generated at all, so move the start of parameters to the start of the method.
+            override fun visitLocalVariable(name: String, desc: String, signature: String?, start: Label, end: Label, index: Int) =
+                super.visitLocalVariable(name, desc, signature, if (index < argsSize) methodStartLabel else start, end, index)
 
-        transformedMethod.accept(MethodBodyVisitor(codegen.visitor))
+            override fun visitLineNumber(line: Int, start: Label) =
+                super.visitLineNumber(childSourceMapper.mapLineNumber(line), start)
+        })
     }
 
     override fun genValueAndPut(
@@ -85,7 +73,7 @@ class InlineCodegenForDefaultBody(
         throw UnsupportedOperationException("Shouldn't be called")
     }
 
-    override fun processAndPutHiddenParameters(justProcess: Boolean) {
+    override fun processHiddenParameters() {
         throw UnsupportedOperationException("Shouldn't be called")
     }
 

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

@@ -44,8 +44,16 @@ open class InliningContext(
     val lambdaInfo: LambdaInfo?,
     val classRegeneration: Boolean
 ) {
+    val isInliningLambda
+        get() = lambdaInfo != null
 
-    val isInliningLambda = lambdaInfo != null
+    // Consider this arrangement:
+    //     inline fun <reified T> f(x: () -> Unit = { /* uses `T` in a local class */ }) = x()
+    //     inline fun <reified V> g() = f<...> { /* uses `V` in a local class */ }
+    // When inlining `f` into `g`, we need to reify the contents of the default for `x` (if it was used), but not the
+    // contents of the lambda passed as the argument in `g` as all reified type parameters used by the latter are not from `f`.
+    val shouldReifyTypeParametersInObjects: Boolean
+        get() = lambdaInfo == null || lambdaInfo is DefaultLambda
 
     var generateAssertField = false
 
@@ -54,7 +62,8 @@ open class InliningContext(
 
     var isContinuation: Boolean = false
 
-    val isRoot: Boolean = parent == null
+    val isRoot: Boolean
+        get() = parent == null
 
     val root: RootInliningContext
         get() = if (isRoot) this as RootInliningContext else parent!!.root

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

@@ -6,24 +6,18 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.coroutines.isCoroutineSuperClass
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
-import kotlin.properties.Delegates
 
 interface FunctionalArgument
 
-abstract class LambdaInfo(@JvmField val isCrossInline: Boolean) : FunctionalArgument {
-
-    abstract val isBoundCallableReference: Boolean
-
-    abstract val isSuspend: Boolean
-
+abstract class LambdaInfo : FunctionalArgument {
     abstract val lambdaClassType: Type
 
     abstract val invokeMethod: Method
@@ -41,13 +35,17 @@ abstract class LambdaInfo(@JvmField val isCrossInline: Boolean) : FunctionalArgu
 
     val reifiedTypeParametersUsages = ReifiedTypeParametersUsages()
 
-    abstract fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>)
-
-    open val hasDispatchReceiver = true
+    open val hasDispatchReceiver
+        get() = true
 
     fun addAllParameters(remapper: FieldRemapper): Parameters {
-        val builder = ParametersBuilder.initializeBuilderFrom(OBJECT_TYPE, invokeMethod.descriptor, this)
-
+        val builder = ParametersBuilder.newBuilder()
+        if (hasDispatchReceiver) {
+            builder.addThis(lambdaClassType, skipped = true).functionalArgument = this
+        }
+        for (type in Type.getArgumentTypes(invokeMethod.descriptor)) {
+            builder.addNextParameter(type, skipped = false)
+        }
         for (info in capturedVars) {
             val field = remapper.findField(FieldInsnNode(0, info.containingLambdaName, info.fieldName, ""))
                 ?: error("Captured field not found: " + info.containingLambdaName + "." + info.fieldName)
@@ -69,76 +67,75 @@ abstract class LambdaInfo(@JvmField val isCrossInline: Boolean) : FunctionalArgu
 
 object NonInlineableArgumentForInlineableParameterCalledInSuspend : FunctionalArgument
 object NonInlineableArgumentForInlineableSuspendParameter : FunctionalArgument
+object DefaultValueOfInlineParameter : FunctionalArgument
 
-abstract class ExpressionLambda(isCrossInline: Boolean) : LambdaInfo(isCrossInline) {
-    override fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>) {
+abstract class ExpressionLambda : LambdaInfo() {
+    fun generateLambdaBody(sourceCompiler: SourceCompilerForInline) {
         node = sourceCompiler.generateLambdaBody(this, reifiedTypeParametersUsages)
         node.node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
     }
 }
 
-abstract class DefaultLambda(
-    private val capturedArgs: Array<Type>,
-    isCrossinline: Boolean,
-    val offset: Int,
-    val needReification: Boolean
-) : LambdaInfo(isCrossinline) {
+class DefaultLambda(info: ExtractedDefaultLambda, sourceCompiler: SourceCompilerForInline) : LambdaInfo() {
+    val isBoundCallableReference: Boolean
 
-    final override var isBoundCallableReference by Delegates.notNull<Boolean>()
-        private set
+    override val lambdaClassType: Type = info.type
+    override val capturedVars: List<CapturedParamDesc>
 
-    val parameterOffsetsInDefault: MutableList<Int> = arrayListOf()
+    override val invokeMethod: Method
+        get() = Method(node.node.name, node.node.desc)
 
-    final override lateinit var invokeMethod: Method
-        private set
+    private val nullableAnyType = sourceCompiler.state.module.builtIns.nullableAnyType
 
-    final override lateinit var capturedVars: List<CapturedParamDesc>
-        private set
+    override val invokeMethodParameters: List<KotlinType>
+        get() = List(invokeMethod.argumentTypes.size) { nullableAnyType }
 
-    var originalBoundReceiverType: Type? = null
-        private set
+    override val invokeMethodReturnType: KotlinType
+        get() = nullableAnyType
 
-    override val isSuspend = false // TODO: it should probably be true sometimes, but it never was
+    val originalBoundReceiverType: Type?
 
-    override fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>) {
-        val classBytes = loadClassBytesByInternalName(sourceCompiler.state, lambdaClassType.internalName)
+    init {
+        val classBytes =
+            sourceCompiler.state.inlineCache.classBytes.getOrPut(lambdaClassType.internalName) {
+                loadClassBytesByInternalName(sourceCompiler.state, lambdaClassType.internalName)
+            }
         val superName = ClassReader(classBytes).superName
-        val isPropertyReference = superName in PROPERTY_REFERENCE_SUPER_CLASSES
-        val isFunctionReference = superName == FUNCTION_REFERENCE.internalName || superName == FUNCTION_REFERENCE_IMPL.internalName
-
-        val constructorDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
-        val constructor = getMethodNode(classBytes, "<init>", constructorDescriptor, lambdaClassType)?.node
-        assert(constructor != null || capturedArgs.isEmpty()) {
-            "Can't find non-default constructor <init>$constructorDescriptor for default lambda $lambdaClassType"
+        // TODO: suspend lambdas are their own continuations, so the body is pre-inlined into `invokeSuspend`
+        //   and thus can't be detangled from the state machine. To make them inlinable, this needs to be redesigned.
+        //   See `SuspendLambdaLowering`.
+        require(!sourceCompiler.state.languageVersionSettings.isCoroutineSuperClass(superName)) {
+            "suspend default lambda ${lambdaClassType.internalName} cannot be inlined; use a function reference instead"
         }
+
+        val constructorMethod = Method("<init>", Type.VOID_TYPE, info.capturedArgs)
+        val constructor = getMethodNode(classBytes, lambdaClassType, constructorMethod)?.node
+        assert(constructor != null || info.capturedArgs.isEmpty()) {
+            "can't find constructor '$constructorMethod' for default lambda '${lambdaClassType.internalName}'"
+        }
+
+        val isPropertyReference = superName in PROPERTY_REFERENCE_SUPER_CLASSES
+        val isReference = isPropertyReference ||
+                superName == FUNCTION_REFERENCE.internalName || superName == FUNCTION_REFERENCE_IMPL.internalName
+        // This only works for primitives but not inline classes, since information about the Kotlin type of the bound
+        // receiver is not present anywhere. This is why with JVM_IR the constructor argument of bound references
+        // is already `Object`, and this field is never used.
+        originalBoundReceiverType =
+            info.capturedArgs.singleOrNull()?.takeIf { isReference && AsmUtil.isPrimitive(it) }
         capturedVars =
-            if (isFunctionReference || isPropertyReference)
-                constructor?.desc?.let { Type.getArgumentTypes(it) }?.singleOrNull()?.let {
-                    originalBoundReceiverType = it
-                    listOf(capturedParamDesc(AsmUtil.RECEIVER_PARAMETER_NAME, AsmUtil.boxType(it), isSuspend = false))
+            if (isReference)
+                info.capturedArgs.singleOrNull()?.let {
+                    // See `InlinedLambdaRemapper`
+                    listOf(capturedParamDesc(AsmUtil.RECEIVER_PARAMETER_NAME, OBJECT_TYPE, isSuspend = false))
                 } ?: emptyList()
             else
                 constructor?.findCapturedFieldAssignmentInstructions()?.map { fieldNode ->
                     capturedParamDesc(fieldNode.name, Type.getType(fieldNode.desc), isSuspend = false)
                 }?.toList() ?: emptyList()
-        isBoundCallableReference = (isFunctionReference || isPropertyReference) && capturedVars.isNotEmpty()
-
-        val invokeNameFallback = (if (isPropertyReference) OperatorNameConventions.GET else OperatorNameConventions.INVOKE).asString()
-        val invokeMethod = mapAsmMethod(sourceCompiler, isPropertyReference)
-        // TODO: `signatureAmbiguity = true` ignores the argument types from `invokeDescriptor` and only looks at the count.
-        //   This effectively masks incorrect results from `mapAsmDescriptor`, which hopefully won't manifest in another way.
-        node = getMethodNode(classBytes, invokeMethod.name, invokeMethod.descriptor, lambdaClassType, signatureAmbiguity = true)
-            ?: getMethodNode(classBytes, invokeNameFallback, invokeMethod.descriptor, lambdaClassType, signatureAmbiguity = true)
-                    ?: error("Can't find method '$invokeMethod' in '${lambdaClassType.internalName}'")
-        this.invokeMethod = Method(node.node.name, node.node.desc)
-        if (needReification) {
-            //nested classes could also require reification
-            reifiedTypeParametersUsages.mergeAll(reifiedTypeInliner.reifyInstructions(node.node))
-        }
+        isBoundCallableReference = isReference && capturedVars.isNotEmpty()
+        node = loadDefaultLambdaBody(classBytes, lambdaClassType, isPropertyReference)
     }
 
-    protected abstract fun mapAsmMethod(sourceCompiler: SourceCompilerForInline, isPropertyReference: Boolean): Method
-
     private companion object {
         val PROPERTY_REFERENCE_SUPER_CLASSES =
             listOf(

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.coroutines.continuationAsmType
 import org.jetbrains.kotlin.codegen.inline.FieldRemapper.Companion.foldName
 import org.jetbrains.kotlin.codegen.inline.coroutines.CoroutineTransformer
-import org.jetbrains.kotlin.codegen.inline.coroutines.isSuspendLambdaCapturedByOuterObjectOrLambda
 import org.jetbrains.kotlin.codegen.inline.coroutines.markNoinlineLambdaIfSuspend
 import org.jetbrains.kotlin.codegen.inline.coroutines.surroundInvokesWithSuspendMarkersIfNeeded
 import org.jetbrains.kotlin.codegen.optimization.ApiVersionCallsPreprocessingMethodTransformer
@@ -18,13 +17,12 @@ 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.fixStack.*
+import org.jetbrains.kotlin.codegen.optimization.fixStack.FastStackAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
 import org.jetbrains.kotlin.utils.SmartList
@@ -38,8 +36,6 @@ 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.*
@@ -59,8 +55,10 @@ 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()
@@ -94,10 +92,6 @@ class MethodInliner(
     ): InlineResult {
         //analyze body
         var transformedNode = markPlacesForInlineAndRemoveInlinable(node, returnLabels, finallyDeepShift)
-        if (inliningContext.isInliningLambda && isDefaultLambdaWithReification(inliningContext.lambdaInfo!!)) {
-            //TODO maybe move reification in one place
-            inliningContext.root.inlineMethodReifier.reifyInstructions(transformedNode)
-        }
 
         //substitute returns with "goto end" instruction to keep non local returns in lambdas
         val end = linkedLabel()
@@ -230,11 +224,11 @@ class MethodInliner(
                         return
                     }
 
-                    val nullableAnyType = inliningContext.root.sourceCompilerForInline.compilationContextDescriptor.builtIns.nullableAnyType
+                    val nullableAnyType = inliningContext.state.module.builtIns.nullableAnyType
                     val expectedParameters = info.invokeMethod.argumentTypes
                     val expectedKotlinParameters = info.invokeMethodParameters
                     val argumentCount = Type.getArgumentTypes(desc).size.let {
-                        if (!inliningContext.root.state.isIrBackend && info.isSuspend && it < expectedParameters.size) {
+                        if (info is PsiExpressionLambda && info.invokeMethodDescriptor.isSuspend && it < expectedParameters.size) {
                             // Inlining suspend lambda into a function that takes a non-suspend lambda.
                             // In the IR backend, this cannot happen as inline lambdas are not lowered.
                             addFakeContinuationMarker(this)
@@ -279,7 +273,8 @@ 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)
@@ -309,7 +304,7 @@ class MethodInliner(
                             } else capturedParamDesc
                             visitFieldInsn(
                                 Opcodes.GETSTATIC, realDesc.containingLambdaName,
-                                FieldRemapper.foldName(realDesc.fieldName), realDesc.type.descriptor
+                                foldName(realDesc.fieldName), realDesc.type.descriptor
                             )
                         }
                         super.visitMethodInsn(opcode, info.newClassName, name, info.newConstructorDescriptor, itf)
@@ -323,10 +318,11 @@ class MethodInliner(
                     } else {
                         super.visitMethodInsn(opcode, owner, name, desc, itf)
                     }
-                } else if ((!inliningContext.isInliningLambda || isDefaultLambdaWithReification(inliningContext.lambdaInfo!!)) &&
-                    ReifiedTypeInliner.isNeedClassReificationMarker(MethodInsnNode(opcode, owner, name, desc, false))
-                ) {
-                    //we shouldn't process here content of inlining lambda it should be reified at external level except default lambdas
+                } else if (ReifiedTypeInliner.isNeedClassReificationMarker(MethodInsnNode(opcode, owner, name, desc, false))) {
+                    // If objects are reified, the marker will be recreated by `handleAnonymousObjectRegeneration` above.
+                    if (!inliningContext.shouldReifyTypeParametersInObjects) {
+                        super.visitMethodInsn(opcode, owner, name, desc, itf)
+                    }
                 } else {
                     super.visitMethodInsn(opcode, owner, name, desc, itf)
                 }
@@ -351,9 +347,6 @@ class MethodInliner(
         return resultNode
     }
 
-    private fun isDefaultLambdaWithReification(lambdaInfo: LambdaInfo) =
-        lambdaInfo is DefaultLambda && lambdaInfo.needReification
-
     private fun prepareNode(node: MethodNode, finallyDeepShift: Int): MethodNode {
         node.instructions.resetLabels()
 
@@ -383,10 +376,7 @@ class MethodInliner(
             private fun getNewIndex(`var`: Int): Int {
                 val lambdaInfo = inliningContext.lambdaInfo
                 if (reorderIrLambdaParameters && lambdaInfo is IrExpressionLambda) {
-                    val extensionSize =
-                        if (lambdaInfo.isExtensionLambda && !lambdaInfo.isBoundCallableReference)
-                            lambdaInfo.invokeMethod.argumentTypes[0].size
-                        else 0
+                    val extensionSize = if (lambdaInfo.isExtensionLambda) lambdaInfo.invokeMethod.argumentTypes[0].size else 0
                     return when {
                         //                v-- extensionSize     v-- argsSizeOnStack
                         // |- extension -|- captured -|- real -|- locals -|    old descriptor
@@ -425,10 +415,10 @@ class MethodInliner(
                 if (DEFAULT_LAMBDA_FAKE_CALL == owner) {
                     val index = name.substringAfter(DEFAULT_LAMBDA_FAKE_CALL).toInt()
                     val lambda = getFunctionalArgumentIfExists(index) as DefaultLambda
-                    lambda.parameterOffsetsInDefault.zip(lambda.capturedVars).asReversed().forEach { (_, captured) ->
-                        val originalBoundReceiverType = lambda.originalBoundReceiverType
-                        if (lambda.isBoundCallableReference && AsmUtil.isPrimitive(originalBoundReceiverType)) {
-                            StackValue.onStack(originalBoundReceiverType!!).put(captured.type, InstructionAdapter(this))
+                    for (captured in lambda.capturedVars.asReversed()) {
+                        lambda.originalBoundReceiverType?.let {
+                            // The receiver is the only captured value; it needs to be boxed.
+                            StackValue.onStack(it).put(captured.type, InstructionAdapter(this))
                         }
                         super.visitFieldInsn(
                             Opcodes.PUTSTATIC,
@@ -452,7 +442,7 @@ class MethodInliner(
                         else -> ""
                     }
 
-                    val varName = if (!varSuffix.isEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
+                    val varName = if (varSuffix.isNotEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
                     super.visitLocalVariable(varName + varSuffix, desc, signature, start, end, getNewIndex(index))
                 }
             }
@@ -544,36 +534,36 @@ class MethodInliner(
                     cur.opcode == Opcodes.GETSTATIC -> {
                         val fieldInsnNode = cur as FieldInsnNode?
                         val className = fieldInsnNode!!.owner
-                        if (isAnonymousSingletonLoad(className, fieldInsnNode.name)) {
-                            recordTransformation(
-                                AnonymousObjectTransformationInfo(
-                                    className, awaitClassReification, isAlreadyRegenerated(className), true,
-                                    inliningContext.nameGenerator
+                        when {
+                            isAnonymousSingletonLoad(className, fieldInsnNode.name) -> {
+                                recordTransformation(
+                                    AnonymousObjectTransformationInfo(
+                                        className, awaitClassReification, isAlreadyRegenerated(className), true,
+                                        inliningContext.nameGenerator
+                                    )
                                 )
-                            )
-                            awaitClassReification = false
-                        } else if (isWhenMappingAccess(className, fieldInsnNode.name)) {
-                            recordTransformation(
-                                WhenMappingTransformationInfo(
-                                    className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
+                                awaitClassReification = false
+                            }
+                            isWhenMappingAccess(className, fieldInsnNode.name) -> {
+                                recordTransformation(
+                                    WhenMappingTransformationInfo(
+                                        className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
+                                    )
                                 )
-                            )
-                        } else if (fieldInsnNode.isCheckAssertionsStatus()) {
-                            fieldInsnNode.owner = inlineCallSiteInfo.ownerClassName
-                            if (inliningContext.isInliningLambda) {
-                                if (inliningContext.lambdaInfo!!.isCrossInline) {
-                                    assert(inliningContext.parent?.parent is RegeneratedClassContext) {
-                                        "$inliningContext grandparent shall be RegeneratedClassContext but got ${inliningContext.parent?.parent}"
-                                    }
-                                    inliningContext.parent!!.parent!!.generateAssertField = true
-                                } else {
-                                    assert(inliningContext.parent != null) {
-                                        "$inliningContext parent shall not be null"
-                                    }
-                                    inliningContext.parent!!.generateAssertField = true
-                                }
-                            } else {
-                                inliningContext.generateAssertField = true
+                            }
+                            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
                             }
                         }
                     }
@@ -603,7 +593,7 @@ class MethodInliner(
                                 assert(lambdaInfo.lambdaClassType.internalName == nodeRemapper.originalLambdaInternalName) {
                                     "Wrong bytecode template for contract template: ${lambdaInfo.lambdaClassType.internalName} != ${nodeRemapper.originalLambdaInternalName}"
                                 }
-                                fieldInsn.name = FieldRemapper.foldName(fieldInsn.name)
+                                fieldInsn.name = foldName(fieldInsn.name)
                                 fieldInsn.opcode = Opcodes.PUTSTATIC
                                 toDelete.addAll(stackTransformations)
                             }
@@ -643,9 +633,8 @@ class MethodInliner(
     private fun replaceContinuationAccessesWithFakeContinuationsIfNeeded(processingNode: MethodNode) {
         // in ir backend inline suspend lambdas do not use ALOAD 0 to get continuation, since they are generated as static functions
         // instead they get continuation from parameter.
-        if (inliningContext.state.isIrBackend) return
         val lambdaInfo = inliningContext.lambdaInfo ?: return
-        if (!lambdaInfo.isSuspend) return
+        if (lambdaInfo !is PsiExpressionLambda || !lambdaInfo.invokeMethodDescriptor.isSuspend) return
         val sources = analyzeMethodNodeWithInterpreter(processingNode, Aload0Interpreter(processingNode))
         val cfg = ControlFlowGraph.build(processingNode)
         val aload0s = processingNode.instructions.asSequence().filter { it.opcode == Opcodes.ALOAD && it.safeAs<VarInsnNode>()?.`var` == 0 }
@@ -758,7 +747,7 @@ class MethodInliner(
             ApiVersionCallsPreprocessingMethodTransformer(targetApiVersion).transform("fake", node)
         }
 
-        val frames = analyzeMethodNodeWithInterpreter(node, BasicInterpreter())
+        val frames = FastStackAnalyzer("<fake>", node, FixStackInterpreter()).analyze()
 
         val localReturnsNormalizer = LocalReturnsNormalizer()
 
@@ -825,7 +814,7 @@ class MethodInliner(
                 getFunctionalArgumentIfExists((insnNode as VarInsnNode).`var`)
             insnNode is FieldInsnNode && insnNode.name.startsWith(CAPTURED_FIELD_FOLD_PREFIX) ->
                 findCapturedField(insnNode, nodeRemapper).functionalArgument
-            insnNode is FieldInsnNode && insnNode.isSuspendLambdaCapturedByOuterObjectOrLambda(inliningContext) ->
+            insnNode is FieldInsnNode && inliningContext.root.sourceCompilerForInline.isSuspendLambdaCapturedByOuterObjectOrLambda(insnNode.name) ->
                 NonInlineableArgumentForInlineableParameterCalledInSuspend
             else ->
                 null
@@ -847,9 +836,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.map {
+            val map = capturedVars.associate {
                 offset to it.also { offset += it.type.size }
-            }.toMap()
+            }
 
             var cur: AbstractInsnNode? = node.instructions.first
             while (cur != null) {
@@ -894,6 +883,7 @@ class MethodInliner(
         }
     }
 
+    @Suppress("SameParameterValue")
     private fun wrapException(originalException: Throwable, node: MethodNode, errorSuffix: String): RuntimeException {
         return if (originalException is InlineException) {
             InlineException("$errorPrefix: $errorSuffix", originalException)
@@ -906,7 +896,7 @@ class MethodInliner(
         private class LocalReturn(
             private val returnInsn: AbstractInsnNode,
             private val insertBeforeInsn: AbstractInsnNode,
-            private val frame: Frame<BasicValue>
+            private val frame: Frame<FixStackValue>
         ) {
 
             fun transform(insnList: InsnList, returnVariableIndex: Int) {
@@ -917,22 +907,19 @@ class MethodInliner(
                 if (expectedStackSize == actualStackSize) return
 
                 var stackSize = actualStackSize
+                val topValue = frame.getStack(stackSize - 1)
                 if (isReturnWithValue) {
-                    val storeOpcode = Opcodes.ISTORE + returnInsn.opcode - Opcodes.IRETURN
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(storeOpcode, returnVariableIndex))
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.storeOpcode, returnVariableIndex))
                     stackSize--
                 }
 
                 while (stackSize > 0) {
-                    val stackElementSize = frame.getStack(stackSize - 1).size
-                    val popOpcode = if (stackElementSize == 1) Opcodes.POP else Opcodes.POP2
-                    insnList.insertBefore(insertBeforeInsn, InsnNode(popOpcode))
+                    insnList.insertBefore(insertBeforeInsn, InsnNode(frame.getStack(stackSize - 1).popOpcode))
                     stackSize--
                 }
 
                 if (isReturnWithValue) {
-                    val loadOpcode = Opcodes.ILOAD + returnInsn.opcode - Opcodes.IRETURN
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(loadOpcode, returnVariableIndex))
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.loadOpcode, returnVariableIndex))
                 }
             }
         }
@@ -942,10 +929,10 @@ class MethodInliner(
         private var returnVariableSize = 0
         private var returnOpcode = -1
 
-        internal fun addLocalReturnToTransform(
+        fun addLocalReturnToTransform(
             returnInsn: AbstractInsnNode,
             insertBeforeInsn: AbstractInsnNode,
-            sourceValueFrame: Frame<BasicValue>
+            sourceValueFrame: Frame<FixStackValue>
         ) {
             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] }
@@ -954,11 +941,7 @@ 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/MethodInlinerUtil.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
+import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
 import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
 import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
@@ -17,15 +17,6 @@ import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
 import org.jetbrains.org.objectweb.asm.tree.analysis.*
 
-fun parameterOffsets(isStatic: Boolean, valueParameters: List<JvmMethodParameterSignature>): Array<Int> {
-    var nextOffset = if (isStatic) 0 else 1
-    return Array(valueParameters.size) { index ->
-        nextOffset.also {
-            nextOffset += valueParameters[index].asmType.size
-        }
-    }
-}
-
 fun MethodNode.remove(instructions: Sequence<AbstractInsnNode>) =
     instructions.forEach {
         this@remove.instructions.remove(it)
@@ -136,7 +127,7 @@ internal class Aload0Interpreter(private val node: MethodNode) : BasicInterprete
 internal fun AbstractInsnNode.isAload0() = opcode == Opcodes.ALOAD && (this as VarInsnNode).`var` == 0
 
 internal fun analyzeMethodNodeWithInterpreter(node: MethodNode, interpreter: BasicInterpreter): Array<out Frame<BasicValue>?> {
-    val analyzer = object : Analyzer<BasicValue>(interpreter) {
+    val analyzer = object : FastMethodAnalyzer<BasicValue>("fake", node, interpreter) {
         override fun newFrame(nLocals: Int, nStack: Int): Frame<BasicValue> {
 
             return object : Frame<BasicValue>(nLocals, nStack) {
@@ -151,7 +142,7 @@ internal fun analyzeMethodNodeWithInterpreter(node: MethodNode, interpreter: Bas
     }
 
     try {
-        return analyzer.analyze("fake", node)
+        return analyzer.analyze()
     } catch (e: AnalyzerException) {
         throw RuntimeException(e)
     }

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

@@ -37,7 +37,7 @@ abstract class ObjectTransformer<out T : TransformationInfo>(@JvmField val trans
         val classBuilder = state.factory.newVisitor(
             JvmDeclarationOrigin.NO_ORIGIN,
             Type.getObjectType(transformationInfo.newClassName),
-            inliningContext.root.sourceCompilerForInline.callsiteFile!!
+            inliningContext.callSiteInfo.file!!
         )
 
         return RemappingClassBuilder(

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

@@ -107,22 +107,5 @@ class ParametersBuilder private constructor() {
         fun newBuilder(): ParametersBuilder {
             return ParametersBuilder()
         }
-
-        @JvmOverloads
-        @JvmStatic
-        fun initializeBuilderFrom(
-            objectType: Type, descriptor: String, inlineLambda: LambdaInfo? = null, isStatic: Boolean = false
-        ): ParametersBuilder {
-            val builder = newBuilder()
-            if (inlineLambda?.hasDispatchReceiver != false && !isStatic) {
-                //skipped this for inlined lambda cause it will be removed
-                builder.addThis(objectType, inlineLambda != null).functionalArgument = inlineLambda
-            }
-
-            for (type in Type.getArgumentTypes(descriptor)) {
-                builder.addNextParameter(type, false)
-            }
-            return builder
-        }
     }
 }

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

@@ -5,19 +5,14 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
-import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
 import org.jetbrains.kotlin.codegen.*
-import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getMethodAsmFlags
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
@@ -26,39 +21,33 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.inline.InlineUtil.isInlinableParameterExpression
+import org.jetbrains.kotlin.resolve.inline.isInlineOnly
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.org.objectweb.asm.Label
-import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.Method
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 class PsiInlineCodegen(
     codegen: ExpressionCodegen,
     state: GenerationState,
-    function: FunctionDescriptor,
-    methodOwner: Type,
+    private val functionDescriptor: FunctionDescriptor,
     signature: JvmMethodSignature,
     typeParameterMappings: TypeParameterMappings<KotlinType>,
     sourceCompiler: SourceCompilerForInline,
-    private val actualDispatchReceiver: Type = methodOwner
+    private val methodOwner: Type,
+    private val actualDispatchReceiver: Type,
+    reportErrorsOn: KtElement,
 ) : InlineCodegen<ExpressionCodegen>(
-    codegen, state, function, methodOwner, signature, typeParameterMappings, sourceCompiler,
+    codegen, state, signature, typeParameterMappings, sourceCompiler,
     ReifiedTypeInliner(
-        typeParameterMappings, PsiInlineIntrinsicsSupport(state), codegen.typeSystem,
+        typeParameterMappings, PsiInlineIntrinsicsSupport(state, reportErrorsOn), codegen.typeSystem,
         state.languageVersionSettings, state.unifiedNullChecks
     ),
 ), CallGenerator {
-    override fun generateAssertFieldIfNeeded(info: RootInliningContext) {
-        if (info.generateAssertField) {
-            codegen.parentCodegen.generateAssertField()
-        }
-    }
+    override fun generateAssertField() =
+        codegen.parentCodegen.generateAssertField()
 
     override fun genCallInner(
         callableMethod: Callable,
@@ -66,13 +55,26 @@ class PsiInlineCodegen(
         callDefault: Boolean,
         codegen: ExpressionCodegen
     ) {
+        (sourceCompiler as PsiSourceCompilerForInline).callDefault = callDefault
+        assert(hiddenParameters.isEmpty()) { "putHiddenParamsIntoLocals() should be called after processHiddenParameters()" }
         if (!state.globalInlineContext.enterIntoInlining(functionDescriptor, resolvedCall?.call?.callElement)) {
             generateStub(resolvedCall?.call?.callElement?.text ?: "<no source>", codegen)
             return
         }
         try {
             val registerLineNumber = registerLineNumberAfterwards(resolvedCall)
-            performInline(resolvedCall?.typeArguments?.keys?.toList(), callDefault, callDefault, codegen.typeSystem, registerLineNumber)
+            for (info in expressionMap.values) {
+                if (info is PsiExpressionLambda) {
+                    // Can't be done immediately in `rememberClosure` for some reason:
+                    info.generateLambdaBody(sourceCompiler)
+                    // Requires `generateLambdaBody` first if the closure is non-empty (for bound callable references,
+                    // or indeed any callable references, it *is* empty, so this was done in `rememberClosure`):
+                    if (!info.isBoundCallableReference) {
+                        putClosureParametersOnStack(info, null)
+                    }
+                }
+            }
+            performInline(registerLineNumber, functionDescriptor.isInlineOnly())
         } finally {
             state.globalInlineContext.exitFromInlining()
         }
@@ -84,46 +86,29 @@ class PsiInlineCodegen(
         return parentIfCondition.isAncestor(callElement, false)
     }
 
-    override fun processAndPutHiddenParameters(justProcess: Boolean) {
-        if (getMethodAsmFlags(functionDescriptor, sourceCompiler.contextKind, state) and Opcodes.ACC_STATIC == 0) {
-            invocationParamBuilder.addNextParameter(methodOwner, false, actualDispatchReceiver)
-        }
+    private val hiddenParameters = mutableListOf<Pair<ParameterInfo, Int>>()
 
+    override fun processHiddenParameters() {
+        if (!DescriptorAsmUtil.isStaticMethod((sourceCompiler as PsiSourceCompilerForInline).context.contextKind, functionDescriptor)) {
+            hiddenParameters += invocationParamBuilder.addNextParameter(methodOwner, false, actualDispatchReceiver) to
+                    codegen.frameMap.enterTemp(methodOwner)
+        }
         for (param in jvmSignature.valueParameters) {
             if (param.kind == JvmMethodParameterKind.VALUE) {
                 break
             }
-            invocationParamBuilder.addNextParameter(param.asmType, false)
+            hiddenParameters += invocationParamBuilder.addNextParameter(param.asmType, false) to
+                    codegen.frameMap.enterTemp(param.asmType)
         }
-
         invocationParamBuilder.markValueParametersStart()
-        val hiddenParameters = invocationParamBuilder.buildParameters().parameters
-
-        delayedHiddenWriting = recordParameterValueInLocalVal(justProcess, false, *hiddenParameters.toTypedArray())
     }
 
-    override fun putClosureParametersOnStack(next: LambdaInfo, functionReferenceReceiver: StackValue?) {
-        activeLambda = next
-        when (next) {
-            is PsiExpressionLambda -> codegen.pushClosureOnStack(next.classDescriptor, true, this, functionReferenceReceiver)
-            is DefaultLambda -> rememberCapturedForDefaultLambda(next)
-            else -> throw RuntimeException("Unknown lambda: $next")
+    override fun putHiddenParamsIntoLocals() {
+        for (i in hiddenParameters.indices.reversed()) {
+            val (param, offset) = hiddenParameters[i]
+            StackValue.local(offset, param.type).store(StackValue.onStack(param.typeOnStack), codegen.visitor)
         }
-        activeLambda = null
-    }
-
-    private fun getBoundCallableReferenceReceiver(argumentExpression: KtExpression): ReceiverValue? {
-        val deparenthesized = KtPsiUtil.deparenthesize(argumentExpression) as? KtCallableReferenceExpression ?: return null
-        val resolvedCall = deparenthesized.callableReference.getResolvedCallWithAssert(state.bindingContext)
-        return JvmCodegenUtil.getBoundCallableReferenceReceiver(resolvedCall)
-    }
-
-    /*lambda or callable reference*/
-    private fun isInliningParameter(expression: KtExpression, valueParameterDescriptor: ValueParameterDescriptor): Boolean {
-        //TODO deparenthesize typed
-        val deparenthesized = KtPsiUtil.deparenthesize(expression)
-
-        return InlineUtil.isInlineParameter(valueParameterDescriptor) && isInlinableParameterExpression(deparenthesized)
+        hiddenParameters.clear()
     }
 
     override fun genValueAndPut(
@@ -137,24 +122,10 @@ class PsiInlineCodegen(
                     "which cannot be declared in Kotlin and thus be inline: $codegen"
         }
 
-        if (isInliningParameter(argumentExpression, valueParameterDescriptor)) {
-            val lambdaInfo = rememberClosure(argumentExpression, parameterType.type, valueParameterDescriptor)
-
-            val receiverValue = getBoundCallableReferenceReceiver(argumentExpression)
-            if (receiverValue != null) {
-                val receiver = codegen.generateReceiverValue(receiverValue, false)
-                val receiverKotlinType = receiver.kotlinType
-                val boxedReceiver =
-                    if (receiverKotlinType != null)
-                        DescriptorAsmUtil.boxType(receiver.type, receiverKotlinType, state.typeMapper)
-                    else
-                        AsmUtil.boxType(receiver.type)
-
-                putClosureParametersOnStack(
-                    lambdaInfo,
-                    StackValue.coercion(receiver, boxedReceiver, receiverKotlinType)
-                )
-            }
+        val isInlineParameter = InlineUtil.isInlineParameter(valueParameterDescriptor)
+        //TODO deparenthesize typed
+        if (isInlineParameter && isInlinableParameterExpression(KtPsiUtil.deparenthesize(argumentExpression))) {
+            rememberClosure(argumentExpression, parameterType.type, valueParameterDescriptor)
         } else {
             val value = codegen.gen(argumentExpression)
             val kind = when {
@@ -173,52 +144,47 @@ class PsiInlineCodegen(
     private fun isCallSiteIsSuspend(descriptor: ValueParameterDescriptor): Boolean =
         state.bindingContext[CodegenBinding.CALL_SITE_IS_SUSPEND_FOR_CROSSINLINE_LAMBDA, descriptor] == true
 
-    private fun rememberClosure(expression: KtExpression, type: Type, parameter: ValueParameterDescriptor): LambdaInfo {
+    private fun rememberClosure(expression: KtExpression, type: Type, parameter: ValueParameterDescriptor) {
         val ktLambda = KtPsiUtil.deparenthesize(expression)
         assert(isInlinableParameterExpression(ktLambda)) { "Couldn't find inline expression in ${expression.text}" }
 
-        return PsiExpressionLambda(
-            ktLambda!!, state.typeMapper, state.languageVersionSettings,
-            parameter.isCrossinline, getBoundCallableReferenceReceiver(expression) != null
-        ).also { lambda ->
-            val closureInfo = invocationParamBuilder.addNextValueParameter(type, true, null, parameter.index)
-            closureInfo.functionalArgument = lambda
-            expressionMap[closureInfo.index] = lambda
+        val boundReceiver = if (ktLambda is KtCallableReferenceExpression) {
+            val resolvedCall = ktLambda.callableReference.getResolvedCallWithAssert(state.bindingContext)
+            JvmCodegenUtil.getBoundCallableReferenceReceiver(resolvedCall)
+        } else null
+
+        val lambda = PsiExpressionLambda(ktLambda!!, state, parameter.isCrossinline, boundReceiver != null)
+        rememberClosure(type, parameter.index, lambda)
+        if (boundReceiver != null) {
+            // Has to be done immediately to preserve evaluation order.
+            val receiver = codegen.generateReceiverValue(boundReceiver, false)
+            val receiverKotlinType = receiver.kotlinType
+            val boxedReceiver =
+                if (receiverKotlinType != null)
+                    DescriptorAsmUtil.boxType(receiver.type, receiverKotlinType, state.typeMapper)
+                else
+                    AsmUtil.boxType(receiver.type)
+            val receiverValue = StackValue.coercion(receiver, boxedReceiver, receiverKotlinType)
+            putClosureParametersOnStack(lambda, receiverValue)
         }
     }
 
-    override fun putValueIfNeeded(parameterType: JvmKotlinType, value: StackValue, kind: ValueKind, parameterIndex: Int) {
-        if (processDefaultMaskOrMethodHandler(value, kind)) return
+    var activeLambda: PsiExpressionLambda? = null
+        private set
 
-        assert(maskValues.isEmpty()) { "Additional default call arguments should be last ones, but $value" }
-
-        putArgumentOrCapturedToLocalVal(parameterType, value, -1, parameterIndex, kind)
+    private fun putClosureParametersOnStack(next: PsiExpressionLambda, receiverValue: StackValue?) {
+        activeLambda = next
+        codegen.pushClosureOnStack(next.classDescriptor, true, this, receiverValue)
+        activeLambda = null
     }
 
-    override fun putCapturedValueOnStack(stackValue: StackValue, valueType: Type, paramIndex: Int) {
-        putArgumentOrCapturedToLocalVal(
-            JvmKotlinType(stackValue.type, stackValue.kotlinType), stackValue, paramIndex, paramIndex, ValueKind.CAPTURED
-        )
-    }
+    override fun putValueIfNeeded(parameterType: JvmKotlinType, value: StackValue, kind: ValueKind, parameterIndex: Int) =
+        putArgumentToLocalVal(parameterType, value, parameterIndex, kind)
+
+    override fun putCapturedValueOnStack(stackValue: StackValue, valueType: Type, paramIndex: Int) =
+        putCapturedToLocalVal(stackValue, activeLambda!!.capturedVars[paramIndex], stackValue.kotlinType)
 
     override fun reorderArgumentsIfNeeded(actualArgsWithDeclIndex: List<ArgumentAndDeclIndex>, valueParameterTypes: List<Type>) = Unit
-
-    override fun putHiddenParamsIntoLocals() {
-        assert(delayedHiddenWriting != null) { "processAndPutHiddenParameters(true) should be called before putHiddenParamsIntoLocals" }
-        delayedHiddenWriting!!.invoke()
-        delayedHiddenWriting = null
-    }
-
-    override fun extractDefaultLambdas(node: MethodNode): List<DefaultLambda> {
-        return expandMaskConditionsAndUpdateVariableNodes(
-            node, maskStartIndex, maskValues, methodHandleInDefaultMethodIndex,
-            extractDefaultLambdaOffsetAndDescriptor(jvmSignature, functionDescriptor),
-            ::PsiDefaultLambda
-        )
-    }
-
-    override fun descriptorIsDeserialized(memberDescriptor: CallableMemberDescriptor): Boolean =
-        memberDescriptor is DescriptorWithContainerSource
 }
 
 private val FunctionDescriptor.explicitParameters
@@ -226,12 +192,10 @@ private val FunctionDescriptor.explicitParameters
 
 class PsiExpressionLambda(
     expression: KtExpression,
-    private val typeMapper: KotlinTypeMapper,
-    private val languageVersionSettings: LanguageVersionSettings,
-    isCrossInline: Boolean,
-    override val isBoundCallableReference: Boolean
-) : ExpressionLambda(isCrossInline) {
-
+    private val state: GenerationState,
+    val isCrossInline: Boolean,
+    val isBoundCallableReference: Boolean
+) : ExpressionLambda() {
     override val lambdaClassType: Type
 
     override val invokeMethod: Method
@@ -240,10 +204,8 @@ class PsiExpressionLambda(
 
     override val invokeMethodParameters: List<KotlinType?>
         get() {
-            val actualInvokeDescriptor = if (isSuspend)
-                getOrCreateJvmSuspendFunctionView(
-                    invokeMethodDescriptor, languageVersionSettings.isReleaseCoroutines(), typeMapper.bindingContext
-                )
+            val actualInvokeDescriptor = if (invokeMethodDescriptor.isSuspend)
+                getOrCreateJvmSuspendFunctionView(invokeMethodDescriptor, state)
             else
                 invokeMethodDescriptor
             return actualInvokeDescriptor.explicitParameters.map { it.returnType }
@@ -260,12 +222,10 @@ class PsiExpressionLambda(
 
     override val returnLabels: Map<String, Label?>
 
-    override val isSuspend: Boolean
-
     val closure: CalculatedClosure
 
     init {
-        val bindingContext = typeMapper.bindingContext
+        val bindingContext = state.bindingContext
         val function = bindingContext.get(BindingContext.FUNCTION, functionWithBodyOrCallableReference)
         if (function == null && expression is KtCallableReferenceExpression) {
             val variableDescriptor =
@@ -273,7 +233,7 @@ class PsiExpressionLambda(
                     ?: throw AssertionError("Reference expression not resolved to variable descriptor with accessors: ${expression.getText()}")
             classDescriptor = bindingContext.get(CodegenBinding.CLASS_FOR_CALLABLE, variableDescriptor)
                 ?: throw IllegalStateException("Class for callable not found: $variableDescriptor\n${expression.text}")
-            lambdaClassType = typeMapper.mapClass(classDescriptor)
+            lambdaClassType = state.typeMapper.mapClass(classDescriptor)
             val getFunction = PropertyReferenceCodegen.findGetFunction(variableDescriptor)
             invokeMethodDescriptor = PropertyReferenceCodegen.createFakeOpenDescriptor(getFunction, classDescriptor)
             val resolvedCall = expression.callableReference.getResolvedCallWithAssert(bindingContext)
@@ -288,24 +248,25 @@ class PsiExpressionLambda(
 
         closure = bindingContext.get(CodegenBinding.CLOSURE, classDescriptor)
             ?: throw AssertionError("null closure for lambda ${expression.text}")
-        returnLabels = InlineCodegen.getDeclarationLabels(expression, invokeMethodDescriptor).associateWith { null }
-        invokeMethod = typeMapper.mapAsmMethod(invokeMethodDescriptor)
-        isSuspend = invokeMethodDescriptor.isSuspend
+        returnLabels = getDeclarationLabels(expression, invokeMethodDescriptor).associateWith { null }
+        invokeMethod = state.typeMapper.mapAsmMethod(invokeMethodDescriptor)
     }
 
+    // This can only be computed after generating the body, hence `lazy`.
     override val capturedVars: List<CapturedParamDesc> by lazy {
         arrayListOf<CapturedParamDesc>().apply {
             val captureThis = closure.capturedOuterClassDescriptor
             if (captureThis != null) {
-                add(capturedParamDesc(AsmUtil.CAPTURED_THIS_FIELD, typeMapper.mapType(captureThis.defaultType), isSuspend = false))
+                add(capturedParamDesc(AsmUtil.CAPTURED_THIS_FIELD, state.typeMapper.mapType(captureThis.defaultType), isSuspend = false))
             }
 
             val capturedReceiver = closure.capturedReceiverFromOuterContext
             if (capturedReceiver != null) {
-                val fieldName = closure.getCapturedReceiverFieldName(typeMapper.bindingContext, languageVersionSettings)
-                val type = typeMapper.mapType(capturedReceiver).let {
-                    if (isBoundCallableReference) AsmUtil.boxType(it) else it
-                }
+                val fieldName = closure.getCapturedReceiverFieldName(state.typeMapper.bindingContext, state.languageVersionSettings)
+                val type = if (isBoundCallableReference)
+                    state.typeMapper.mapType(capturedReceiver, null, TypeMappingMode.GENERIC_ARGUMENT)
+                else
+                    state.typeMapper.mapType(capturedReceiver)
                 add(capturedParamDesc(fieldName, type, isSuspend = false))
             }
 
@@ -319,40 +280,3 @@ class PsiExpressionLambda(
     val isPropertyReference: Boolean
         get() = propertyReferenceInfo != null
 }
-
-class PsiDefaultLambda(
-    override val lambdaClassType: Type,
-    capturedArgs: Array<Type>,
-    private val parameterDescriptor: ValueParameterDescriptor,
-    offset: Int,
-    needReification: Boolean
-) : DefaultLambda(capturedArgs, parameterDescriptor.isCrossinline, offset, needReification) {
-    private lateinit var invokeMethodDescriptor: FunctionDescriptor
-
-    override val invokeMethodParameters: List<KotlinType?>
-        get() = invokeMethodDescriptor.explicitParameters.map { it.returnType }
-
-    override val invokeMethodReturnType: KotlinType?
-        get() = invokeMethodDescriptor.returnType
-
-    override fun mapAsmMethod(sourceCompiler: SourceCompilerForInline, isPropertyReference: Boolean): Method {
-        val substitutedDescriptor = parameterDescriptor.type.memberScope
-            .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
-            .single()
-        invokeMethodDescriptor = when {
-            // Property references: `(A) -> B` => `get(Any?): Any?`
-            isPropertyReference -> substitutedDescriptor.original
-            // Suspend function references: `suspend (A) -> B` => `invoke(A, Continuation<B>): Any?`
-            // TODO: default suspend lambdas are currently uninlinable
-            parameterDescriptor.type.isSuspendFunctionType ->
-                getOrCreateJvmSuspendFunctionView(
-                    substitutedDescriptor,
-                    sourceCompiler.state.languageVersionSettings.isReleaseCoroutines(),
-                    sourceCompiler.state.bindingContext
-                )
-            // Non-suspend function references and lambdas: `(A) -> B` => `invoke(A): B`
-            else -> substitutedDescriptor
-        }
-        return sourceCompiler.state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor).asmMethod
-    }
-}

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

@@ -5,13 +5,19 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
 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.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.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
@@ -19,7 +25,10 @@ import org.jetbrains.org.objectweb.asm.Type.INT_TYPE
 import org.jetbrains.org.objectweb.asm.Type.VOID_TYPE
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
-class PsiInlineIntrinsicsSupport(private val state: GenerationState) : ReifiedTypeInliner.IntrinsicsSupport<KotlinType> {
+class PsiInlineIntrinsicsSupport(
+    override val state: GenerationState,
+    private val reportErrorsOn: KtElement,
+) : ReifiedTypeInliner.IntrinsicsSupport<KotlinType> {
     override fun putClassInstance(v: InstructionAdapter, type: KotlinType) {
         DescriptorAsmUtil.putJavaLangClassInstance(v, state.typeMapper.mapType(type), type, state.typeMapper)
     }
@@ -56,5 +65,18 @@ class PsiInlineIntrinsicsSupport(private val state: GenerationState) : ReifiedTy
         )
     }
 
+    override fun isMutableCollectionType(type: KotlinType): Boolean {
+        val classifier = type.constructor.declarationDescriptor
+        return classifier is ClassDescriptor && JavaToKotlinClassMap.isMutable(classifier.fqNameUnsafe)
+    }
+
     override fun toKotlinType(type: KotlinType): KotlinType = type
+
+    override fun reportSuspendTypeUnsupported() {
+        state.diagnostics.report(TYPEOF_SUSPEND_TYPE.on(reportErrorsOn))
+    }
+
+    override fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name) {
+        state.diagnostics.report(TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND.on(reportErrorsOn, typeParameterName.asString()))
+    }
 }

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

@@ -0,0 +1,443 @@
+/*
+ * 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.inline
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.backend.common.CodegenUtil
+import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
+import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.binding.CodegenBinding
+import org.jetbrains.kotlin.codegen.context.*
+import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.isReleaseCoroutines
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.incremental.KotlinLookupLocation
+import org.jetbrains.kotlin.psi.*
+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
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.MethodVisitor
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.Method
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
+
+class PsiSourceCompilerForInline(
+    private val codegen: ExpressionCodegen,
+    override val callElement: KtElement,
+    private val functionDescriptor: FunctionDescriptor
+) : SourceCompilerForInline {
+    override val state
+        get() = codegen.state
+
+    private val additionalInnerClasses = mutableListOf<ClassDescriptor>()
+
+    val context = getContext(
+        functionDescriptor,
+        functionDescriptor,
+        codegen.state,
+        DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor)?.containingFile as? KtFile,
+        additionalInnerClasses
+    ) as MethodContext
+
+    override val callElementText: String by lazy { callElement.text }
+
+    override val inlineCallSiteInfo: InlineCallSiteInfo
+        get() {
+            var context = codegen.getContext()
+            var parentCodegen = codegen.parentCodegen
+            while (context is InlineLambdaContext) {
+                val closureContext = context.getParentContext()
+                assert(closureContext is ClosureContext) { "Parent context of inline lambda should be closure context" }
+                assert(closureContext.parentContext is MethodContext) { "Closure context should appear in method context" }
+                context = closureContext.parentContext as MethodContext
+                assert(parentCodegen is FakeMemberCodegen) { "Parent codegen of inlined lambda should be FakeMemberCodegen" }
+                parentCodegen = (parentCodegen as FakeMemberCodegen).delegate
+            }
+
+            val signature = codegen.state.typeMapper.mapSignatureSkipGeneric(context.functionDescriptor, context.contextKind)
+            return InlineCallSiteInfo(
+                parentCodegen.className,
+                signature.asmMethod,
+                context.functionDescriptor.isInlineOrInsideInline(),
+                callElement.containingFile,
+                CodegenUtil.getLineNumberForElement(callElement, false) ?: 0
+            )
+        }
+
+    override val sourceMapper
+        get() = codegen.parentCodegen.orCreateSourceMapper
+
+    override fun generateLambdaBody(lambdaInfo: ExpressionLambda, reifiedTypeParameters: ReifiedTypeParametersUsages): SMAPAndMethodNode {
+        require(lambdaInfo is PsiExpressionLambda)
+        val invokeMethodDescriptor = lambdaInfo.invokeMethodDescriptor
+        val jvmMethodSignature = state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor)
+        val asmMethod = jvmMethodSignature.asmMethod
+        val methodNode = MethodNode(
+            Opcodes.API_VERSION, DescriptorAsmUtil.getMethodAsmFlags(invokeMethodDescriptor, OwnerKind.IMPLEMENTATION, state),
+            asmMethod.name, asmMethod.descriptor, null, null
+        )
+        val adapter = wrapWithMaxLocalCalc(methodNode)
+        val closureContext = when {
+            lambdaInfo.isPropertyReference ->
+                codegen.getContext().intoAnonymousClass(lambdaInfo.classDescriptor, codegen, OwnerKind.IMPLEMENTATION)
+            invokeMethodDescriptor.isSuspend ->
+                codegen.getContext().intoCoroutineClosure(
+                    getOrCreateJvmSuspendFunctionView(invokeMethodDescriptor, state), invokeMethodDescriptor, codegen, state.typeMapper
+                )
+            else -> codegen.getContext().intoClosure(invokeMethodDescriptor, codegen, state.typeMapper)
+        }
+        val context = closureContext.intoInlinedLambda(invokeMethodDescriptor, lambdaInfo.isCrossInline, lambdaInfo.isPropertyReference)
+        val smap = generateMethodBody(
+            adapter, invokeMethodDescriptor, context,
+            lambdaInfo.functionWithBodyOrCallableReference,
+            jvmMethodSignature, lambdaInfo
+        )
+        adapter.visitMaxs(-1, -1)
+        return SMAPAndMethodNode(methodNode, smap)
+    }
+
+    private fun generateMethodBody(
+        adapter: MethodVisitor,
+        descriptor: FunctionDescriptor,
+        context: MethodContext,
+        expression: KtExpression,
+        jvmMethodSignature: JvmMethodSignature,
+        lambdaInfo: PsiExpressionLambda?
+    ): SMAP {
+        val isLambda = lambdaInfo != null
+
+        // Wrapping for preventing marking actual parent codegen as containing reified markers
+        val parentCodegen = FakeMemberCodegen(
+            codegen.parentCodegen, expression, context.parentContext as FieldOwnerContext<*>,
+            if (isLambda)
+                codegen.parentCodegen.className
+            else
+                state.typeMapper.mapImplementationOwner(descriptor).internalName,
+            if (isLambda) emptyList() else additionalInnerClasses,
+            isLambda
+        )
+
+        val strategy = when (expression) {
+            is KtCallableReferenceExpression -> {
+                val resolvedCall = expression.callableReference.getResolvedCallWithAssert(state.bindingContext)
+                val receiverKotlinType = JvmCodegenUtil.getBoundCallableReferenceReceiver(resolvedCall)?.type
+                val receiverType = receiverKotlinType?.let(state.typeMapper::mapType)
+                val boundReceiverJvmKotlinType = receiverType?.let { JvmKotlinType(receiverType, receiverKotlinType) }
+
+                if (isLambda && lambdaInfo!!.isPropertyReference) {
+                    val asmType = state.typeMapper.mapClass(lambdaInfo.classDescriptor)
+                    val info = lambdaInfo.propertyReferenceInfo
+                    PropertyReferenceCodegen.PropertyReferenceGenerationStrategy(
+                        true, info!!.getFunction, info.target, asmType,
+                        boundReceiverJvmKotlinType,
+                        lambdaInfo.functionWithBodyOrCallableReference, state, true
+                    )
+                } else {
+                    FunctionReferenceGenerationStrategy(state, descriptor, resolvedCall, boundReceiverJvmKotlinType, null, true)
+                }
+            }
+            is KtFunctionLiteral -> ClosureGenerationStrategy(state, expression as KtDeclarationWithBody)
+            else -> FunctionGenerationStrategy.FunctionDefault(state, expression as KtDeclarationWithBody)
+        }
+
+        FunctionCodegen.generateMethodBody(
+            adapter, descriptor, context, jvmMethodSignature, strategy, parentCodegen, state.jvmDefaultMode,
+            state.languageVersionSettings.isReleaseCoroutines()
+        )
+
+        if (isLambda) {
+            codegen.propagateChildReifiedTypeParametersUsages(parentCodegen.reifiedTypeParametersUsages)
+        }
+
+        return SMAP(parentCodegen.orCreateSourceMapper.resultMappings)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private class FakeMemberCodegen(
+        val delegate: MemberCodegen<*>,
+        declaration: KtElement,
+        codegenContext: FieldOwnerContext<*>,
+        private val className: String,
+        private val parentAsInnerClasses: List<ClassDescriptor>,
+        private val isInlineLambdaCodegen: Boolean
+    ) : MemberCodegen<KtPureElement>(delegate as MemberCodegen<KtPureElement>, declaration, codegenContext) {
+
+        override fun generateDeclaration() {
+            throw IllegalStateException()
+        }
+
+        override fun generateBody() {
+            throw IllegalStateException()
+        }
+
+        override fun generateKotlinMetadataAnnotation() {
+            throw IllegalStateException()
+        }
+
+        override fun getInlineNameGenerator(): NameGenerator {
+            return delegate.inlineNameGenerator
+        }
+
+        override //TODO: obtain name from context
+        fun getClassName(): String {
+            return className
+        }
+
+        override fun addParentsToInnerClassesIfNeeded(innerClasses: MutableCollection<ClassDescriptor>) {
+            if (isInlineLambdaCodegen) {
+                super.addParentsToInnerClassesIfNeeded(innerClasses)
+            } else {
+                innerClasses.addAll(parentAsInnerClasses)
+            }
+        }
+
+        override fun generateAssertField() {
+            delegate.generateAssertField()
+        }
+    }
+
+    private fun getDirectMemberAndCallableFromObject(): CallableMemberDescriptor {
+        val directMember = JvmCodegenUtil.getDirectMember(functionDescriptor)
+        return (directMember as? ImportedFromObjectCallableDescriptor<*>)?.callableFromObject ?: directMember
+    }
+
+    internal var callDefault: Boolean = false
+
+    private fun mapDefault(): Method {
+        // This is all available in the `Callable` passed to `PsiInlineCodegen.genCallInner`, but it's not forwarded through the inliner...
+        var result = state.typeMapper.mapDefaultMethod(functionDescriptor, context.contextKind)
+        if (result.name.contains("-") &&
+            !state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) &&
+            classFileContainsMethod(functionDescriptor, state, result) == false
+        ) {
+            state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = true
+            result = state.typeMapper.mapDefaultMethod(functionDescriptor, context.contextKind)
+            state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = false
+        }
+        return result
+    }
+
+    override fun compileInlineFunction(jvmSignature: JvmMethodSignature): SMAPAndMethodNode {
+        generateInlineIntrinsic(state.languageVersionSettings, functionDescriptor, jvmSignature.asmMethod, codegen.typeSystem)?.let {
+            return it
+        }
+
+        val asmMethod = if (callDefault) mapDefault() else jvmSignature.asmMethod
+        if (asmMethod.name != functionDescriptor.name.asString()) {
+            KotlinLookupLocation(callElement).location?.let {
+                state.trackLookup(DescriptorUtils.getFqNameSafe(functionDescriptor.containingDeclaration), asmMethod.name, it)
+            }
+        }
+
+        val directMember = getDirectMemberAndCallableFromObject()
+        if (directMember is DescriptorWithContainerSource) {
+            val containerId = KotlinTypeMapper.getContainingClassesForDeserializedCallable(directMember).implClassId
+            val isMangled = requiresFunctionNameManglingForReturnType(functionDescriptor)
+            return loadCompiledInlineFunction(containerId, asmMethod, functionDescriptor.isSuspend, isMangled, state)
+        }
+
+        val element = DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor) as? KtDeclarationWithBody
+            ?: throw IllegalStateException("Couldn't find declaration for function $functionDescriptor")
+
+        val node = MethodNode(
+            Opcodes.API_VERSION,
+            DescriptorAsmUtil.getMethodAsmFlags(functionDescriptor, context.contextKind, state) or
+                    if (callDefault) Opcodes.ACC_STATIC else 0,
+            asmMethod.name,
+            asmMethod.descriptor, null, null
+        )
+
+        //for maxLocals calculation
+        val maxCalcAdapter = wrapWithMaxLocalCalc(node)
+        val smap = if (callDefault) {
+            val implementationOwner = state.typeMapper.mapImplementationOwner(functionDescriptor)
+            val parentCodegen = FakeMemberCodegen(
+                codegen.parentCodegen, element, context.parentContext as FieldOwnerContext<*>,
+                implementationOwner.internalName,
+                additionalInnerClasses,
+                false
+            )
+            if (element !is KtNamedFunction) {
+                throw IllegalStateException("Property accessors with default parameters not supported $functionDescriptor")
+            }
+            FunctionCodegen.generateDefaultImplBody(
+                context, functionDescriptor, maxCalcAdapter, DefaultParameterValueLoader.DEFAULT,
+                element as KtNamedFunction?, parentCodegen, asmMethod
+            )
+            SMAP(parentCodegen.orCreateSourceMapper.resultMappings)
+        } else {
+            generateMethodBody(maxCalcAdapter, functionDescriptor, context, element, jvmSignature, null)
+        }
+        maxCalcAdapter.visitMaxs(-1, -1)
+        maxCalcAdapter.visitEnd()
+
+        return SMAPAndMethodNode(node, smap)
+    }
+
+    override fun hasFinallyBlocks() = codegen.hasFinallyBlocks()
+
+    override fun generateFinallyBlocks(finallyNode: MethodNode, curFinallyDepth: Int, returnType: Type, afterReturnLabel: Label, target: Label?) {
+        // TODO use the target label for non-local break/continue
+        ExpressionCodegen(
+            finallyNode, codegen.frameMap, codegen.returnType,
+            codegen.getContext(), codegen.state, codegen.parentCodegen
+        ).also {
+            it.addBlockStackElementsForNonLocalReturns(codegen.blockStackElements, curFinallyDepth)
+        }.generateFinallyBlocksIfNeeded(returnType, null, afterReturnLabel)
+    }
+
+    override val isCallInsideSameModuleAsCallee: Boolean
+        get() = JvmCodegenUtil.isCallInsideSameModuleAsDeclared(functionDescriptor, codegen.getContext(), codegen.state.outDirectory)
+
+    override val isFinallyMarkerRequired: Boolean
+        get() = isFinallyMarkerRequired(codegen.getContext())
+
+    override fun isSuspendLambdaCapturedByOuterObjectOrLambda(name: String): Boolean {
+        // We cannot find the lambda in captured parameters: it came from object outside of the our reach:
+        // this can happen when the lambda capture by non-transformed closure:
+        //   inline fun inlineMe(crossinline c: suspend() -> Unit) = suspend { c() }
+        //   inline fun inlineMe2(crossinline c: suspend() -> Unit) = suspend { inlineMe { c() }() }
+        // Suppose, we inline inlineMe into inlineMe2: the only knowledge we have about inlineMe$1 is captured receiver (this$0)
+        // Thus, transformed lambda from inlineMe, inlineMe3$$inlined$inlineMe2$1 contains the following bytecode
+        //   ALOAD 0
+        //   GETFIELD inlineMe2$1$invokeSuspend$$inlined$inlineMe$1.this$0 : LScratchKt$inlineMe2$1;
+        //   GETFIELD inlineMe2$1.$c : Lkotlin/jvm/functions/Function1;
+        // Since inlineMe2's lambda is outside of reach of the inliner, find crossinline parameter from compilation context:
+        var container: DeclarationDescriptor = codegen.getContext().functionDescriptor
+        while (container !is ClassDescriptor) {
+            container = container.containingDeclaration ?: return false
+        }
+        var classDescriptor: ClassDescriptor? = container
+        while (classDescriptor != null) {
+            val closure = state.bindingContext[CodegenBinding.CLOSURE, classDescriptor] ?: return false
+            for ((param, value) in closure.captureVariables) {
+                if (param is ValueParameterDescriptor && value.fieldName == name) {
+                    return param.type.isSuspendFunctionTypeOrSubtype
+                }
+            }
+            classDescriptor = closure.capturedOuterClassDescriptor
+        }
+        return false
+    }
+
+    override fun getContextLabels(): Map<String, Label?> {
+        val context = codegen.getContext()
+        val parentContext = context.parentContext
+        val descriptor = if (parentContext is ClosureContext && parentContext.originalSuspendLambdaDescriptor != null) {
+            parentContext.originalSuspendLambdaDescriptor!!
+        } else context.contextDescriptor
+
+        val labels = getDeclarationLabels(DescriptorToSourceUtils.descriptorToDeclaration(descriptor), descriptor)
+        return labels.associateWith { null } // TODO add break/continue labels
+    }
+
+    override fun reportSuspensionPointInsideMonitor(stackTraceElement: String) {
+        org.jetbrains.kotlin.codegen.coroutines.reportSuspensionPointInsideMonitor(callElement, state, stackTraceElement)
+    }
+
+    companion object {
+        fun getContext(
+            descriptor: DeclarationDescriptor,
+            innerDescriptor: DeclarationDescriptor,
+            state: GenerationState,
+            sourceFile: KtFile?,
+            additionalInners: MutableList<ClassDescriptor>
+        ): CodegenContext<*> {
+            if (descriptor is PackageFragmentDescriptor) {
+                //no inners
+                return PackageContext(descriptor, state.rootContext, null, sourceFile)
+            }
+
+            val container = descriptor.containingDeclaration ?: error("No container for descriptor: $descriptor")
+            val containerContext = getContext(
+                container,
+                descriptor,
+                state,
+                sourceFile,
+                additionalInners
+            )
+
+            return when (descriptor) {
+                is ScriptDescriptor -> {
+                    val earlierScripts = state.scriptSpecific.earlierScriptsForReplInterpreter
+                    containerContext.intoScript(
+                        descriptor,
+                        earlierScripts ?: emptyList(),
+                        descriptor as ClassDescriptor, state.typeMapper
+                    )
+                }
+                is ClassDescriptor -> {
+                    val kind =
+                        when {
+                            DescriptorUtils.isInterface(descriptor) &&
+                                    innerDescriptor !is ClassDescriptor &&
+                                    !innerDescriptor.isCallableMemberCompiledToJvmDefault(state.jvmDefaultMode) ->
+                                OwnerKind.DEFAULT_IMPLS
+                            else ->
+                                OwnerKind.IMPLEMENTATION
+                        }
+
+                    additionalInners.addIfNotNull(
+                        InnerClassConsumer.classForInnerClassRecord(descriptor, kind == OwnerKind.DEFAULT_IMPLS)
+                    )
+
+                    if (descriptor.isInlineClass()) {
+                        containerContext.intoClass(descriptor, OwnerKind.IMPLEMENTATION, state)
+                            .intoClass(descriptor, OwnerKind.ERASED_INLINE_CLASS, state)
+                    } else {
+                        containerContext.intoClass(descriptor, kind, state)
+                    }
+                }
+                is FunctionDescriptor -> {
+                    containerContext.intoFunction(descriptor)
+                }
+                else -> {
+                    throw IllegalStateException("Couldn't build context for $descriptor")
+                }
+            }
+
+        }
+    }
+}
+
+fun DeclarationDescriptor.isInlineOrInsideInline(): Boolean =
+    if (this is FunctionDescriptor && isInline) true
+    else containingDeclaration?.isInlineOrInsideInline() == true
+
+fun getDeclarationLabels(lambdaOrFun: PsiElement?, descriptor: DeclarationDescriptor): Set<String> {
+    val result = HashSet<String>()
+
+    if (lambdaOrFun != null) {
+        val label = LabelResolver.getLabelNameIfAny(lambdaOrFun)
+        if (label != null) {
+            result.add(label.asString())
+        }
+    }
+
+    if (!ExpressionTypingUtils.isFunctionLiteral(descriptor)) {
+        if (!descriptor.name.isSpecial) {
+            result.add(descriptor.name.asString())
+        }
+        result.add(FIRST_FUN_LABEL)
+    }
+    return result
+}

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

@@ -20,9 +20,11 @@ import org.jetbrains.kotlin.codegen.generateAsCast
 import org.jetbrains.kotlin.codegen.generateIsCheck
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods
 import org.jetbrains.kotlin.codegen.optimization.common.intConstant
+import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -63,11 +65,18 @@ class ReifiedTypeInliner<KT : KotlinTypeMarker>(
     }
 
     interface IntrinsicsSupport<KT : KotlinTypeMarker> {
+        val state: GenerationState
+
         fun putClassInstance(v: InstructionAdapter, type: KT)
 
         fun generateTypeParameterContainer(v: InstructionAdapter, typeParameter: TypeParameterMarker)
 
+        fun isMutableCollectionType(type: KT): Boolean
+
         fun toKotlinType(type: KT): KotlinType
+
+        fun reportSuspendTypeUnsupported()
+        fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name)
     }
 
     companion object {

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

@@ -6,428 +6,109 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.backend.common.CodegenUtil
-import org.jetbrains.kotlin.codegen.*
-import org.jetbrains.kotlin.codegen.context.*
-import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.isReleaseCoroutines
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.incremental.KotlinLookupLocation
-import org.jetbrains.kotlin.incremental.components.LookupLocation
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
-import org.jetbrains.kotlin.resolve.isInlineClass
-import org.jetbrains.kotlin.resolve.jvm.annotations.isCallableMemberCompiledToJvmDefault
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.incremental.components.LocationInfo
+import org.jetbrains.kotlin.incremental.components.Position
+import org.jetbrains.kotlin.incremental.components.ScopeKind
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.org.objectweb.asm.Label
-import org.jetbrains.org.objectweb.asm.MethodVisitor
-import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import kotlin.properties.Delegates
+
+class InlineCallSiteInfo(
+    val ownerClassName: String,
+    val method: Method,
+    val isInlineOrInsideInline: Boolean,
+    val file: PsiFile?,
+    val lineNumber: Int
+)
 
 interface SourceCompilerForInline {
     val state: GenerationState
 
     val callElement: Any
 
-    val lookupLocation: LookupLocation
-
     val callElementText: String
 
-    val callsiteFile: PsiFile?
-
-    val contextKind: OwnerKind
-
     val inlineCallSiteInfo: InlineCallSiteInfo
 
-    val lazySourceMapper: SourceMapper
+    val sourceMapper: SourceMapper
 
     fun generateLambdaBody(lambdaInfo: ExpressionLambda, reifiedTypeParameters: ReifiedTypeParametersUsages): SMAPAndMethodNode
 
-    fun doCreateMethodNodeFromSource(
-        callableDescriptor: FunctionDescriptor,
-        jvmSignature: JvmMethodSignature,
-        callDefault: Boolean,
-        asmMethod: Method
-    ): SMAPAndMethodNode
+    fun compileInlineFunction(jvmSignature: JvmMethodSignature): SMAPAndMethodNode
 
     fun hasFinallyBlocks(): Boolean
 
-    fun createCodegenForExternalFinallyBlockGenerationOnNonLocalReturn(
-        finallyNode: MethodNode,
-        curFinallyDepth: Int
-    ): BaseExpressionCodegen
+    fun generateFinallyBlocks(finallyNode: MethodNode, curFinallyDepth: Int, returnType: Type, afterReturnLabel: Label, target: Label?)
 
-    fun generateFinallyBlocksIfNeeded(codegen: BaseExpressionCodegen, returnType: Type, afterReturnLabel: Label, target: Label?)
+    val isCallInsideSameModuleAsCallee: Boolean
 
-    fun isCallInsideSameModuleAsDeclared(functionDescriptor: FunctionDescriptor): Boolean
+    val isFinallyMarkerRequired: Boolean
 
-    fun isFinallyMarkerRequired(): Boolean
-
-    val compilationContextDescriptor: DeclarationDescriptor
-
-    val compilationContextFunctionDescriptor: FunctionDescriptor
+    fun isSuspendLambdaCapturedByOuterObjectOrLambda(name: String): Boolean
 
     fun getContextLabels(): Map<String, Label?>
 
     fun reportSuspensionPointInsideMonitor(stackTraceElement: String)
 }
 
-
-class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, override val callElement: KtElement) :
-    SourceCompilerForInline {
-
-    override val state = codegen.state
-
-    private var context by Delegates.notNull<CodegenContext<*>>()
-
-    private var additionalInnerClasses = mutableListOf<ClassDescriptor>()
-
-    override val lookupLocation = KotlinLookupLocation(callElement)
-
-
-    override val callElementText: String by lazy {
-        callElement.text
-    }
-
-    override val callsiteFile by lazy {
-        callElement.containingFile
-    }
-
-    override val contextKind
-        get () = context.contextKind
-
-    override val inlineCallSiteInfo: InlineCallSiteInfo
-        get() {
-            var context = codegen.getContext()
-            var parentCodegen = codegen.parentCodegen
-            while (context is InlineLambdaContext) {
-                val closureContext = context.getParentContext()
-                assert(closureContext is ClosureContext) { "Parent context of inline lambda should be closure context" }
-                assert(closureContext.parentContext is MethodContext) { "Closure context should appear in method context" }
-                context = closureContext.parentContext as MethodContext
-                assert(parentCodegen is FakeMemberCodegen) { "Parent codegen of inlined lambda should be FakeMemberCodegen" }
-                parentCodegen = (parentCodegen as FakeMemberCodegen).delegate
-            }
-
-            val signature = codegen.state.typeMapper.mapSignatureSkipGeneric(context.functionDescriptor, context.contextKind)
-            return InlineCallSiteInfo(
-                parentCodegen.className,
-                signature.asmMethod.name,
-                signature.asmMethod.descriptor,
-                compilationContextFunctionDescriptor.isInlineOrInsideInline(),
-                compilationContextFunctionDescriptor.isSuspend,
-                CodegenUtil.getLineNumberForElement(callElement, false) ?: 0
-            )
-        }
-
-    override val lazySourceMapper
-        get() = codegen.parentCodegen.orCreateSourceMapper
-
-    override fun generateLambdaBody(lambdaInfo: ExpressionLambda, reifiedTypeParameters: ReifiedTypeParametersUsages): SMAPAndMethodNode {
-        lambdaInfo as? PsiExpressionLambda ?: error("TODO")
-        val invokeMethodDescriptor = lambdaInfo.invokeMethodDescriptor
-        val jvmMethodSignature = state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor)
-        val asmMethod = jvmMethodSignature.asmMethod
-        val methodNode = MethodNode(
-            Opcodes.API_VERSION, DescriptorAsmUtil.getMethodAsmFlags(invokeMethodDescriptor, OwnerKind.IMPLEMENTATION, state),
-            asmMethod.name, asmMethod.descriptor, null, null
-        )
-        val adapter = wrapWithMaxLocalCalc(methodNode)
-        val closureContext = when {
-            lambdaInfo.isPropertyReference ->
-                codegen.getContext().intoAnonymousClass(lambdaInfo.classDescriptor, codegen, OwnerKind.IMPLEMENTATION)
-            invokeMethodDescriptor.isSuspend ->
-                codegen.getContext().intoCoroutineClosure(
-                    getOrCreateJvmSuspendFunctionView(invokeMethodDescriptor, state), invokeMethodDescriptor, codegen, state.typeMapper
-                )
-            else -> codegen.getContext().intoClosure(invokeMethodDescriptor, codegen, state.typeMapper)
-        }
-        val context = closureContext.intoInlinedLambda(invokeMethodDescriptor, lambdaInfo.isCrossInline, lambdaInfo.isPropertyReference)
-        val smap = generateMethodBody(
-            adapter, invokeMethodDescriptor, context,
-            lambdaInfo.functionWithBodyOrCallableReference,
-            jvmMethodSignature, lambdaInfo
-        )
-        adapter.visitMaxs(-1, -1)
-        return SMAPAndMethodNode(methodNode, smap)
-    }
-
-    private fun generateMethodBody(
-        adapter: MethodVisitor,
-        descriptor: FunctionDescriptor,
-        context: MethodContext,
-        expression: KtExpression,
-        jvmMethodSignature: JvmMethodSignature,
-        lambdaInfo: PsiExpressionLambda?
-    ): SMAP {
-        val isLambda = lambdaInfo != null
-
-        // Wrapping for preventing marking actual parent codegen as containing reified markers
-        val parentCodegen = FakeMemberCodegen(
-            codegen.parentCodegen, expression, context.parentContext as FieldOwnerContext<*>,
-            if (isLambda)
-                codegen.parentCodegen.className
-            else
-                state.typeMapper.mapImplementationOwner(descriptor).internalName,
-            if (isLambda) emptyList<ClassDescriptor>() else additionalInnerClasses,
-            isLambda
-        )
-
-        val strategy = when (expression) {
-            is KtCallableReferenceExpression -> {
-                val resolvedCall = expression.callableReference.getResolvedCallWithAssert(state.bindingContext)
-                val receiverKotlinType = JvmCodegenUtil.getBoundCallableReferenceReceiver(resolvedCall)?.type
-                val receiverType = receiverKotlinType?.let(state.typeMapper::mapType)
-                val boundReceiverJvmKotlinType = receiverType?.let { JvmKotlinType(receiverType, receiverKotlinType) }
-
-                if (isLambda && lambdaInfo!!.isPropertyReference) {
-                    val asmType = state.typeMapper.mapClass(lambdaInfo.classDescriptor)
-                    val info = lambdaInfo.propertyReferenceInfo
-                    PropertyReferenceCodegen.PropertyReferenceGenerationStrategy(
-                        true, info!!.getFunction, info.target, asmType,
-                        boundReceiverJvmKotlinType,
-                        lambdaInfo.functionWithBodyOrCallableReference, state, true
-                    )
-                } else {
-                    FunctionReferenceGenerationStrategy(state, descriptor, resolvedCall, boundReceiverJvmKotlinType, null, true)
-                }
-            }
-            is KtFunctionLiteral -> ClosureGenerationStrategy(state, expression as KtDeclarationWithBody)
-            else -> FunctionGenerationStrategy.FunctionDefault(state, expression as KtDeclarationWithBody)
-        }
-
-        FunctionCodegen.generateMethodBody(
-            adapter, descriptor, context, jvmMethodSignature, strategy, parentCodegen, state.jvmDefaultMode,
-            state.languageVersionSettings.isReleaseCoroutines()
-        )
-
-        if (isLambda) {
-            codegen.propagateChildReifiedTypeParametersUsages(parentCodegen.reifiedTypeParametersUsages)
-        }
-
-        return SMAP(parentCodegen.orCreateSourceMapper.resultMappings)
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    private class FakeMemberCodegen(
-        internal val delegate: MemberCodegen<*>,
-        declaration: KtElement,
-        codegenContext: FieldOwnerContext<*>,
-        private val className: String,
-        private val parentAsInnerClasses: List<ClassDescriptor>,
-        private val isInlineLambdaCodegen: Boolean
-    ) : MemberCodegen<KtPureElement>(delegate as MemberCodegen<KtPureElement>, declaration, codegenContext) {
-
-        override fun generateDeclaration() {
-            throw IllegalStateException()
-        }
-
-        override fun generateBody() {
-            throw IllegalStateException()
-        }
-
-        override fun generateKotlinMetadataAnnotation() {
-            throw IllegalStateException()
-        }
-
-        override fun getInlineNameGenerator(): NameGenerator {
-            return delegate.inlineNameGenerator
-        }
-
-        override //TODO: obtain name from context
-        fun getClassName(): String {
-            return className
-        }
-
-        override fun addParentsToInnerClassesIfNeeded(innerClasses: MutableCollection<ClassDescriptor>) {
-            if (isInlineLambdaCodegen) {
-                super.addParentsToInnerClassesIfNeeded(innerClasses)
-            } else {
-                innerClasses.addAll(parentAsInnerClasses)
-            }
-        }
-
-        override fun generateAssertField() {
-            delegate.generateAssertField()
-        }
-    }
-
-    override fun doCreateMethodNodeFromSource(
-        callableDescriptor: FunctionDescriptor,
-        jvmSignature: JvmMethodSignature,
-        callDefault: Boolean,
-        asmMethod: Method
-    ): SMAPAndMethodNode {
-        val element = DescriptorToSourceUtils.descriptorToDeclaration(callableDescriptor)
-
-        if (!(element is KtNamedFunction || element is KtPropertyAccessor)) {
-            throw IllegalStateException("Couldn't find declaration for function $callableDescriptor")
-        }
-        val inliningFunction = element as KtDeclarationWithBody?
-
-        val node = MethodNode(
-            Opcodes.API_VERSION,
-            DescriptorAsmUtil.getMethodAsmFlags(callableDescriptor, context.contextKind, state) or if (callDefault) Opcodes.ACC_STATIC else 0,
-            asmMethod.name,
-            asmMethod.descriptor, null, null
-        )
-
-        //for maxLocals calculation
-        val maxCalcAdapter = wrapWithMaxLocalCalc(node)
-        val parentContext = context.parentContext ?: error("Context has no parent: " + context)
-        val methodContext = parentContext.intoFunction(callableDescriptor)
-
-        val smap = if (callDefault) {
-            val implementationOwner = state.typeMapper.mapImplementationOwner(callableDescriptor)
-            val parentCodegen = FakeMemberCodegen(
-                codegen.parentCodegen, inliningFunction!!, methodContext.parentContext as FieldOwnerContext<*>,
-                implementationOwner.internalName,
-                additionalInnerClasses,
-                false
-            )
-            if (element !is KtNamedFunction) {
-                throw IllegalStateException("Property accessors with default parameters not supported $callableDescriptor")
-            }
-            FunctionCodegen.generateDefaultImplBody(
-                methodContext, callableDescriptor, maxCalcAdapter, DefaultParameterValueLoader.DEFAULT,
-                inliningFunction as KtNamedFunction?, parentCodegen, asmMethod
-            )
-            SMAP(parentCodegen.orCreateSourceMapper.resultMappings)
-        } else {
-            generateMethodBody(maxCalcAdapter, callableDescriptor, methodContext, inliningFunction!!, jvmSignature, null)
-        }
-        maxCalcAdapter.visitMaxs(-1, -1)
-        maxCalcAdapter.visitEnd()
-
-        return SMAPAndMethodNode(node, smap)
-    }
-
-    override fun hasFinallyBlocks() = codegen.hasFinallyBlocks()
-
-    override fun generateFinallyBlocksIfNeeded(codegen: BaseExpressionCodegen, returnType: Type, afterReturnLabel: Label, target: Label?) {
-        // TODO use the target label for non-local break/continue
-        require(codegen is ExpressionCodegen)
-        codegen.generateFinallyBlocksIfNeeded(returnType, null, afterReturnLabel)
-    }
-
-    override fun createCodegenForExternalFinallyBlockGenerationOnNonLocalReturn(finallyNode: MethodNode, curFinallyDepth: Int) =
-        ExpressionCodegen(
-            finallyNode, codegen.frameMap, codegen.returnType,
-            codegen.getContext(), codegen.state, codegen.parentCodegen
-        ).also {
-            it.addBlockStackElementsForNonLocalReturns(codegen.blockStackElements, curFinallyDepth)
-        }
-
-    override fun isCallInsideSameModuleAsDeclared(functionDescriptor: FunctionDescriptor): Boolean {
-        return JvmCodegenUtil.isCallInsideSameModuleAsDeclared(functionDescriptor, codegen.getContext(), codegen.state.outDirectory)
-    }
-
-    override fun isFinallyMarkerRequired(): Boolean = isFinallyMarkerRequired(codegen.getContext())
-
-
-    override val compilationContextDescriptor
-        get() = codegen.getContext().contextDescriptor
-
-    override val compilationContextFunctionDescriptor
-        get() = codegen.getContext().functionDescriptor
-
-    override fun getContextLabels(): Map<String, Label?> {
-        val context = codegen.getContext()
-        val parentContext = context.parentContext
-        val descriptor = if (parentContext is ClosureContext && parentContext.originalSuspendLambdaDescriptor != null) {
-            parentContext.originalSuspendLambdaDescriptor!!
-        } else context.contextDescriptor
-
-        val labels = InlineCodegen.getDeclarationLabels(DescriptorToSourceUtils.descriptorToDeclaration(descriptor), descriptor)
-        return labels.associateWith { null } // TODO add break/continue labels
-    }
-
-    fun initializeInlineFunctionContext(functionDescriptor: FunctionDescriptor) {
-        context = getContext(
-            functionDescriptor,
-            functionDescriptor,
-            state,
-            DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor)?.containingFile as? KtFile,
-            additionalInnerClasses
-        )
-    }
-
-    override fun reportSuspensionPointInsideMonitor(stackTraceElement: String) {
-        org.jetbrains.kotlin.codegen.coroutines.reportSuspensionPointInsideMonitor(callElement, state, stackTraceElement)
-    }
-
-    companion object {
-        fun getContext(
-            descriptor: DeclarationDescriptor,
-            innerDescriptor: DeclarationDescriptor,
-            state: GenerationState,
-            sourceFile: KtFile?,
-            additionalInners: MutableList<ClassDescriptor>
-        ): CodegenContext<*> {
-            if (descriptor is PackageFragmentDescriptor) {
-                //no inners
-                return PackageContext(descriptor, state.rootContext, null, sourceFile)
-            }
-
-            val container = descriptor.containingDeclaration ?: error("No container for descriptor: $descriptor")
-            val containerContext = getContext(
-                container,
-                descriptor,
-                state,
-                sourceFile,
-                additionalInners
-            )
-
-            return when (descriptor) {
-                is ScriptDescriptor -> {
-                    val earlierScripts = state.scriptSpecific.earlierScriptsForReplInterpreter
-                    containerContext.intoScript(
-                        descriptor,
-                        earlierScripts ?: emptyList(),
-                        descriptor as ClassDescriptor, state.typeMapper
-                    )
-                }
-                is ClassDescriptor -> {
-                    val kind =
-                        when {
-                            DescriptorUtils.isInterface(descriptor) &&
-                                    innerDescriptor !is ClassDescriptor &&
-                                    !innerDescriptor.isCallableMemberCompiledToJvmDefault(state.jvmDefaultMode) ->
-                                OwnerKind.DEFAULT_IMPLS
-                            else ->
-                                OwnerKind.IMPLEMENTATION
-                        }
-
-                    additionalInners.addIfNotNull(
-                        InnerClassConsumer.classForInnerClassRecord(descriptor, kind == OwnerKind.DEFAULT_IMPLS)
-                    )
-
-                    if (descriptor.isInlineClass()) {
-                        containerContext.intoClass(descriptor, OwnerKind.IMPLEMENTATION, state)
-                            .intoClass(descriptor, OwnerKind.ERASED_INLINE_CLASS, state)
-                    } else {
-                        containerContext.intoClass(descriptor, kind, state)
-                    }
-                }
-                is FunctionDescriptor -> {
-                    containerContext.intoFunction(descriptor)
-                }
-                else -> {
-                    throw IllegalStateException("Couldn't build context for $descriptor")
-                }
-            }
-
-        }
-    }
+fun GenerationState.trackLookup(container: FqName, functionName: String, location: LocationInfo) {
+    val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: return
+    lookupTracker.record(
+        location.filePath,
+        if (lookupTracker.requiresPosition) location.position else Position.NO_POSITION,
+        container.asString(),
+        ScopeKind.CLASSIFIER,
+        functionName
+    )
 }
 
-fun DeclarationDescriptor.isInlineOrInsideInline(): Boolean =
-    if (this is FunctionDescriptor && isInline) true
-    else containingDeclaration?.isInlineOrInsideInline() == true
+fun loadCompiledInlineFunction(
+    containerId: ClassId,
+    asmMethod: Method,
+    isSuspend: Boolean,
+    isMangled: Boolean,
+    state: GenerationState
+): SMAPAndMethodNode {
+    val containerType = AsmUtil.asmTypeByClassId(containerId)
+    val resultInCache = state.inlineCache.methodNodeById.getOrPut(MethodId(containerType.descriptor, asmMethod)) {
+        val bytes = state.inlineCache.classBytes.getOrPut(containerType.internalName) {
+            findVirtualFile(state, containerId)?.contentsToByteArray()
+                ?: throw IllegalStateException("Couldn't find declaration file for $containerId")
+        }
+        getMethodNode(containerType, bytes, asmMethod, isSuspend, isMangled)
+    }
+    return SMAPAndMethodNode(cloneMethodNode(resultInCache.node), resultInCache.classSMAP)
+}
+
+private fun getMethodNode(
+    owner: Type,
+    bytes: ByteArray,
+    method: Method,
+    isSuspend: Boolean,
+    isMangled: Boolean
+): SMAPAndMethodNode {
+    getMethodNode(owner, bytes, method, isSuspend)?.let { return it }
+    if (isMangled) {
+        // Compatibility with old inline class ABI versions.
+        val dashIndex = method.name.indexOf('-')
+        val nameWithoutManglingSuffix = if (dashIndex > 0) method.name.substring(0, dashIndex) else method.name
+        if (nameWithoutManglingSuffix != method.name) {
+            getMethodNode(owner, bytes, Method(nameWithoutManglingSuffix, method.descriptor), isSuspend)?.let { return it }
+        }
+        getMethodNode(owner, bytes, Method("$nameWithoutManglingSuffix-impl", method.descriptor), isSuspend)?.let { return it }
+    }
+    throw IllegalStateException("couldn't find inline method $owner.$method")
+}
+
+// If an `inline suspend fun` has a state machine, it should have a `$$forInline` version without one.
+private fun getMethodNode(owner: Type, bytes: ByteArray, method: Method, isSuspend: Boolean) =
+    (if (isSuspend) getMethodNode(bytes, owner, Method(method.name + FOR_INLINE_SUFFIX, method.descriptor)) else null)
+        ?: getMethodNode(bytes, owner, method)

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

@@ -6,18 +6,13 @@
 package org.jetbrains.kotlin.codegen.inline.coroutines
 
 import com.intellij.util.ArrayUtil
-import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
 import org.jetbrains.kotlin.codegen.ClassBuilder
-import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.coroutines.*
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.isReleaseCoroutines
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.org.objectweb.asm.MethodVisitor
@@ -96,8 +91,8 @@ class CoroutineTransformer(
                 obtainClassBuilderForCoroutineState = { classBuilder },
                 reportSuspensionPointInsideMonitor = { sourceCompilerForInline.reportSuspensionPointInsideMonitor(it) },
                 // TODO: this linenumbers might not be correct and since they are used only for step-over, check them.
-                lineNumber = sourceCompilerForInline.inlineCallSiteInfo.lineNumber,
-                sourceFile = sourceCompilerForInline.callsiteFile?.name ?: "",
+                lineNumber = inliningContext.callSiteInfo.lineNumber,
+                sourceFile = inliningContext.callSiteInfo.file?.name ?: "",
                 languageVersionSettings = state.languageVersionSettings,
                 shouldPreserveClassInitialization = state.constructorCallNormalizationMode.shouldPreserveClassInitialization,
                 containingClassInternalName = classBuilder.thisName,
@@ -130,8 +125,8 @@ class CoroutineTransformer(
                 createNewMethodFrom(node, name), node.access, name, node.desc, null, null,
                 obtainClassBuilderForCoroutineState = { (inliningContext as RegeneratedClassContext).continuationBuilders[continuationClassName]!! },
                 reportSuspensionPointInsideMonitor = { sourceCompilerForInline.reportSuspensionPointInsideMonitor(it) },
-                lineNumber = sourceCompilerForInline.inlineCallSiteInfo.lineNumber,
-                sourceFile = sourceCompilerForInline.callsiteFile?.name ?: "",
+                lineNumber = inliningContext.callSiteInfo.lineNumber,
+                sourceFile = inliningContext.callSiteInfo.file?.name ?: "",
                 languageVersionSettings = state.languageVersionSettings,
                 shouldPreserveClassInitialization = state.constructorCallNormalizationMode.shouldPreserveClassInitialization,
                 containingClassInternalName = classBuilder.thisName,
@@ -238,35 +233,6 @@ fun surroundInvokesWithSuspendMarkersIfNeeded(node: MethodNode) {
     }
 }
 
-// We cannot find the lambda in captured parameters: it came from object outside of the our reach:
-// this can happen when the lambda capture by non-transformed closure:
-//   inline fun inlineMe(crossinline c: suspend() -> Unit) = suspend { c() }
-//   inline fun inlineMe2(crossinline c: suspend() -> Unit) = suspend { inlineMe { c() }() }
-// Suppose, we inline inlineMe into inlineMe2: the only knowledge we have about inlineMe$1 is captured receiver (this$0)
-// Thus, transformed lambda from inlineMe, inlineMe3$$inlined$inlineMe2$1 contains the following bytecode
-//   ALOAD 0
-//   GETFIELD inlineMe2$1$invokeSuspend$$inlined$inlineMe$1.this$0 : LScratchKt$inlineMe2$1;
-//   GETFIELD inlineMe2$1.$c : Lkotlin/jvm/functions/Function1;
-// Since inlineMe2's lambda is outside of reach of the inliner, find crossinline parameter from compilation context:
-fun FieldInsnNode.isSuspendLambdaCapturedByOuterObjectOrLambda(inliningContext: InliningContext): Boolean {
-    var container: DeclarationDescriptor = inliningContext.root.sourceCompilerForInline.compilationContextFunctionDescriptor
-    while (container !is ClassDescriptor) {
-        container = container.containingDeclaration ?: return false
-    }
-    val bindingContext = inliningContext.state.bindingContext
-    var classDescriptor: ClassDescriptor? = container
-    while (classDescriptor != null) {
-        val closure = bindingContext[CodegenBinding.CLOSURE, classDescriptor] ?: return false
-        for ((param, value) in closure.captureVariables) {
-            if (param is ValueParameterDescriptor && value.fieldName == name) {
-                return param.type.isSuspendFunctionTypeOrSubtype
-            }
-        }
-        classDescriptor = closure.capturedOuterClassDescriptor
-    }
-    return false
-}
-
 // Interpreter, that keeps track of captured functional arguments
 private class PossibleLambdaLoad(val insn: AbstractInsnNode) : BasicValue(AsmTypes.OBJECT_TYPE)
 

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

@@ -16,20 +16,16 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
-import org.jetbrains.kotlin.codegen.DescriptorAsmUtil
-import org.jetbrains.kotlin.codegen.OwnerKind
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner.Companion.isNeedClassReificationMarker
 import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.inline.InlineUtil
-import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind
-import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.*
+import kotlin.math.max
 
 private data class Condition(
     val mask: Int, val constant: Int,
@@ -41,34 +37,15 @@ private data class Condition(
     val varIndex = varInsNode?.`var` ?: 0
 }
 
-fun extractDefaultLambdaOffsetAndDescriptor(
-    jvmSignature: JvmMethodSignature,
-    functionDescriptor: FunctionDescriptor
-): Map<Int, ValueParameterDescriptor> {
-    val valueParameters = jvmSignature.valueParameters
-    val containingDeclaration = functionDescriptor.containingDeclaration
-    val kind =
-        if (DescriptorUtils.isInterface(containingDeclaration)) OwnerKind.DEFAULT_IMPLS
-        else OwnerKind.getMemberOwnerKind(containingDeclaration)
-    val parameterOffsets = parameterOffsets(DescriptorAsmUtil.isStaticMethod(kind, functionDescriptor), valueParameters)
-    val valueParameterOffset = valueParameters.takeWhile { it.kind != JvmMethodParameterKind.VALUE }.size
+class ExtractedDefaultLambda(val type: Type, val capturedArgs: Array<Type>, val offset: Int, val needReification: Boolean)
 
-    return functionDescriptor.valueParameters.filter {
-        InlineUtil.isInlineParameter(it) && it.declaresDefaultValue()
-    }.associateBy {
-        parameterOffsets[valueParameterOffset + it.index]
-    }
-}
-
-
-fun <T, R : DefaultLambda> expandMaskConditionsAndUpdateVariableNodes(
+fun expandMaskConditionsAndUpdateVariableNodes(
     node: MethodNode,
     maskStartIndex: Int,
     masks: List<Int>,
     methodHandlerIndex: Int,
-    defaultLambdas: Map<Int, T>,
-    lambdaConstructor: (Type, Array<Type>, T, Int, Boolean) -> R
-): List<R> {
+    validOffsets: Collection<Int>
+): List<ExtractedDefaultLambda> {
     fun isMaskIndex(varIndex: Int): Boolean {
         return maskStartIndex <= varIndex && varIndex < maskStartIndex + masks.size
     }
@@ -111,7 +88,8 @@ fun <T, R : DefaultLambda> expandMaskConditionsAndUpdateVariableNodes(
     val toDelete = linkedSetOf<AbstractInsnNode>()
     val toInsert = arrayListOf<Pair<AbstractInsnNode, AbstractInsnNode>>()
 
-    val defaultLambdasInfo = extractDefaultLambdasInfo(conditions, defaultLambdas, toDelete, toInsert, lambdaConstructor)
+    val extractable = conditions.filter { it.expandNotDelete && it.varIndex in validOffsets }
+    val defaultLambdasInfo = extractDefaultLambdasInfo(extractable, toDelete, toInsert)
 
     val indexToVarNode = node.localVariables?.filter { it.index < maskStartIndex }?.associateBy { it.index } ?: emptyMap()
     conditions.forEach {
@@ -131,7 +109,7 @@ fun <T, R : DefaultLambda> expandMaskConditionsAndUpdateVariableNodes(
     }
 
     node.localVariables.removeIf {
-        (it.start in toDelete && it.end in toDelete) || defaultLambdas.contains(it.index)
+        (it.start in toDelete && it.end in toDelete) || validOffsets.contains(it.index)
     }
 
     node.remove(toDelete)
@@ -139,16 +117,12 @@ fun <T, R : DefaultLambda> expandMaskConditionsAndUpdateVariableNodes(
     return defaultLambdasInfo
 }
 
-
-private fun <T, R : DefaultLambda> extractDefaultLambdasInfo(
+private fun extractDefaultLambdasInfo(
     conditions: List<Condition>,
-    defaultLambdas: Map<Int, T>,
     toDelete: MutableCollection<AbstractInsnNode>,
-    toInsert: MutableList<Pair<AbstractInsnNode, AbstractInsnNode>>,
-    lambdaConstructor: (Type, Array<Type>, T, Int, Boolean) -> R
-): List<R> {
-    val defaultLambdaConditions = conditions.filter { it.expandNotDelete && defaultLambdas.contains(it.varIndex) }
-    return defaultLambdaConditions.map {
+    toInsert: MutableList<Pair<AbstractInsnNode, AbstractInsnNode>>
+): List<ExtractedDefaultLambda> {
+    return conditions.map {
         val varAssignmentInstruction = it.varInsNode!!
         var instanceInstuction = varAssignmentInstruction.previous
         if (instanceInstuction is TypeInsnNode && instanceInstuction.opcode == Opcodes.CHECKCAST) {
@@ -190,7 +164,7 @@ private fun <T, R : DefaultLambda> extractDefaultLambdasInfo(
 
         toInsert.add(varAssignmentInstruction to defaultLambdaFakeCallStub(argTypes, it.varIndex))
 
-        lambdaConstructor(owner, argTypes, defaultLambdas[it.varIndex]!!, it.varIndex, needReification)
+        ExtractedDefaultLambda(owner, argTypes, it.varIndex, needReification)
     }
 }
 
@@ -205,3 +179,68 @@ private fun defaultLambdaFakeCallStub(args: Array<Type>, lambdaOffset: Int): Met
         false
     )
 }
+
+fun loadDefaultLambdaBody(classBytes: ByteArray, classType: Type, isPropertyReference: Boolean): SMAPAndMethodNode {
+    // In general we can't know what the correct unboxed `invoke` is, and what Kotlin types its arguments have,
+    // as the type of this object may be any subtype of the parameter's type. All we know is that Function<N>
+    // has to have a `invoke` that takes `Object`s and returns an `Object`; everything else needs to be figured
+    // out from its contents. TODO: for > 22 arguments, the only argument is an array. `MethodInliner` can't do that.
+    val invokeName = if (isPropertyReference) OperatorNameConventions.GET.asString() else OperatorNameConventions.INVOKE.asString()
+    val invokeNode = getMethodNode(classBytes, classType) {
+        it.name == invokeName && it.returnType == AsmTypes.OBJECT_TYPE && it.argumentTypes.all { arg -> arg == AsmTypes.OBJECT_TYPE }
+    } ?: error("can't find erased invoke '$invokeName(Object...): Object' in default lambda '${classType.internalName}'")
+    return if (invokeNode.node.access.and(Opcodes.ACC_BRIDGE) == 0)
+        invokeNode
+    else
+        invokeNode.node.inlineBridge(classBytes, classType)
+}
+
+private fun MethodNode.inlineBridge(classBytes: ByteArray, classType: Type): SMAPAndMethodNode {
+    // If the erased invoke is a bridge, we need to locate the unboxed invoke and inline it. As mentioned above,
+    // we don't know what the Kotlin types of its arguments/returned value are, so we can't generate our own
+    // boxing/unboxing code; luckily, the bridge already has that.
+    val invokeInsn = instructions.singleOrNull { it is MethodInsnNode && it.owner == classType.internalName } as MethodInsnNode?
+        ?: error("no single invoke of method on this in '${name}${desc}' of default lambda '${classType.internalName}'")
+    val targetMethod = Method(invokeInsn.name, invokeInsn.desc)
+    val target = getMethodNode(classBytes, classType, targetMethod)
+        ?: error("can't find non-bridge invoke '$targetMethod' in default lambda '${classType.internalName}")
+
+    // Store unboxed/casted arguments in the correct variable slots
+    val targetArgs = targetMethod.argumentTypes
+    val targetArgsSize = targetArgs.sumOf { it.size } + if (target.node.access.and(Opcodes.ACC_STATIC) == 0) 1 else 0
+    var offset = targetArgsSize
+    for (type in targetArgs.reversed()) {
+        offset -= type.size
+        instructions.insertBefore(invokeInsn, VarInsnNode(type.getOpcode(Opcodes.ISTORE), offset))
+    }
+    if (target.node.access.and(Opcodes.ACC_STATIC) == 0) {
+        instructions.insertBefore(invokeInsn, InsnNode(Opcodes.POP)) // this
+    }
+
+    // Remap returns and ranges for arguments' LVT entries
+    val invokeLabel = LabelNode()
+    val returnLabel = LabelNode()
+    instructions.insertBefore(invokeInsn, invokeLabel)
+    instructions.insert(invokeInsn, returnLabel)
+    for (insn in target.node.instructions) {
+        if (insn.opcode in Opcodes.IRETURN..Opcodes.RETURN) {
+            target.node.instructions.set(insn, JumpInsnNode(Opcodes.GOTO, returnLabel))
+        }
+    }
+    for (local in target.node.localVariables) {
+        if (local.index < targetArgsSize) {
+            local.start = invokeLabel
+            local.end = returnLabel
+        }
+    }
+
+    // Insert contents of the method into the bridge
+    instructions.filterIsInstance<LineNumberNode>().forEach { instructions.remove(it) } // those are not meaningful
+    instructions.insertBefore(invokeInsn, target.node.instructions)
+    instructions.remove(invokeInsn)
+    localVariables = target.node.localVariables
+    tryCatchBlocks = target.node.tryCatchBlocks
+    maxLocals = max(maxLocals, target.node.maxLocals)
+    maxStack = max(maxStack, target.node.maxStack)
+    return SMAPAndMethodNode(this, target.classSMAP)
+}

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

@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.org.objectweb.asm.*
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.*
 import org.jetbrains.org.objectweb.asm.util.Printer
 import org.jetbrains.org.objectweb.asm.util.Textifier
@@ -84,40 +85,18 @@ private const val INLINE_MARKER_AFTER_INLINE_SUSPEND_ID = 7
 private const val INLINE_MARKER_BEFORE_UNBOX_INLINE_CLASS = 8
 private const val INLINE_MARKER_AFTER_UNBOX_INLINE_CLASS = 9
 
-internal fun getMethodNode(
-    classData: ByteArray,
-    methodName: String,
-    methodDescriptor: String,
-    classType: Type,
-    signatureAmbiguity: Boolean = false
-): SMAPAndMethodNode? {
-    val cr = ClassReader(classData)
+internal inline fun getMethodNode(classData: ByteArray, classType: Type, crossinline match: (Method) -> Boolean): SMAPAndMethodNode? {
     var node: MethodNode? = null
-    val debugInfo = arrayOfNulls<String>(2)
-
-    cr.accept(object : ClassVisitor(Opcodes.API_VERSION) {
+    var sourceFile: String? = null
+    var sourceMap: String? = null
+    ClassReader(classData).accept(object : ClassVisitor(Opcodes.API_VERSION) {
         override fun visitSource(source: String?, debug: String?) {
-            super.visitSource(source, debug)
-            debugInfo[0] = source
-            debugInfo[1] = debug
+            sourceFile = source
+            sourceMap = debug
         }
 
-        override fun visitMethod(
-            access: Int,
-            name: String,
-            desc: String,
-            signature: String?,
-            exceptions: Array<String>?
-        ): MethodVisitor? {
-            if (methodName != name || (signatureAmbiguity && access.and(Opcodes.ACC_SYNTHETIC) != 0)) return null
-
-            if (methodDescriptor != desc) {
-                val sameNumberOfParameters = Type.getArgumentTypes(methodDescriptor).size == Type.getArgumentTypes(desc).size
-                if (!signatureAmbiguity || !sameNumberOfParameters) {
-                    return null
-                }
-            }
-
+        override fun visitMethod(access: Int, name: String, desc: String, signature: String?, exceptions: Array<String>?): MethodVisitor? {
+            if (!match(Method(name, desc))) return null
             node?.let { existing ->
                 throw AssertionError("Can't find proper '$name' method for inline: ambiguity between '${existing.name + existing.desc}' and '${name + desc}'")
             }
@@ -126,15 +105,15 @@ internal fun getMethodNode(
         }
     }, ClassReader.SKIP_FRAMES or if (GENERATE_SMAP) 0 else ClassReader.SKIP_DEBUG)
 
-    if (node == null) {
-        return null
+    return node?.let{
+        val (first, last) = listOfNotNull(it).lineNumberRange()
+        SMAPAndMethodNode(it, SMAPParser.parseOrCreateDefault(sourceMap, sourceFile, classType.internalName, first, last))
     }
-
-    val (first, last) = listOfNotNull(node).lineNumberRange()
-    val smap = SMAPParser.parseOrCreateDefault(debugInfo[1], debugInfo[0], classType.internalName, first, last)
-    return SMAPAndMethodNode(node!!, smap)
 }
 
+internal fun getMethodNode(classData: ByteArray, classType: Type, method: Method): SMAPAndMethodNode? =
+    getMethodNode(classData, classType) { it == method }
+
 internal fun Collection<MethodNode>.lineNumberRange(): Pair<Int, Int> {
     var minLine = Int.MAX_VALUE
     var maxLine = Int.MIN_VALUE
@@ -347,8 +326,42 @@ internal val AbstractInsnNode?.insnText: String
         return sw.toString().trim()
     }
 
+fun AbstractInsnNode?.insnText(insnList: InsnList): String {
+    if (this == null) return "<null>"
+
+    fun AbstractInsnNode.indexOf() =
+        insnList.indexOf(this)
+
+    fun LabelNode.labelText() =
+        "L#${this.indexOf()}"
+
+    return when (this) {
+        is LabelNode ->
+            labelText()
+        is JumpInsnNode ->
+            "$insnOpcodeText ${label.labelText()}"
+        is LookupSwitchInsnNode ->
+            "$insnOpcodeText " +
+                    this.keys.zip(this.labels).joinToString(prefix = "[", postfix = "]") { (key, label) -> "$key:${label.labelText()}" }
+        is TableSwitchInsnNode ->
+            "$insnOpcodeText " +
+                    (min..max).zip(this.labels).joinToString(prefix = "[", postfix = "]") { (key, label) -> "$key:${label.labelText()}" }
+        else ->
+            insnText
+    }
+}
+
 internal val AbstractInsnNode?.insnOpcodeText: String
-    get() = if (this == null) "null" else Printer.OPCODES[opcode]
+    get() = when (this) {
+        null -> "null"
+        is LabelNode -> "LABEL"
+        is LineNumberNode -> "LINENUMBER"
+        is FrameNode -> "FRAME"
+        else -> Printer.OPCODES[opcode]
+    }
+
+internal fun TryCatchBlockNode.text(insns: InsnList): String =
+    "[${insns.indexOf(start)} .. ${insns.indexOf(end)} -> ${insns.indexOf(handler)}]"
 
 internal fun loadClassBytesByInternalName(state: GenerationState, internalName: String): ByteArray {
     //try to find just compiled classes then in dependencies

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

@@ -14,8 +14,9 @@ import org.jetbrains.kotlin.codegen.coroutines.createMethodNodeForCoroutineConte
 import org.jetbrains.kotlin.codegen.coroutines.createMethodNodeForIntercepted
 import org.jetbrains.kotlin.codegen.coroutines.createMethodNodeForSuspendCoroutineUninterceptedOrReturn
 import org.jetbrains.kotlin.codegen.createMethodNodeForAlwaysEnabledAssert
+import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicArrayConstructors
 import org.jetbrains.kotlin.codegen.isBuiltinAlwaysEnabledAssert
-import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.resolve.calls.checkers.TypeOfChecker
@@ -26,31 +27,42 @@ import org.jetbrains.kotlin.types.model.TypeParameterMarker
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
-internal fun generateInlineIntrinsic(
-    state: GenerationState,
-    descriptor: FunctionDescriptor,
-    typeParameters: List<TypeParameterMarker>?,
-    typeSystem: TypeSystemCommonBackendContext
-): MethodNode? {
-    val languageVersionSettings = state.languageVersionSettings
-
-    return when {
-        isSpecialEnumMethod(descriptor) ->
-            createSpecialEnumMethodBody(descriptor.name.asString(), typeParameters!!.single(), typeSystem)
-        TypeOfChecker.isTypeOf(descriptor) ->
-            typeSystem.createTypeOfMethodBody(typeParameters!!.single())
+fun generateInlineIntrinsicForIr(languageVersionSettings: LanguageVersionSettings, descriptor: FunctionDescriptor): SMAPAndMethodNode? =
+    when {
+        // TODO: implement these as codegen intrinsics (see IrIntrinsicMethods)
         descriptor.isBuiltInIntercepted(languageVersionSettings) ->
             createMethodNodeForIntercepted(languageVersionSettings)
         descriptor.isBuiltInCoroutineContext(languageVersionSettings) ->
             createMethodNodeForCoroutineContext(descriptor, languageVersionSettings)
         descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(languageVersionSettings) ->
             createMethodNodeForSuspendCoroutineUninterceptedOrReturn(languageVersionSettings)
+        else -> null
+    }?.let { SMAPAndMethodNode(it, SMAP(listOf())) }
+
+internal fun generateInlineIntrinsic(
+    languageVersionSettings: LanguageVersionSettings,
+    descriptor: FunctionDescriptor,
+    asmMethod: Method,
+    typeSystem: TypeSystemCommonBackendContext
+): SMAPAndMethodNode? {
+    return generateInlineIntrinsicForIr(languageVersionSettings, descriptor) ?: when {
+        isSpecialEnumMethod(descriptor) ->
+            createSpecialEnumMethodBody(descriptor.name.asString(), descriptor.original.typeParameters.single(), typeSystem)
+        TypeOfChecker.isTypeOf(descriptor) ->
+            typeSystem.createTypeOfMethodBody(descriptor.original.typeParameters.single())
         descriptor.isBuiltinAlwaysEnabledAssert() ->
             createMethodNodeForAlwaysEnabledAssert(descriptor)
+        descriptor is FictitiousArrayConstructor ->
+            IntrinsicArrayConstructors.generateArrayConstructorBody(asmMethod)
+        IntrinsicArrayConstructors.isArrayOf(descriptor) ->
+            IntrinsicArrayConstructors.generateArrayOfBody(asmMethod)
+        IntrinsicArrayConstructors.isEmptyArray(descriptor) ->
+            IntrinsicArrayConstructors.generateEmptyArrayBody(asmMethod)
         else -> null
-    }
+    }?.let { SMAPAndMethodNode(it, SMAP(listOf())) }
 }
 
 private fun isSpecialEnumMethod(descriptor: FunctionDescriptor): Boolean {

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
+import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -37,15 +38,15 @@ private fun TypeSystemCommonBackendContext.putTypeOfReifiedTypeParameter(
     v.aconst(null)
 }
 
-internal fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateTypeOf(
+fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateTypeOf(
     v: InstructionAdapter, type: KT, intrinsicsSupport: ReifiedTypeInliner.IntrinsicsSupport<KT>
 ) {
     val typeParameter = type.typeConstructor().getTypeParameterClassifier()
     if (typeParameter != null) {
         if (!doesTypeContainTypeParametersWithRecursiveBounds(type)) {
-            throw UnsupportedOperationException(
-                "Non-reified type parameters with recursive bounds are not supported yet: ${typeParameter.getName()}"
-            )
+            intrinsicsSupport.reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameter.getName())
+            v.aconst(null)
+            return
         }
 
         generateNonReifiedTypeParameter(v, typeParameter, intrinsicsSupport)
@@ -89,6 +90,27 @@ internal fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateType
     }
 
     v.invokestatic(REFLECTION, methodName, signature, false)
+
+    if (intrinsicsSupport.toKotlinType(type).isSuspendFunctionType) {
+        intrinsicsSupport.reportSuspendTypeUnsupported()
+    }
+
+    if (intrinsicsSupport.state.stableTypeOf) {
+        if (intrinsicsSupport.isMutableCollectionType(type)) {
+            v.invokestatic(REFLECTION, "mutableCollectionType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false)
+        } else if (type.typeConstructor().isNothingConstructor()) {
+            v.invokestatic(REFLECTION, "nothingType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false)
+        }
+
+        if (type.isFlexible()) {
+            // If this is a flexible type, we've just generated its lower bound and have it on the stack.
+            // Let's generate the upper bound now and call the method that takes lower and upper bound and constructs a flexible KType.
+            @Suppress("UNCHECKED_CAST")
+            generateTypeOf(v, type.upperBoundIfFlexible() as KT, intrinsicsSupport)
+
+            v.invokestatic(REFLECTION, "platformType", Type.getMethodDescriptor(K_TYPE, K_TYPE, K_TYPE), false)
+        }
+    }
 }
 
 private fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateNonReifiedTypeParameter(
@@ -103,7 +125,7 @@ private fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateNonRe
         TypeVariance.OUT -> KVariance.OUT
     }
     v.getstatic(K_VARIANCE.internalName, variance.name, K_VARIANCE.descriptor)
-    v.aconst(typeParameter.isReified())
+    v.iconst(if (typeParameter.isReified()) 1 else 0)
     v.invokestatic(
         REFLECTION, "typeParameter",
         Type.getMethodDescriptor(K_TYPE_PARAMETER, OBJECT_TYPE, JAVA_STRING_TYPE, K_VARIANCE, Type.BOOLEAN_TYPE),
@@ -119,11 +141,11 @@ private fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateNonRe
     if (bounds.size == 1) {
         generateTypeOf(v, bounds.single(), intrinsicsSupport)
     } else {
-        v.aconst(bounds.size)
+        v.iconst(bounds.size)
         v.newarray(K_TYPE)
         for ((i, bound) in bounds.withIndex()) {
             v.dup()
-            v.aconst(i)
+            v.iconst(i)
             generateTypeOf(v, bound, intrinsicsSupport)
             v.astore(K_TYPE)
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicArrayConstructors.kt

@@ -16,10 +16,14 @@
 
 package org.jetbrains.kotlin.codegen.intrinsics
 
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.codegen.inline.ReificationArgument
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.org.objectweb.asm.Label
@@ -30,6 +34,15 @@ import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 internal object IntrinsicArrayConstructors {
+    fun isArrayOf(descriptor: FunctionDescriptor): Boolean =
+        descriptor.name.asString() == "arrayOf" && descriptor.containingDeclaration.isBuiltInsPackage
+
+    fun isEmptyArray(descriptor: FunctionDescriptor): Boolean =
+        descriptor.name.asString() == "emptyArray" && descriptor.containingDeclaration.isBuiltInsPackage
+
+    private val DeclarationDescriptor.isBuiltInsPackage: Boolean
+        get() = this is PackageFragmentDescriptor && fqName == StandardNames.BUILT_INS_PACKAGE_FQ_NAME
+
     fun generateArrayConstructorBody(method: Method): MethodNode {
         val node = MethodNode(
             Opcodes.ASM6, Opcodes.ACC_PUBLIC or Opcodes.ACC_STATIC or Opcodes.ACC_FINAL, method.name, method.descriptor, null, null

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/KClassJavaObjectTypeProperty.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner
+import org.jetbrains.kotlin.codegen.putReifiedOperationMarkerIfTypeIsReifiedParameter
 import org.jetbrains.kotlin.psi.KtClassLiteralExpression
 import org.jetbrains.kotlin.resolve.BindingContext.DOUBLE_COLON_LHS
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall

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

@@ -34,11 +34,26 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 class ConstantConditionEliminationMethodTransformer : MethodTransformer() {
 
     override fun transform(internalClassName: String, methodNode: MethodNode) {
+        if (!methodNode.hasOptimizableConditions()) {
+            return
+        }
         do {
             val changes = ConstantConditionsOptimization(internalClassName, methodNode).run()
         } while (changes)
     }
 
+    private fun MethodNode.hasOptimizableConditions(): Boolean {
+        val insns = instructions.toArray()
+        return insns.any { it.isIntJump() } && insns.any { it.isIntConst() }
+    }
+
+    private fun AbstractInsnNode.isIntConst() =
+        opcode in Opcodes.ICONST_M1..Opcodes.ICONST_5 || opcode == Opcodes.BIPUSH || opcode == Opcodes.SIPUSH ||
+                (opcode == Opcodes.LDC && this is LdcInsnNode && cst is Int)
+
+    private fun AbstractInsnNode.isIntJump() =
+        opcode in Opcodes.IFEQ..Opcodes.IFLE || opcode in Opcodes.IF_ICMPEQ..Opcodes.IF_ICMPLE
+
     private class ConstantConditionsOptimization(val internalClassName: String, val methodNode: MethodNode) {
         fun run(): Boolean {
             val actions = collectRewriteActions()

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

@@ -72,18 +72,30 @@ class OptimizationMethodVisitor(
     }
 
     companion object {
-        private val MEMORY_LIMIT_BY_METHOD_MB = 50
+        private const val MEMORY_LIMIT_BY_METHOD_MB = 50
+        private const val TRY_CATCH_BLOCKS_SOFT_LIMIT = 16
 
         fun canBeOptimized(node: MethodNode): Boolean {
-            val totalFramesSizeMb = node.instructions.size() * (node.maxLocals + node.maxStack) / (1024 * 1024)
-            return totalFramesSizeMb < MEMORY_LIMIT_BY_METHOD_MB
+            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
         }
 
         fun canBeOptimizedUsingSourceInterpreter(node: MethodNode): Boolean {
-            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
+            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
         }
+
+        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(
-    private val boxedType: Type,
+    boxedType: Type,
     val boxingInsn: AbstractInsnNode,
     val progressionIterator: ProgressionIteratorBasicValue?,
     val generationState: GenerationState

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

@@ -17,13 +17,16 @@
 package org.jetbrains.kotlin.codegen.optimization.boxing
 
 import org.jetbrains.kotlin.codegen.optimization.OptimizationMethodVisitor
+import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.isLoadOperation
 import org.jetbrains.kotlin.codegen.optimization.fixStack.peekWords
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.Analyzer
+import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
+import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
+import org.jetbrains.org.objectweb.asm.tree.InsnNode
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.tree.analysis.SourceInterpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
@@ -52,7 +55,7 @@ class PopBackwardPropagationTransformer : MethodTransformer() {
         private val dontTouchInsnIndices = BitSet(insns.size)
 
         fun transform() {
-            val frames = Analyzer(HazardsTrackingInterpreter()).analyze("fake", methodNode)
+            val frames = FastMethodAnalyzer("fake", methodNode, HazardsTrackingInterpreter()).analyze()
             for ((i, insn) in insns.withIndex()) {
                 val frame = frames[i] ?: continue
                 when (insn.opcode) {

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

@@ -38,6 +38,10 @@ 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/ControlFlowGraph.kt

@@ -5,46 +5,160 @@
 
 package org.jetbrains.kotlin.codegen.optimization.common
 
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.tree.InsnList
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
+import gnu.trove.TIntHashSet
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.tree.*
 
 
 class ControlFlowGraph private constructor(private val insns: InsnList) {
-    private val edges: Array<MutableList<Int>> = Array(insns.size()) { arrayListOf<Int>() }
-    private val backwardEdges: Array<MutableList<Int>> = Array(insns.size()) { arrayListOf<Int>() }
+    private val successors: Array<MutableList<Int>> = Array(insns.size()) { ArrayList(2) }
+    private val predecessors: Array<MutableList<Int>> = Array(insns.size()) { ArrayList(2) }
 
     fun getSuccessorsIndices(insn: AbstractInsnNode): List<Int> = getSuccessorsIndices(insns.indexOf(insn))
-    fun getSuccessorsIndices(index: Int): List<Int> = edges[index]
+    fun getSuccessorsIndices(index: Int): List<Int> = successors[index]
     fun getPredecessorsIndices(insn: AbstractInsnNode): List<Int> = getPredecessorsIndices(insns.indexOf(insn))
-    fun getPredecessorsIndices(index: Int): List<Int> = backwardEdges[index]
+    fun getPredecessorsIndices(index: Int): List<Int> = predecessors[index]
+
+    private class Builder(
+        private val method: MethodNode,
+        private val followExceptions: Boolean
+    ) {
+        private val instructions = method.instructions
+        private val nInsns = instructions.size()
+
+        private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
+
+        private val queued = BooleanArray(nInsns)
+        private val queue = IntArray(nInsns)
+        private var top = 0
+
+        private val predecessors = Array(nInsns) { TIntHashSet() }
+
+        private val AbstractInsnNode.indexOf get() = instructions.indexOf(this)
+
+        fun build(): ControlFlowGraph {
+            val graph = ControlFlowGraph(method.instructions)
+            if (nInsns == 0) return graph
+
+            checkAssertions()
+            computeExceptionHandlersForEachInsn()
+            initControlFlowAnalysis()
+            traverseCfg()
+
+            for ((i, preds) in predecessors.withIndex()) {
+                for (pred in preds.toArray()) {
+                    graph.predecessors[i].add(pred)
+                    graph.successors[pred].add(i)
+                }
+            }
+            return graph
+        }
+
+        private fun traverseCfg() {
+            while (top > 0) {
+                val insn = queue[--top]
+                val insnNode = method.instructions[insn]
+                val insnOpcode = insnNode.opcode
+
+                when (insnNode.type) {
+                    AbstractInsnNode.LABEL, AbstractInsnNode.LINE, AbstractInsnNode.FRAME ->
+                        visitOpInsn(insn)
+                    AbstractInsnNode.JUMP_INSN ->
+                        visitJumpInsnNode(insnNode as JumpInsnNode, insn, insnOpcode)
+                    AbstractInsnNode.LOOKUPSWITCH_INSN ->
+                        visitLookupSwitchInsnNode(insn, insnNode as LookupSwitchInsnNode)
+                    AbstractInsnNode.TABLESWITCH_INSN ->
+                        visitTableSwitchInsnNode(insn, insnNode as TableSwitchInsnNode)
+                    else -> {
+                        if (insnOpcode != Opcodes.ATHROW && (insnOpcode < Opcodes.IRETURN || insnOpcode > Opcodes.RETURN)) {
+                            visitOpInsn(insn)
+                        }
+                    }
+                }
+
+
+                handlers[insn]?.forEach { tcb ->
+                    visitExceptionEdge(insn, tcb.handler.indexOf)
+                }
+            }
+        }
+
+        private fun checkAssertions() {
+            if (instructions.any { it.opcode == Opcodes.JSR || it.opcode == Opcodes.RET })
+                throw AssertionError("Subroutines are deprecated since Java 6")
+        }
+
+        private fun visitOpInsn(insn: Int) {
+            visitEdge(insn, insn + 1)
+        }
+
+        private fun visitTableSwitchInsnNode(insn: Int, insnNode: TableSwitchInsnNode) {
+            var jump = insnNode.dflt.indexOf
+            visitEdge(insn, jump)
+            for (label in insnNode.labels) {
+                jump = label.indexOf
+                visitEdge(insn, jump)
+            }
+        }
+
+        private fun visitLookupSwitchInsnNode(insn: Int, insnNode: LookupSwitchInsnNode) {
+            var jump = insnNode.dflt.indexOf
+            visitEdge(insn, jump)
+            for (label in insnNode.labels) {
+                jump = label.indexOf
+                visitEdge(insn, jump)
+            }
+        }
+
+        private fun visitJumpInsnNode(insnNode: JumpInsnNode, insn: Int, insnOpcode: Int) {
+            if (insnOpcode != Opcodes.GOTO && insnOpcode != Opcodes.JSR) {
+                visitEdge(insn, insn + 1)
+            }
+            val jump = insnNode.label.indexOf
+            visitEdge(insn, jump)
+        }
+
+        private fun initControlFlowAnalysis() {
+            queued[0] = true
+            queue[top++] = 0
+        }
+
+        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 insnHandlers = handlers[j]
+                        ?: ArrayList<TryCatchBlockNode>().also { handlers[j] = it }
+                    insnHandlers.add(tcb)
+                }
+            }
+        }
+
+        private fun visitExceptionEdge(from: Int, to: Int) {
+            if (followExceptions) {
+                predecessors[to].add(from)
+            }
+            enqueue(to)
+        }
+
+        private fun visitEdge(from: Int, to: Int) {
+            predecessors[to].add(from)
+            enqueue(to)
+        }
+
+        private fun enqueue(insn: Int) {
+            if (!queued[insn]) {
+                queued[insn] = true
+                queue[top++] = insn
+            }
+        }
+    }
 
     companion object {
         @JvmStatic
         fun build(node: MethodNode, followExceptions: Boolean = true): ControlFlowGraph {
-            val graph = ControlFlowGraph(node.instructions)
-
-            fun addEdge(from: Int, to: Int) {
-                graph.edges[from].add(to)
-                graph.backwardEdges[to].add(from)
-            }
-
-            object : MethodAnalyzer<BasicValue>("fake", node, OptimizationBasicInterpreter()) {
-                override fun visitControlFlowEdge(insn: Int, successor: Int): Boolean {
-                    addEdge(insn, successor)
-                    return true
-                }
-
-                override fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean {
-                    if (followExceptions) {
-                        addEdge(insn, successor)
-                    }
-                    return true
-                }
-            }.analyze()
-
-            return graph
+            return Builder(node, followExceptions).build()
         }
     }
 }

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

@@ -24,6 +24,6 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Value
 class CustomFramesMethodAnalyzer<V : Value>(
     owner: String, method: MethodNode, interpreter: Interpreter<V>,
     private val frameFactory: (Int, Int) -> Frame<V>
-) : MethodAnalyzer<V>(owner, method, interpreter) {
+) : FastMethodAnalyzer<V>(owner, method, interpreter) {
     override fun newFrame(nLocals: Int, nStack: Int) = frameFactory(nLocals, nStack)
 }

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

@@ -0,0 +1,374 @@
+/*
+ * 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.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
+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.fixStack.FastStackAnalyzer
+ */
+@Suppress("DuplicatedCode")
+open class FastMethodAnalyzer<V : Value>(
+    private val owner: String,
+    val method: MethodNode,
+    private val interpreter: Interpreter<V>
+) {
+    private val insnsArray = method.instructions.toArray()
+    private val nInsns = method.instructions.size()
+
+    // 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)
+
+    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)
+
+    fun analyze(): Array<Frame<V>?> {
+        if (nInsns == 0) return frames
+
+        checkAssertions()
+
+        computeExceptionHandlersForEachInsn(method)
+
+        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()
+
+                    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 AbstractInsnNode.indexOf() =
+        method.instructions.indexOf(this)
+
+    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
+            }
+        }
+    }
+
+    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) {
+        mergeControlFlowEdge(insn, insn + 1, 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.reversed()) {
+            jump = label.indexOf()
+            mergeControlFlowEdge(insn, jump, 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) {
+            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, insn + 1, 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) {
+        for (tcb in m.tryCatchBlocks) {
+            val begin = tcb.start.indexOf()
+            val end = tcb.end.indexOf()
+            for (j in begin until end) {
+                if (!insnsArray[j].isMeaningful) continue
+                var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[j]
+                if (insnHandlers == null) {
+                    insnHandlers = SmartList()
+                    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
+        }
+    }
+
+    @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/InstructionLivenessAnalyzer.kt

@@ -1,6 +1,35 @@
 /*
  * 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.common
@@ -95,7 +124,7 @@ class InstructionLivenessAnalyzer(val method: MethodNode) {
         var jump = insnNode.dflt.indexOf
         visitControlFlowEdge(jump)
         for (label in insnNode.labels) {
-            jump = instructions.indexOf(label)
+            jump = label.indexOf
             visitControlFlowEdge(jump)
         }
     }
@@ -126,9 +155,10 @@ class InstructionLivenessAnalyzer(val method: MethodNode) {
             val begin = tcb.start.indexOf
             val end = tcb.end.indexOf
             for (j in begin until end) {
+                if (!instructions[j].isMeaningful) continue
                 var insnHandlers = handlers[j]
                 if (insnHandlers == null) {
-                    insnHandlers = ArrayList<TryCatchBlockNode>()
+                    insnHandlers = ArrayList()
                     handlers[j] = insnHandlers
                 }
                 insnHandlers.add(tcb)

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

@@ -1,263 +0,0 @@
-/*
- * 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
-import java.util.*
-
-/**
- * This class is a modified version of `org.objectweb.asm.tree.analysis.Analyzer`
- * @author Eric Bruneton
- * @author Dmitry Petrov
- */
-open class MethodAnalyzer<V : Value>(
-    private val owner: String,
-    val method: MethodNode,
-    protected val interpreter: Interpreter<V>
-) {
-    val instructions: InsnList = method.instructions
-    private val nInsns: Int = instructions.size()
-
-    val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
-
-    private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
-    private val queued: BooleanArray = BooleanArray(nInsns)
-    private val queue: IntArray = IntArray(nInsns)
-    private var top: Int = 0
-
-    protected open fun init(owner: String, m: MethodNode) {}
-
-    protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
-
-    protected open fun newFrame(src: Frame<out V>): Frame<V> {
-        val frame = newFrame(src.locals, src.maxStackSize)
-        frame.init(src)
-        return frame
-    }
-
-    protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
-
-    protected open fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean = true
-
-    protected open fun visitControlFlowExceptionEdge(insn: Int, tcb: TryCatchBlockNode): Boolean =
-        visitControlFlowExceptionEdge(insn, instructions.indexOf(tcb.handler))
-
-    fun analyze(): Array<Frame<V>?> {
-        if (nInsns == 0) return frames
-
-        checkAssertions()
-
-        computeExceptionHandlersForEachInsn(method)
-
-        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 = instructions.indexOf(tcb.handler)
-                    if (visitControlFlowExceptionEdge(insn, tcb)) {
-                        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
-    }
-
-    fun getFrame(insn: AbstractInsnNode): Frame<V>? =
-        frames[instructions.indexOf(insn)]
-
-    private fun checkAssertions() {
-        if (instructions.toArray().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 = instructions.indexOf(insnNode.dflt)
-        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 = instructions.indexOf(label)
-            processControlFlowEdge(current, insn, jump)
-        }
-    }
-
-    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
-        var jump = instructions.indexOf(insnNode.dflt)
-        processControlFlowEdge(current, insn, jump)
-        for (label in insnNode.labels) {
-            jump = instructions.indexOf(label)
-            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 = instructions.indexOf(insnNode.label)
-        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)
-
-        init(owner, m)
-    }
-
-    private fun computeExceptionHandlersForEachInsn(m: MethodNode) {
-        for (tcb in m.tryCatchBlocks) {
-            val begin = instructions.indexOf(tcb.start)
-            val end = instructions.indexOf(tcb.end)
-            for (j in begin until end) {
-                var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[j]
-                if (insnHandlers == null) {
-                    insnHandlers = ArrayList<TryCatchBlockNode>()
-                    handlers[j] = insnHandlers
-                }
-                insnHandlers.add(tcb)
-            }
-        }
-    }
-
-    private fun mergeControlFlowEdge(insn: Int, frame: Frame<V>) {
-        val oldFrame = frames[insn]
-        val changes =
-            if (oldFrame != null)
-                oldFrame.merge(frame, interpreter)
-            else {
-                frames[insn] = newFrame(frame)
-                true
-            }
-        if (changes && !queued[insn]) {
-            queued[insn] = true
-            queue[top++] = insn
-        }
-    }
-
-}