[Draft] Jspecify: support type use annotations

As it prevents from dynamic reloading of plugin

^KT-39958 Fixed

.bunch

@@ -2,7 +2,6 @@
 202
 203_202
 193
-192_193
-as36_192_193
 as40_193
-as41
+as41
+as42_202

.gitignore

@@ -59,3 +59,6 @@ node_modules/
 .rpt2_cache/
 libraries/tools/kotlin-test-js-runner/lib/
 local.properties
+buildSrcTmp/
+distTmp/
+outTmp/

.idea/dictionaries/yan.xml

@@ -10,7 +10,10 @@
       <w>kapt</w>
       <w>kotlinc</w>
       <w>mutators</w>
+      <w>parcelable</w>
       <w>parceler</w>
+      <w>parcelers</w>
+      <w>parcelize</w>
       <w>repl</w>
       <w>testdata</w>
       <w>uast</w>

.idea/runConfigurations/Test__KMM.xml

@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Test: KMM" type="GradleRunConfiguration" factoryName="Gradle">
+    <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="kmmTest" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <method v="2" />
+  </configuration>
+</component>

.idea/scopes/Apply_copyright.xml

@@ -1,3 +1,3 @@
 <component name="DependencyValidationManager">
-  <scope name="Apply copyright" pattern="!file[*]:*//testData//*&amp;&amp;!file[*]:testData//*&amp;&amp;!file[*]:*.gradle.kts&amp;&amp;!file[*]:*.gradle&amp;&amp;!file[kotlin.kotlin-ultimate]:*/&amp;&amp;!file[kotlin.kotlin-ultimate.*]:*/&amp;&amp;!file[kotlin.libraries]:stdlib/api//*" />
+  <scope name="Apply copyright" pattern="!file[*]:*//testData//*&amp;&amp;!file[*]:testData//*&amp;&amp;!file[*]:*.gradle.kts&amp;&amp;!file[*]:*.gradle&amp;&amp;!file[group:kotlin-ultimate]:*/&amp;&amp;!file[kotlin.libraries]:stdlib/api//*" />
 </component>

ReadMe.md

@@ -18,6 +18,16 @@ Welcome to [Kotlin](https://kotlinlang.org/)! Some handy links:
  * [Public Slack channel](https://slack.kotlinlang.org/)
  * [TeamCity CI build](https://teamcity.jetbrains.com/project.html?tab=projectOverview&projectId=Kotlin)
 
+## Kotlin Multiplatform capabilities
+
+Support for multiplatform programming is one of Kotlin’s key benefits. It reduces time spent writing and maintaining the same code for [different platforms](https://kotlinlang.org/docs/reference/mpp-supported-platforms.html) while retaining the flexibility and benefits of native programming.
+
+ * [Kotlin Multiplatform Mobile](https://kotlinlang.org/lp/mobile/) for sharing code between Android and iOS
+ * [Getting Started with Kotlin Multiplatform Mobile Guide](https://kotlinlang.org/docs/mobile/create-first-app.html)
+ * [Kotlin Multiplatform Benefits](https://kotlinlang.org/docs/reference/multiplatform.html)
+ * [Share code on all platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-all-platforms)
+ * [Share code on similar platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-similar-platforms)
+
 ## Editing Kotlin
 
  * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html)
@@ -86,6 +96,8 @@ command line parameters on the first run:
 - `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.
+
 **OPTIONAL:** Some artifacts, mainly Maven plugin ones, are built separately with Maven.
 Refer to [libraries/ReadMe.md](libraries/ReadMe.md) for details.
 

benchmarks/build.gradle.kts

@@ -8,10 +8,8 @@ buildscript {
         val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
-            maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
         } else {
             maven("https://dl.bintray.com/kotlin/kotlinx")
-            maven("https://dl.bintray.com/kotlin/kotlin-dev")
         }
     }
     dependencies {
@@ -30,16 +28,15 @@ repositories {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
     if (cacheRedirectorEnabled) {
         maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
-        maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
-    } else {
+   } else {
         maven("https://dl.bintray.com/kotlin/kotlinx")
-        maven("https://dl.bintray.com/kotlin/kotlin-dev")
     }
 }
 
 dependencies {
     compile(kotlinStdlib())
     compile(project(":compiler:frontend"))
+    compile(projectTests(":compiler:tests-common"))
     compile(project(":compiler:cli"))
     compile(intellijCoreDep()) { includeJars("intellij-core") }
     compile(jpsStandalone()) { includeJars("jps-model") }
@@ -73,6 +70,7 @@ benchmark {
             param("size", 1000)
 
             include("CommonCallsBenchmark")
+            include("ControlFlowAnalysisBenchmark")
             //include("InferenceBaselineCallsBenchmark")
         }
 
@@ -95,3 +93,52 @@ benchmark {
         register("main")
     }
 }
+
+tasks.named("classes") {
+    doLast {
+        tasks.named("mainBenchmarkJar", Zip::class.java) {
+            isZip64 = true
+            archiveName = "benchmarks.jar"
+        }
+        listOf("mainBenchmark", "mainFirBenchmark", "mainNiBenchmark").forEach {
+            tasks.named(it, JavaExec::class.java) {
+                systemProperty("idea.home.path", intellijRootDir().canonicalPath)
+            }
+        }
+    }
+}
+
+tasks.register<JavaExec>("runBenchmark") {
+    // jmhArgs example: -PjmhArgs='CommonCalls -p size=500 -p isIR=true -p useNI=true -f 1'
+    val jmhArgs = if (project.hasProperty("jmhArgs")) project.property("jmhArgs").toString() else ""
+    val resultFilePath = "$buildDir/benchmarks/jmh-result.json"
+    val ideaHome = intellijRootDir().canonicalPath
+
+    val benchmarkJarPath = "$buildDir/benchmarks/main/jars/benchmarks.jar"
+    args = mutableListOf("-Didea.home.path=$ideaHome", benchmarkJarPath, "-rf", "json", "-rff", resultFilePath) + jmhArgs.split("\\s".toRegex())
+    main = "-jar"
+
+    doLast {
+        if (project.kotlinBuildProperties.isTeamcityBuild) {
+            val jsonArray = com.google.gson.JsonParser.parseString(File(resultFilePath).readText()).asJsonArray
+            jsonArray.forEach {
+                val benchmark = it.asJsonObject
+                // remove unnecessary name parts from string like this "org.jetbrains.kotlin.benchmarks.CommonCallsBenchmark.benchmark"
+                val name = benchmark["benchmark"].asString.removeSuffix(".benchmark").let {
+                    val indexOfLastDot = it.indexOfLast { it == '.' }
+                    it.removeRange(0..indexOfLastDot)
+                }
+                val params = benchmark["params"].asJsonObject
+                val isIR = if (params.has("isIR")) params["isIR"].asString else "false"
+                val useNI = if (params.has("useNI")) params["useNI"].asString else "false"
+                val size = params["size"].asString
+                val score = "%.3f".format(benchmark["primaryMetric"].asJsonObject["score"].asString.toFloat())
+
+                val irPostfix = if (isIR.toBoolean()) " isIR=true" else ""
+                val niPostfix = if (useNI.toBoolean() && !isIR.toBoolean()) " isNI=true" else ""
+
+                println("""##teamcity[buildStatisticValue key='$name size=$size${irPostfix}$niPostfix' value='$score']""")
+            }
+        }
+    }
+}

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

@@ -5,7 +5,6 @@
 package org.jetbrains.kotlin.benchmarks
 
 import com.intellij.openapi.Disposable
-import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.CharsetToolkit
 import com.intellij.psi.PsiElementFinder
@@ -13,7 +12,6 @@ import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.impl.PsiFileFactoryImpl
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.testFramework.LightVirtualFile
-import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
@@ -26,21 +24,15 @@ 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.FirSession
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
-import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
-import org.jetbrains.kotlin.fir.java.FirLibrarySession
-import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.createSession
+import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.storage.ExceptionTracker
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
@@ -111,9 +103,7 @@ abstract class AbstractSimpleFileBenchmark {
         )
 
         if (isIR) {
-            Extensions.getArea(env.project)
-                .getExtensionPoint(PsiElementFinder.EP_NAME)
-                .unregisterExtension(JavaElementFinder::class.java)
+            PsiElementFinder.EP.getPoint(env.project).unregisterExtension(JavaElementFinder::class.java)
         }
 
         file = createFile(
@@ -170,43 +160,10 @@ abstract class AbstractSimpleFileBenchmark {
         totalTransformer.process(listOf(firFile))
 
         bh.consume(firFile.hashCode())
+        env.project.extensionArea
+            .getExtensionPoint<PsiElementFinder>(PsiElementFinder.EP.name)
+            .unregisterExtension(FirJavaElementFinder::class.java)
     }
 
     protected abstract fun buildText(): String
 }
-
-fun createSession(
-    environment: KotlinCoreEnvironment,
-    sourceScope: GlobalSearchScope,
-    librariesScope: GlobalSearchScope = GlobalSearchScope.notScope(sourceScope)
-): FirSession {
-    val moduleInfo = FirTestModuleInfo()
-    val project = environment.project
-    val provider = FirProjectSessionProvider(project)
-    return FirJavaModuleBasedSession.create(moduleInfo, provider, sourceScope).also {
-        createSessionForDependencies(provider, moduleInfo, librariesScope, environment)
-    }
-}
-
-private fun createSessionForDependencies(
-    provider: FirProjectSessionProvider,
-    moduleInfo: FirTestModuleInfo,
-    librariesScope: GlobalSearchScope,
-    environment: KotlinCoreEnvironment
-) {
-    val dependenciesInfo = FirTestModuleInfo()
-    moduleInfo.dependencies.add(dependenciesInfo)
-    FirLibrarySession.create(
-        dependenciesInfo, provider, librariesScope, environment.project,
-        environment.createPackagePartProvider(librariesScope)
-    )
-}
-
-class FirTestModuleInfo(
-    override val name: Name = Name.identifier("TestModule"),
-    val dependencies: MutableList<ModuleInfo> = mutableListOf(),
-    override val platform: TargetPlatform = JvmPlatforms.unspecifiedJvmPlatform,
-    override val analyzerServices: PlatformDependentAnalyzerServices = JvmPlatformAnalyzerServices
-) : ModuleInfo {
-    override fun dependencies(): List<ModuleInfo> = dependencies
-}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class ControlFlowAnalysisBenchmark : AbstractSimpleFileBenchmark() {
+    @Param("1000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+        buildString {
+            appendLine("fun test() {")
+            for (i in 0 until size) {
+                appendLine("for (i$i in 0..10) { ")
+            }
+            for (i in 0 until size) {
+                appendLine("}")
+            }
+            appendLine("}")
+        }
+}

build-common/build.gradle.kts

@@ -7,6 +7,7 @@ plugins {
 
 dependencies {
     compileOnly(project(":core:util.runtime"))
+    compileOnly(project(":compiler:backend.common.jvm"))
     compileOnly(project(":compiler:util"))
     compileOnly(project(":compiler:cli-common"))
     compileOnly(project(":compiler:frontend.java"))

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

@@ -75,7 +75,7 @@ open class IncrementalJsCache(
     override fun markDirty(removedAndCompiledSources: Collection<File>) {
         removedAndCompiledSources.forEach { sourceFile ->
             // The common prefix of all FQN parents has to be the file package
-            sourceToClassesMap[sourceFile].map { it.parentOrNull()?.asString() ?: "" }.minBy { it.length }?.let {
+            sourceToClassesMap[sourceFile].map { it.parentOrNull()?.asString() ?: "" }.minByOrNull { it.length }?.let {
                 packageMetadata.remove(it)
             }
         }

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

@@ -168,6 +168,8 @@ open class IncrementalJvmCache(
                 constantsMap.process(kotlinClass, changesCollector)
                 inlineFunctionsMap.process(kotlinClass, changesCollector)
             }
+            KotlinClassHeader.Kind.UNKNOWN, KotlinClassHeader.Kind.SYNTHETIC_CLASS -> {
+            }
         }
     }
 

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

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.load.java.JavaVisibilities
+import org.jetbrains.kotlin.load.java.JavaDescriptorVisibilities
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf
@@ -41,7 +41,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
             childSerializer: DescriptorSerializer
     ) {
         super.serializeClass(descriptor, proto, versionRequirementTable, childSerializer)
-        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateClass, true)
         }
     }
@@ -50,7 +50,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
                                       proto: ProtoBuf.Constructor.Builder,
                                       childSerializer: DescriptorSerializer) {
         super.serializeConstructor(descriptor, proto, childSerializer)
-        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateConstructor, true)
         }
     }
@@ -62,7 +62,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
         childSerializer: DescriptorSerializer
     ) {
         super.serializeFunction(descriptor, proto, versionRequirementTable, childSerializer)
-        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateMethod, true)
         }
 
@@ -78,7 +78,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
             childSerializer: DescriptorSerializer
     ) {
         super.serializeProperty(descriptor, proto, versionRequirementTable, childSerializer)
-        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateField, true)
         }
 

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

@@ -23,12 +23,12 @@ import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import java.io.File
 
 class LocalFileKotlinClass private constructor(
-        private val file: File,
-        private val fileContents: ByteArray,
-        className: ClassId,
-        classVersion: Int,
-        classHeader: KotlinClassHeader,
-        innerClasses: InnerClassesInfo
+    private val file: File,
+    private val fileContents: ByteArray,
+    className: ClassId,
+    classVersion: Int,
+    classHeader: KotlinClassHeader,
+    innerClasses: InnerClassesInfo
 ) : FileBasedKotlinClass(className, classVersion, classHeader, innerClasses) {
 
     companion object {

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

@@ -80,7 +80,7 @@ open class LookupStorage(
 
         for (lookupSymbol in lookups.keySet().sorted()) {
             val key = LookupSymbolKey(lookupSymbol.name, lookupSymbol.scope)
-            val paths = lookups[lookupSymbol]!!
+            val paths = lookups[lookupSymbol]
             val fileIds = paths.mapTo(TreeSet()) { pathToId[it]!! }
             fileIds.addAll(lookupMap[key] ?: emptySet())
             lookupMap[key] = fileIds

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

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+@file:Suppress("UNUSED_PARAMETER")
+
 package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.library.metadata.KlibMetadataProtoBuf

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.incremental
 
-import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufClassKind
 import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufPackageKind
 import org.jetbrains.kotlin.incremental.storage.ProtoMapValue
@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
+import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
 import java.util.*
 
 data class Difference(
@@ -49,8 +50,8 @@ fun ProtoMapValue.toProtoData(packageFqName: FqName): ProtoData =
     }
 
 internal val MessageLite.isPrivate: Boolean
-    get() = Visibilities.isPrivate(
-        ProtoEnumFlags.visibility(
+    get() = DescriptorVisibilities.isPrivate(
+        ProtoEnumFlags.descriptorVisibility(
             when (this) {
                 is ProtoBuf.Constructor -> Flags.VISIBILITY.get(flags)
                 is ProtoBuf.Function -> Flags.VISIBILITY.get(flags)
@@ -346,4 +347,4 @@ val ProtoBuf.Class.typeTableOrNull: ProtoBuf.TypeTable?
     get() = if (hasTypeTable()) typeTable else null
 
 val ProtoBuf.Package.typeTableOrNull: ProtoBuf.TypeTable?
-    get() = if (hasTypeTable()) typeTable else null
+    get() = if (hasTypeTable()) typeTable else null

build-common/test/org/jetbrains/kotlin/metadata/DebugProtoBuf.java

@@ -17258,6 +17258,7 @@ public final class DebugProtoBuf {
      *hasAnnotations
      *Visibility
      *isSecondary
+     *hasNonStableParameterNames
      * </pre>
      */
     boolean hasFlags();
@@ -17268,6 +17269,7 @@ public final class DebugProtoBuf {
      *hasAnnotations
      *Visibility
      *isSecondary
+     *hasNonStableParameterNames
      * </pre>
      */
     int getFlags();
@@ -17463,6 +17465,7 @@ public final class DebugProtoBuf {
      *hasAnnotations
      *Visibility
      *isSecondary
+     *hasNonStableParameterNames
      * </pre>
      */
     public boolean hasFlags() {
@@ -17475,6 +17478,7 @@ public final class DebugProtoBuf {
      *hasAnnotations
      *Visibility
      *isSecondary
+     *hasNonStableParameterNames
      * </pre>
      */
     public int getFlags() {
@@ -17894,6 +17898,7 @@ public final class DebugProtoBuf {
        *hasAnnotations
        *Visibility
        *isSecondary
+       *hasNonStableParameterNames
        * </pre>
        */
       public boolean hasFlags() {
@@ -17906,6 +17911,7 @@ public final class DebugProtoBuf {
        *hasAnnotations
        *Visibility
        *isSecondary
+       *hasNonStableParameterNames
        * </pre>
        */
       public int getFlags() {
@@ -17918,6 +17924,7 @@ public final class DebugProtoBuf {
        *hasAnnotations
        *Visibility
        *isSecondary
+       *hasNonStableParameterNames
        * </pre>
        */
       public Builder setFlags(int value) {
@@ -17933,6 +17940,7 @@ public final class DebugProtoBuf {
        *hasAnnotations
        *Visibility
        *isSecondary
+       *hasNonStableParameterNames
        * </pre>
        */
       public Builder clearFlags() {
@@ -18307,6 +18315,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isSuspend
      *isExpect
+     *hasNonStableParameterNames
      * </pre>
      */
     boolean hasFlags();
@@ -18325,6 +18334,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isSuspend
      *isExpect
+     *hasNonStableParameterNames
      * </pre>
      */
     int getFlags();
@@ -18723,6 +18733,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isSuspend
      *isExpect
+     *hasNonStableParameterNames
      * </pre>
      */
     public boolean hasFlags() {
@@ -18743,6 +18754,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isSuspend
      *isExpect
+     *hasNonStableParameterNames
      * </pre>
      */
     public int getFlags() {
@@ -19639,6 +19651,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isSuspend
        *isExpect
+       *hasNonStableParameterNames
        * </pre>
        */
       public boolean hasFlags() {
@@ -19659,6 +19672,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isSuspend
        *isExpect
+       *hasNonStableParameterNames
        * </pre>
        */
       public int getFlags() {
@@ -19679,6 +19693,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isSuspend
        *isExpect
+       *hasNonStableParameterNames
        * </pre>
        */
       public Builder setFlags(int value) {
@@ -19702,6 +19717,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isSuspend
        *isExpect
+       *hasNonStableParameterNames
        * </pre>
        */
       public Builder clearFlags() {

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

@@ -4656,7 +4656,8 @@ public final class DebugJvmProtoBuf {
    * <code>extend .org.jetbrains.kotlin.metadata.Class { ... }</code>
    *
    * <pre>
-   * isFunctionBodyInInterface: 0 if actual body generated in DefaultImpl, 1 - otherwise (in interface default method)
+   * first bit: isFunctionBodyInInterface: 0 if actual body generated in DefaultImpl, 1 - otherwise (in interface default method)
+   * second bit: is all-compatibility mode or not, 1 - yes, 0 - no
    * </pre>
    */
   public static final

build.gradle.kts

@@ -7,7 +7,7 @@ import proguard.gradle.ProGuardTask
 buildscript {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.SpaceBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         bootstrapKotlinRepo?.let(::maven)
@@ -27,9 +27,10 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.20")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
+        classpath("org.jfrog.buildinfo:build-info-extractor-gradle:4.17.2")
     }
 }
 
@@ -177,8 +178,8 @@ extra["versions.org.springframework"] = "4.2.0.RELEASE"
 extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
-extra["versions.completion-ranking-kotlin"] = "0.1.2"
-extra["versions.r8"] = "1.5.70"
+extra["versions.completion-ranking-kotlin"] = "0.1.3"
+extra["versions.r8"] = "2.0.88"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -187,12 +188,13 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.4-M3-dev-15627"
+    extra["versions.kotlin-native"] = "1.4.20-dev-16314"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
 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.getBooleanProperty("kotlin.build.useIR") ?: false)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
 
@@ -220,6 +222,8 @@ extra["compilerModules"] = arrayOf(
     ":compiler:config",
     ":compiler:config.jvm",
     ":compiler:container",
+    ":compiler:resolution.common",
+    ":compiler:resolution.common.jvm",
     ":compiler:resolution",
     ":compiler:serialization",
     ":compiler:psi",
@@ -228,6 +232,8 @@ extra["compilerModules"] = arrayOf(
     ":compiler:frontend.java",
     ":compiler:cli-common",
     ":compiler:ir.tree",
+    ":compiler:ir.tree.impl",
+    ":compiler:ir.tree.persistent",
     ":compiler:ir.psi2ir",
     ":compiler:ir.backend.common",
     ":compiler:backend.jvm",
@@ -262,17 +268,22 @@ extra["compilerModules"] = arrayOf(
     ":kotlin-build-common",
     ":core:metadata",
     ":core:metadata.jvm",
+    ":core:deserialization.common",
+    ":core:deserialization.common.jvm",
+    ":core:compiler.common",
+    ":core:compiler.common.jvm",
+    ":compiler:backend.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":core:descriptors.runtime",
     ":core:deserialization",
     ":core:util.runtime",
-    ":core:type-system",
     ":compiler:fir:cones",
     ":compiler:fir:resolve",
     ":compiler:fir:fir-serialization",
+    ":compiler:fir:fir-deserialization",
     ":compiler:fir:tree",
-    ":compiler:fir:raw-fir:fir-common",
+    ":compiler:fir:raw-fir:raw-fir.common",
     ":compiler:fir:raw-fir:psi2fir",
     ":compiler:fir:raw-fir:light-tree2fir",
     ":compiler:fir:fir2ir",
@@ -280,11 +291,11 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:java",
     ":compiler:fir:jvm",
     ":compiler:fir:checkers",
+    ":compiler:fir:entrypoint",
     ":compiler:fir:analysis-tests"
 )
 
 extra["compilerModulesForJps"] = listOf(
-    ":core:type-system",
     ":kotlin-build-common",
     ":kotlin-util-io",
     ":kotlin-util-klib",
@@ -293,6 +304,8 @@ extra["compilerModulesForJps"] = listOf(
     ":kotlin-compiler-runner",
     ":daemon-common",
     ":daemon-common-new",
+    ":core:compiler.common",
+    ":core:compiler.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":idea:idea-jps-common",
@@ -328,7 +341,8 @@ val gradlePluginProjects = listOf(
     ":kotlin-allopen",
     ":kotlin-annotation-processing-gradle",
     ":kotlin-noarg",
-    ":kotlin-sam-with-receiver"
+    ":kotlin-sam-with-receiver",
+    ":kotlin-parcelize-compiler"
 )
 
 apply {
@@ -352,7 +366,7 @@ fun Task.listConfigurationContents(configName: String) {
 }
 
 val defaultJvmTarget = "1.8"
-val defaultJavaHome = jdkPath(defaultJvmTarget)
+val defaultJavaHome = jdkPath(if (Platform[203].orHigher()) "11" else defaultJvmTarget)
 val ignoreTestFailures by extra(project.kotlinBuildProperties.ignoreTestFailures)
 
 allprojects {
@@ -405,9 +419,6 @@ allprojects {
     val commonCompilerArgs = listOfNotNull(
         "-Xopt-in=kotlin.RequiresOptIn",
         "-Xread-deserialized-contracts",
-        "-Xjvm-default=compatibility",
-        "-Xno-optimized-callable-references",
-        "-Xno-kotlin-nothing-value-exception",
         "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
@@ -419,9 +430,20 @@ allprojects {
         }
     }
 
+    val jvmCompilerArgs = listOf(
+        "-Xjvm-default=compatibility",
+        "-Xno-optimized-callable-references",
+        "-Xno-kotlin-nothing-value-exception",
+        "-Xnormalize-constructor-calls=enable"
+    )
+
     tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
         kotlinOptions {
-            freeCompilerArgs = commonCompilerArgs + listOf("-Xnormalize-constructor-calls=enable")
+            freeCompilerArgs = commonCompilerArgs + jvmCompilerArgs
+
+            if (useJvmIrBackend) {
+                useIR = true
+            }
         }
     }
 
@@ -451,6 +473,7 @@ allprojects {
             ignore("META-INF/MANIFEST.MF")
             ignore("META-INF/compiler.version")
             ignore("META-INF/plugin.xml")
+            ignore("kotlin/KotlinVersionCurrentValue.class")
         }
     }
 
@@ -500,6 +523,23 @@ allprojects {
         }
 
         apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
+        apply(from = "$rootDir/gradle/testRetry.gradle.kts")
+    }
+}
+
+gradle.buildFinished {
+    val taskGraph = gradle?.taskGraph
+    if (taskGraph != null) {
+        taskGraph.allTasks
+                .filterIsInstance<SourceTask>()
+                .filter { it.didWork }
+                .forEach {
+                    it.source.visit {
+                        if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
+                            logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
+                        }
+                    }
+                }
     }
 }
 
@@ -507,9 +547,12 @@ gradle.taskGraph.whenReady {
     fun Boolean.toOnOff(): String = if (this) "on" else "off"
     val profile = if (isTeamcityBuild) "CI" else "Local"
 
-    logger.warn("$profile build profile is active (proguard is ${kotlinBuildProperties.proguard.toOnOff()}" +
-                            ", jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()})." +
-                            " Use -Pteamcity=<true|false> to reproduce CI/local build")
+    val proguardMessage = "proguard is ${kotlinBuildProperties.proguard.toOnOff()}"
+    val jarCompressionMessage = "jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()}"
+                val profileMessage = "$profile build profile is active ($proguardMessage, $jarCompressionMessage). " +
+            "Use -Pteamcity=<true|false> to reproduce CI/local build"
+
+    logger.warn("\n\n$profileMessage")
 
     allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
         task.entryCompression = if (kotlinBuildProperties.jarCompression)
@@ -670,9 +713,12 @@ tasks {
         dependsOn("scriptingTest")
         dependsOn(":kotlin-build-common:test")
         dependsOn(":compiler:incremental-compilation-impl:test")
+        dependsOn(":compiler:incremental-compilation-impl:testJvmICWithJdk11")
         dependsOn(":core:descriptors.runtime:test")
 
         dependsOn("jvmCompilerIntegrationTest")
+
+        dependsOn(":plugins:parcelize:parcelize-compiler:test")
     }
 
     register("toolsTest") {
@@ -708,16 +754,9 @@ tasks {
         dependsOn(":jps-plugin:test")
     }
 
-    register("idea-plugin-main-tests") {
-        dependsOn("dist")
-        dependsOn(":idea:test")
-    }
-
     register("idea-plugin-additional-tests") {
         dependsOn("dist")
         dependsOn(
-            ":idea:idea-gradle:test",
-            ":idea:idea-gradle-native:test",
             ":idea:idea-maven:test",
             ":j2k:test",
             ":nj2k:test",
@@ -740,17 +779,6 @@ tasks {
         }
     }
 
-    register("idea-plugin-tests") {
-        dependsOn("dist")
-        dependsOn(
-            "idea-plugin-main-tests",
-            "idea-plugin-additional-tests"
-        )
-        if (Ide.IJ()) {
-            dependsOn("idea-new-project-wizard-tests")
-        }
-    }
-
     register("idea-plugin-performance-tests") {
         dependsOn("dist")
         dependsOn(
@@ -758,19 +786,38 @@ tasks {
         )
     }
 
+    register("idea-fir-plugin-performance-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":idea:idea-fir-performance-tests:ideaFirPerformanceTest"
+        )
+    }
+
     register("android-ide-tests") {
         dependsOn("dist")
         dependsOn(
             ":plugins:android-extensions-ide:test",
             ":idea:idea-android:test",
-            ":kotlin-annotation-processing:test"
+            ":kotlin-annotation-processing:test",
+            ":plugins:parcelize:parcelize-ide:test"
         )
     }
 
-    register("plugins-tests") {
-        dependsOn("dist")
+    register("ideaPluginTest") {
+        dependsOn(
+            "mainIdeTests",
+            "gradleIdeTest",
+            "kaptIdeTest",
+            "miscIdeTests"
+        )
+    }
+
+    register("mainIdeTests") {
+        dependsOn(":idea:test")
+    }
+
+    register("miscIdeTests") {
         dependsOn(
-            ":kotlin-annotation-processing:test",
             ":kotlin-allopen-compiler-plugin:test",
             ":kotlin-noarg-compiler-plugin:test",
             ":kotlin-sam-with-receiver-compiler-plugin:test",
@@ -778,53 +825,40 @@ tasks {
             ":kotlin-annotation-processing-gradle:test",
             ":kotlinx-serialization-compiler-plugin:test",
             ":kotlinx-serialization-ide-plugin:test",
-            ":idea:jvm-debugger:jvm-debugger-test:test"
-        )
-    }
-
-
-    register("ideaPluginTest") {
-        dependsOn(
-            "idea-plugin-tests",
+            ":idea:jvm-debugger:jvm-debugger-test:test",
+            "idea-plugin-additional-tests",
             "jps-tests",
-            "plugins-tests",
-            "android-ide-tests",
             ":generators:test"
         )
+        if (Ide.IJ()) {
+            dependsOn("idea-new-project-wizard-tests")
+        }
     }
 
-    register("publishIdeArtifacts") {
-        idePluginDependency {
-            dependsOn(
-                ":prepare:ide-plugin-dependencies:android-extensions-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-tests-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-compiler-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-dist-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
-                ":kotlin-script-runtime:publish",
-                ":kotlin-script-util:publish",
-                ":kotlin-scripting-common:publish",
-                ":kotlin-scripting-jvm:publish",
-                ":kotlin-scripting-compiler:publish",
-                ":kotlin-scripting-compiler-impl:publish",
-                ":kotlin-android-extensions-runtime:publish",
-                ":kotlin-stdlib-common:publish",
-                ":kotlin-stdlib:publish",
-                ":kotlin-stdlib-jdk7:publish",
-                ":kotlin-stdlib-jdk8:publish",
-                ":kotlin-reflect:publish",
-                ":kotlin-main-kts:publish",
-                ":kotlin-stdlib-js:publish",
-                ":kotlin-test:kotlin-test-js:publish"
-            )
-        }
+    register("kaptIdeTest") {
+        dependsOn(":kotlin-annotation-processing:test")
+    }
+
+    register("gradleIdeTest") {
+        dependsOn(
+            ":idea:idea-gradle:test",
+            ":idea:idea-gradle-native:test"
+        )
+    }
+
+    register("kmmTest", AggregateTest::class) {
+        dependsOn(
+            ":idea:idea-gradle:test",
+            ":idea:test",
+            ":compiler:test",
+            ":js:js.tests:test"
+        )
+        if (Ide.IJ193.orHigher())
+            dependsOn(":kotlin-gradle-plugin-integration-tests:test")
+        if (Ide.AS40.orHigher())
+            dependsOn(":kotlin-ultimate:ide:android-studio-native:test")
+
+        testPatternFile = file("tests/mpp/kmm-patterns.csv")
     }
 
     register("test") {
@@ -844,6 +878,41 @@ tasks {
             }
         }
     }
+
+    register("publishIdeArtifacts") {
+        idePluginDependency {
+            dependsOn(
+                ":prepare:ide-plugin-dependencies:android-extensions-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-tests-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-compiler-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-dist-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
+                ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide:publish",
+                ":kotlin-script-runtime:publish",
+                ":kotlin-script-util:publish",
+                ":kotlin-scripting-common:publish",
+                ":kotlin-scripting-jvm:publish",
+                ":kotlin-scripting-compiler:publish",
+                ":kotlin-scripting-compiler-impl:publish",
+                ":kotlin-android-extensions-runtime:publish",
+                ":kotlin-stdlib-common:publish",
+                ":kotlin-stdlib:publish",
+                ":kotlin-stdlib-jdk7:publish",
+                ":kotlin-stdlib-jdk8:publish",
+                ":kotlin-reflect:publish",
+                ":kotlin-main-kts:publish",
+                ":kotlin-stdlib-js:publish",
+                ":kotlin-test:kotlin-test-js:publish"
+            )
+        }
+    }
 }
 
 fun CopySpec.setExecutablePermissions() {
@@ -907,7 +976,7 @@ val zipPlugin by task<Zip> {
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Plugin artifacts packed to $archiveFile")
+        logger.lifecycle("Plugin artifacts packed to ${archiveFile.get()}")
     }
 }
 

buildSrc/build.gradle.kts

@@ -5,7 +5,7 @@ buildscript {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
     extra["defaultSnapshotVersion"] = kotlinBuildProperties.defaultSnapshotVersion
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.SpaceBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         if (cacheRedirectorEnabled) {
@@ -22,7 +22,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.20")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -97,7 +97,7 @@ repositories {
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.20")
     implementation("com.gradle.publish:plugin-publish-plugin:0.11.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
@@ -110,6 +110,8 @@ dependencies {
     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("org.gradle:test-retry-gradle-plugin:1.1.9")
 }
 
 samWithReceiver {

buildSrc/prepare-deps/build.gradle.kts

@@ -1,16 +1,15 @@
 @file:Suppress("PropertyName", "HasPlatformType", "UnstableApiUsage")
 
 import org.gradle.internal.os.OperatingSystem
+import org.jetbrains.kotlin.gradle.tasks.internal.CleanableStore
 import java.io.Closeable
 import java.io.OutputStreamWriter
 import java.net.URI
 import java.text.SimpleDateFormat
-import java.util.*
-import javax.xml.stream.XMLOutputFactory
-
-import org.jetbrains.kotlin.gradle.tasks.internal.CleanableStore
 import java.time.Duration
 import java.time.Instant
+import java.util.*
+import javax.xml.stream.XMLOutputFactory
 
 plugins {
     base
@@ -180,6 +179,7 @@ val mergeSources by tasks.creating(Jar::class.java) {
     dependsOn(sources)
     isPreserveFileTimestamps = false
     isReproducibleFileOrder = true
+    isZip64 = true
     if (!kotlinBuildProperties.isTeamcityBuild) {
         from(provider { sources.map(::zipTree) })
     }
@@ -255,9 +255,8 @@ fun buildIvyRepositoryTask(
         inputs.files(configuration)
 
         outputs.upToDateWhen {
-            configuration.resolvedConfiguration.resolvedArtifacts.single()
-                .moduleDirectory()
-                .exists()
+            val repoMarker = configuration.resolvedConfiguration.resolvedArtifacts.single().moduleDirectory().resolve(".marker")
+            repoMarker.exists()
         }
 
         doFirst {
@@ -266,8 +265,9 @@ fun buildIvyRepositoryTask(
 
             artifact.storeDirectory().cleanStore()
 
-            if (moduleDirectory.exists()) {
-                logger.info("Path ${moduleDirectory.absolutePath} already exists, skipping unpacking.")
+            val repoMarker = File(moduleDirectory, ".marker")
+            if (repoMarker.exists()) {
+                logger.info("Path ${repoMarker.absolutePath} already exists, skipping unpacking.")
                 return@doFirst
             }
 
@@ -326,6 +326,8 @@ fun buildIvyRepositoryTask(
                             )
                         }
                 }
+
+                repoMarker.createNewFile()
             }
         }
     }

buildSrc/settings.gradle

@@ -20,7 +20,7 @@ buildscript {
         }
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.20")
     }
 }
 
@@ -46,12 +46,12 @@ if (target_AppCode_Clion) {
 } else if (target_AndroidStudio) {
     logger.info("Including modules for AS (mobile plugin) in buildSrc/settings.gradle")
 
-    include ":prepare-deps:cocoa-common-binaries"
+    include ":prepare-deps:appcode-binaries"
     include ":prepare-deps:lldb-framework"
     include ":prepare-deps:lldb-frontend"
 
-    project(":prepare-deps:cocoa-common-binaries").projectDir =
-            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/cocoa-common-binaries")
+    project(":prepare-deps:appcode-binaries").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/appcode-binaries")
     project(":prepare-deps:lldb-framework").projectDir =
             file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-framework")
     project(":prepare-deps:lldb-frontend").projectDir =
@@ -69,4 +69,4 @@ if (target_AppCode_Clion) {
 
 } else {
     logger.info("Not including extra modules in buildSrc/settings.gradle")
-}
+}

buildSrc/src/main/kotlin/AggregateTest.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+import org.gradle.api.GradleException
+import org.gradle.api.tasks.*
+import org.gradle.api.tasks.testing.Test
+import java.io.File
+
+// You can see "How To" via link: https://jetbrains.quip.com/xQ2WAUy9bZmy/How-to-use-AggregateTest-task
+open class AggregateTest : Test() { // Inherit from Test to see test results in IDEA Test viewer
+    private var patterns: MutableMap<String, MutableList<String>> = mutableMapOf()
+
+    @InputFile
+    lateinit var testPatternFile: File
+
+    init {
+        // Set empty FileCollection to avoid NPE when initializing a base 'Test' class
+        classpath = project.objects.fileCollection()
+        testClassesDirs = project.objects.fileCollection()
+
+        project.gradle.taskGraph.whenReady {
+            if (allTasks.filterIsInstance<AggregateTest>().isNotEmpty()) {
+                initPatterns()
+                allTasks.filterIsInstance<Test>().forEach { testTask -> subTaskConfigure(testTask) }
+
+                if (!project.gradle.startParameter.taskNames.all { project.tasks.findByPath(it) is AggregateTest }) {
+                    logger.warn("Please, don't use AggregateTest and non-AggregateTest test tasks together. You can get incorrect results.")
+                }
+            }
+        }
+    }
+
+    private fun initPatterns() {
+        if (!testPatternFile.exists())
+            throw GradleException("File with test patterns is not found")
+        testPatternFile
+            .readLines()
+            .asSequence()
+            .filter { it.isNotEmpty() }
+            .forEach { line ->
+                // patternType is exclude or include value
+                val (pattern, patternType) = line.split(',').map { it.trim() }
+                patterns.getOrPut(patternType) { mutableListOf() }.add(pattern)
+            }
+    }
+
+    private fun subTaskConfigure(testTask: Test) {
+        testTask.outputs.upToDateWhen { false }
+        testTask.ignoreFailures = true
+        testTask.filter {
+            isFailOnNoMatchingTests = false
+            patterns["include"]?.let {
+                it.forEach { pattern ->
+                    includeTestsMatching(pattern)
+                }
+            }
+            patterns["exclude"]?.let {
+                it.forEach { pattern ->
+                    excludeTestsMatching(pattern)
+                }
+            }
+        }
+    }
+
+    @Override
+    @TaskAction
+    override fun executeTests() {
+        // Do nothing
+    }
+}

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -56,7 +56,7 @@ var Project.javaHome: String?
 
 fun Project.generator(fqName: String, sourceSet: SourceSet? = null) = smartJavaExec {
     classpath = (sourceSet ?: testSourceSet).runtimeClasspath
-    main = fqName
+    mainClass.set(fqName)
     workingDir = rootDir
     systemProperty("line.separator", "\n")
 }

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,7 +26,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P183, P191, P192, P193, P201, P202;
+    P183, P191, P192, P193, P201, P202, P203;
 
     val version: Int = name.drop(1).toInt()
 
@@ -48,11 +48,13 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     IJ193(Platform.P193),
     IJ201(Platform.P201),
     IJ202(Platform.P202),
+    IJ203(Platform.P203),
 
     AS35(Platform.P183),
     AS36(Platform.P192),
     AS40(Platform.P193),
-    AS41(Platform.P201);
+    AS41(Platform.P201),
+    AS42(Platform.P202);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

buildSrc/src/main/kotlin/SmartJavaExec.kt

@@ -23,6 +23,10 @@ fun JavaExec.passClasspathInJar() {
         dependsOn(classpath)
         inputs.files(classpath)
         inputs.property("main", main)
+
+        archiveFileName.set("$main.${this@passClasspathInJar.name}.classpath.container.jar")
+        destinationDirectory.set(temporaryDir)
+
         doFirst {
             val classPathString = classpath.joinToString(" ") { project.file(it).toURI().toString() }
             manifest {
@@ -34,16 +38,11 @@ fun JavaExec.passClasspathInJar() {
                 )
             }
         }
-        archiveName = "$main.${this@passClasspathInJar.name}.classpath.container.$extension"
-        destinationDir = temporaryDir
     }
 
     dependsOn(jarTask)
 
-    doFirst {
-        main = "-jar"
-
-        classpath = project.files()
-        args = listOf(jarTask.outputs.files.singleFile.path) + args.orEmpty()
-    }
+    main = "-jar"
+    classpath = project.files()
+    args = listOf(jarTask.outputs.files.singleFile.path) + args.orEmpty()
 }

buildSrc/src/main/kotlin/dependencies.kt

@@ -1,3 +1,8 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
 @file:Suppress("unused")
 
 // usages in build scripts are not tracked properly
@@ -97,9 +102,11 @@ fun Project.kotlinStdlib(suffix: String? = null, classifier: String? = null): An
         dependencies.project(listOfNotNull(":kotlin-stdlib", suffix).joinToString("-"), classifier)
 }
 
-fun Project.kotlinBuiltins(): Any =
+fun Project.kotlinBuiltins(): Any = kotlinBuiltins(forJvm = false)
+
+fun Project.kotlinBuiltins(forJvm: Boolean): Any =
     if (kotlinBuildProperties.useBootstrapStdlib) "org.jetbrains.kotlin:builtins:$bootstrapKotlinVersion"
-    else dependencies.project(":core:builtins")
+    else dependencies.project(":core:builtins", configuration = "runtimeElementsJvm".takeIf { forJvm })
 
 fun DependencyHandler.projectTests(name: String): ProjectDependency = project(name, configuration = "tests-jar")
 fun DependencyHandler.projectRuntimeJar(name: String): ProjectDependency = project(name, configuration = "runtimeJar")

buildSrc/src/main/kotlin/localDependencies.kt

@@ -80,6 +80,8 @@ fun Project.androidDxJar() = "org.jetbrains.kotlin:android-dx:${rootProject.extr
 
 fun Project.jpsBuildTest() = "com.jetbrains.intellij.idea:jps-build-test:${rootProject.extra["versions.intellijSdk"]}"
 
+fun Project.kotlinxCollectionsImmutable() = "org.jetbrains.kotlinx:kotlinx-collections-immutable-jvm:${rootProject.extra["versions.kotlinx-collections-immutable"]}"
+
 /**
  * Runtime version of annotations that are already in Kotlin stdlib (historically Kotlin has older version of this one).
  *
@@ -165,7 +167,7 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
 
         classpath = mainSourceSet.runtimeClasspath
 
-        main = "com.intellij.idea.Main"
+        mainClass.set("com.intellij.idea.Main")
 
         workingDir = File(intellijRootDir(), "bin")
 
@@ -178,13 +180,14 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
             "-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}"
         )
 
-        if (Platform[201].orHigher()) {
+        if (Platform[201].orHigher() && !isIntellijUltimateSdkAvailable()) {
             jvmArgs("-Didea.platform.prefix=Idea")
         }
 

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

@@ -52,6 +52,7 @@ open class PublishedKotlinModule : Plugin<Project> {
                 configure<SigningExtension> {
                     isRequired = signingRequired
                     sign(configurations["archives"])
+                    useGpgCmd()
                 }
 
                 tasks.named<Sign>("signArchives").configure {

buildSrc/src/main/kotlin/tasks.kt

@@ -31,6 +31,47 @@ import java.lang.Character.isUpperCase
 import java.nio.file.Files
 import java.nio.file.Path
 
+fun Task.dependsOnKotlinPluginInstall() {
+    dependsOn(
+        ":kotlin-allopen:install",
+        ":kotlin-noarg:install",
+        ":kotlin-sam-with-receiver:install",
+        ":kotlin-android-extensions:install",
+        ":kotlin-parcelize-compiler:install",
+        ":kotlin-build-common:install",
+        ":kotlin-compiler-embeddable:install",
+        ":native:kotlin-native-utils:install",
+        ":kotlin-util-klib:install",
+        ":kotlin-util-io:install",
+        ":kotlin-compiler-runner:install",
+        ":kotlin-daemon-embeddable:install",
+        ":kotlin-daemon-client:install",
+        ":kotlin-gradle-plugin-api:install",
+        ":kotlin-gradle-plugin:install",
+        ":kotlin-gradle-plugin-model:install",
+        ":kotlin-reflect:install",
+        ":kotlin-annotation-processing-gradle:install",
+        ":kotlin-test:kotlin-test-common:install",
+        ":kotlin-test:kotlin-test-annotations-common:install",
+        ":kotlin-test:kotlin-test-jvm:install",
+        ":kotlin-test:kotlin-test-js:install",
+        ":kotlin-test:kotlin-test-junit:install",
+        ":kotlin-gradle-subplugin-example:install",
+        ":kotlin-stdlib-common:install",
+        ":kotlin-stdlib:install",
+        ":kotlin-stdlib-jdk8:install",
+        ":kotlin-stdlib-js:install",
+        ":examples:annotation-processor-example:install",
+        ":kotlin-script-runtime:install",
+        ":kotlin-scripting-common:install",
+        ":kotlin-scripting-jvm:install",
+        ":kotlin-scripting-compiler-embeddable:install",
+        ":kotlin-scripting-compiler-impl-embeddable:install",
+        ":kotlin-test-js-runner:install",
+        ":native:kotlin-klib-commonizer-embeddable:install"
+    )
+}
+
 fun Project.projectTest(
     taskName: String = "test",
     parallel: Boolean = false,

compiler/android-tests/build.gradle.kts

@@ -6,25 +6,23 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
-    compile(project(":compiler:cli"))
-    compile(project(":compiler:frontend"))
-    compile(project(":compiler:backend"))
-    compile(kotlinStdlib())
-    compile(project(":kotlin-reflect"))
-    compile(projectTests(":compiler:tests-common"))
-    compile(commonDep("junit:junit"))
-
-    Platform[193].orLower {
-        compileOnly(intellijDep()) { includeJars("openapi") }
-    }
-
-    testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":core:descriptors"))
     testCompile(project(":core:descriptors.jvm"))
+    testCompile(project(":compiler:util"))
+    testCompile(project(":compiler:cli"))
+    testCompile(project(":compiler:frontend"))
+    testCompile(project(":compiler:backend"))
+    testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":compiler:frontend.java"))
+
+    testCompile(kotlinStdlib())
+    testCompile(project(":kotlin-reflect"))
+    testCompile(projectTests(":compiler:tests-common"))
+    testCompile(commonDep("junit:junit"))
+
     testCompile(projectTests(":jps-plugin"))
     testCompile(commonDep("junit:junit"))
+
     Platform[193].orLower {
         testCompile(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
     }
@@ -44,7 +42,7 @@ dependencies {
 }
 
 sourceSets {
-    "main" { projectDefault() }
+    "main" { }
     "test" { projectDefault() }
 }
 

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

@@ -25,7 +25,7 @@ import org.junit.runners.AllTests;
 
 import java.io.File;
 
-@RunWith(AllTests.class)
+//@RunWith(AllTests.class)
 public class AndroidRunner {
 
     private static PathManager pathManager;

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

@@ -65,7 +65,7 @@ object CodegenUtil {
                 if (copy)
                     copyFunctions(
                         declaration, traitMember, declaration.containingDeclaration, traitMember.modality,
-                        Visibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, true
+                        DescriptorVisibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, true
                     )
                 else mapMembers(declaration, traitMember)
             )
@@ -74,13 +74,13 @@ object CodegenUtil {
     }
 
     fun copyFunctions(
-        inheritedMember: CallableMemberDescriptor,
-        traitMember: CallableMemberDescriptor,
-        newOwner: DeclarationDescriptor,
-        modality: Modality,
-        visibility: Visibility,
-        kind: CallableMemberDescriptor.Kind,
-        copyOverrides: Boolean
+            inheritedMember: CallableMemberDescriptor,
+            traitMember: CallableMemberDescriptor,
+            newOwner: DeclarationDescriptor,
+            modality: Modality,
+            visibility: DescriptorVisibility,
+            kind: CallableMemberDescriptor.Kind,
+            copyOverrides: Boolean
     ): Map<FunctionDescriptor, FunctionDescriptor> =
         mapMembers(inheritedMember.copy(newOwner, modality, visibility, kind, copyOverrides), traitMember)
 

compiler/backend.common.jvm/build.gradle.kts

@@ -0,0 +1,15 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    api(project(":core:compiler.common.jvm"))
+    api(project(":compiler:config.jvm"))
+    api(intellijCoreDep()) { includeJars("asm-all", "guava", rootProject = rootProject) }
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" {}
+}

compiler/backend.common.jvm/src/org/jetbrains/kotlin/codegen/AsmUtil.java

@@ -0,0 +1,450 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.codegen;
+
+import com.google.common.collect.ImmutableMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.builtins.PrimitiveType;
+import org.jetbrains.kotlin.descriptors.Visibilities;
+import org.jetbrains.kotlin.descriptors.Visibility;
+import org.jetbrains.kotlin.descriptors.java.JavaVisibilities;
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
+import org.jetbrains.kotlin.name.ClassId;
+import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
+import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
+import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
+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.InstructionAdapter;
+import org.jetbrains.org.objectweb.asm.commons.Method;
+
+import java.util.Map;
+
+import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
+import static org.jetbrains.org.objectweb.asm.Opcodes.*;
+
+public class AsmUtil {
+    private static final int NO_FLAG_LOCAL = 0;
+    public static final int NO_FLAG_PACKAGE_PRIVATE = 0;
+
+    @NotNull
+    private static final Map<Visibility, Integer> visibilityToAccessFlag = ImmutableMap.<Visibility, Integer>builder()
+            .put(Visibilities.Private.INSTANCE, ACC_PRIVATE)
+            .put(Visibilities.PrivateToThis.INSTANCE, ACC_PRIVATE)
+            .put(Visibilities.Protected.INSTANCE, ACC_PROTECTED)
+            .put(JavaVisibilities.ProtectedStaticVisibility.INSTANCE, ACC_PROTECTED)
+            .put(JavaVisibilities.ProtectedAndPackage.INSTANCE, ACC_PROTECTED)
+            .put(Visibilities.Public.INSTANCE, ACC_PUBLIC)
+            .put(Visibilities.Internal.INSTANCE, ACC_PUBLIC)
+            .put(Visibilities.Local.INSTANCE, NO_FLAG_LOCAL)
+            .put(JavaVisibilities.PackageVisibility.INSTANCE, NO_FLAG_PACKAGE_PRIVATE)
+            .build();
+
+    public static final String CAPTURED_PREFIX = "$";
+
+    public static final String THIS = "this";
+
+    public static final String THIS_IN_DEFAULT_IMPLS = "$this";
+
+    public static final String LABELED_THIS_FIELD = THIS + "_";
+
+    public static final String CAPTURED_LABELED_THIS_FIELD = CAPTURED_PREFIX + LABELED_THIS_FIELD;
+
+    public static final String INLINE_DECLARATION_SITE_THIS = "this_";
+
+    public static final String LABELED_THIS_PARAMETER = CAPTURED_PREFIX + THIS + "$";
+
+    public static final String CAPTURED_THIS_FIELD = "this$0";
+
+    public static final String RECEIVER_PARAMETER_NAME = "$receiver";
+
+    /*
+        This is basically an old convention. Starting from Kotlin 1.3, it was replaced with `$this_<label>`.
+        Note that it is still used for inlined callable references and anonymous callable extension receivers
+        even in 1.3.
+    */
+    public static final String CAPTURED_RECEIVER_FIELD = "receiver$0";
+
+    // For non-inlined callable references ('kotlin.jvm.internal.CallableReference' has a 'receiver' field)
+    public static final String BOUND_REFERENCE_RECEIVER = "receiver";
+
+    public static final String LOCAL_FUNCTION_VARIABLE_PREFIX = "$fun$";
+
+    private static final ImmutableMap<Integer, JvmPrimitiveType> primitiveTypeByAsmSort;
+    private static final ImmutableMap<Type, Type> primitiveTypeByBoxedType;
+
+    static {
+        ImmutableMap.Builder<Integer, JvmPrimitiveType> typeBySortBuilder = ImmutableMap.builder();
+        ImmutableMap.Builder<Type, Type> typeByWrapperBuilder = ImmutableMap.builder();
+        for (JvmPrimitiveType primitiveType : JvmPrimitiveType.values()) {
+            Type asmType = Type.getType(primitiveType.getDesc());
+            typeBySortBuilder.put(asmType.getSort(), primitiveType);
+            typeByWrapperBuilder.put(asmTypeByFqNameWithoutInnerClasses(primitiveType.getWrapperFqName()), asmType);
+        }
+        primitiveTypeByAsmSort = typeBySortBuilder.build();
+        primitiveTypeByBoxedType = typeByWrapperBuilder.build();
+    }
+
+    private AsmUtil() {
+    }
+
+    @NotNull
+    public static String getCapturedFieldName(@NotNull String originalName) {
+        return CAPTURED_PREFIX + originalName;
+    }
+
+    @NotNull
+    public static String getLabeledThisName(@NotNull String callableName, @NotNull String prefix, @NotNull String defaultName) {
+        if (!Name.isValidIdentifier(callableName)) {
+            return defaultName;
+        }
+
+        return prefix + CommonVariableAsmNameManglingUtils.mangleNameIfNeeded(callableName);
+    }
+
+    @NotNull
+    public static Type boxType(@NotNull Type type) {
+        Type boxedType = boxPrimitiveType(type);
+        return boxedType != null ? boxedType : type;
+    }
+
+    @Nullable
+    public static Type boxPrimitiveType(@NotNull Type type) {
+        JvmPrimitiveType jvmPrimitiveType = primitiveTypeByAsmSort.get(type.getSort());
+        return jvmPrimitiveType != null ? asmTypeByFqNameWithoutInnerClasses(jvmPrimitiveType.getWrapperFqName()) : null;
+    }
+
+    @NotNull
+    public static Type unboxType(@NotNull Type boxedType) {
+        Type primitiveType = unboxPrimitiveTypeOrNull(boxedType);
+        if (primitiveType == null) {
+            throw new UnsupportedOperationException("Unboxing: " + boxedType);
+        }
+        return primitiveType;
+    }
+
+    @Nullable
+    public static Type unboxPrimitiveTypeOrNull(@NotNull Type boxedType) {
+        return primitiveTypeByBoxedType.get(boxedType);
+    }
+
+    public static boolean isBoxedPrimitiveType(@NotNull Type boxedType) {
+        return primitiveTypeByBoxedType.get(boxedType) != null;
+    }
+
+    @NotNull
+    public static Type unboxUnlessPrimitive(@NotNull Type boxedOrPrimitiveType) {
+        if (isPrimitive(boxedOrPrimitiveType)) return boxedOrPrimitiveType;
+        return unboxType(boxedOrPrimitiveType);
+    }
+
+    public static boolean isBoxedTypeOf(@NotNull Type boxedType, @NotNull Type unboxedType) {
+        return unboxPrimitiveTypeOrNull(boxedType) == unboxedType;
+    }
+
+    public static boolean isIntPrimitive(Type type) {
+        return type == Type.INT_TYPE || type == Type.SHORT_TYPE || type == Type.BYTE_TYPE || type == Type.CHAR_TYPE;
+    }
+
+    public static boolean isIntOrLongPrimitive(Type type) {
+        return isIntPrimitive(type) || type == Type.LONG_TYPE;
+    }
+
+    public static boolean isPrimitive(Type type) {
+        return type.getSort() != Type.OBJECT && type.getSort() != Type.ARRAY;
+    }
+
+    @NotNull
+    public static Type correctElementType(@NotNull Type type) {
+        String internalName = type.getInternalName();
+        assert internalName.charAt(0) == '[';
+        return Type.getType(internalName.substring(1));
+    }
+
+    @NotNull
+    public static Type getArrayType(@NotNull Type componentType) {
+        return Type.getType("[" + componentType.getDescriptor());
+    }
+
+    @Nullable
+    public static PrimitiveType asmPrimitiveTypeToLangPrimitiveType(Type type) {
+        JvmPrimitiveType jvmPrimitiveType = primitiveTypeByAsmSort.get(type.getSort());
+        return jvmPrimitiveType != null ? jvmPrimitiveType.getPrimitiveType() : null;
+    }
+
+    @NotNull
+    public static Method method(@NotNull String name, @NotNull Type returnType, @NotNull Type... parameterTypes) {
+        return new Method(name, Type.getMethodDescriptor(returnType, parameterTypes));
+    }
+
+    public static Type stringValueOfType(Type type) {
+        int sort = type.getSort();
+        return sort == Type.OBJECT || sort == Type.ARRAY
+               ? OBJECT_TYPE
+               : sort == Type.BYTE || sort == Type.SHORT ? Type.INT_TYPE : type;
+    }
+
+    public static void genThrow(@NotNull InstructionAdapter v, @NotNull String exception, @Nullable String message) {
+        v.anew(Type.getObjectType(exception));
+        v.dup();
+        if (message != null) {
+            v.aconst(message);
+            v.invokespecial(exception, "<init>", "(Ljava/lang/String;)V", false);
+        }
+        else {
+            v.invokespecial(exception, "<init>", "()V", false);
+        }
+        v.athrow();
+    }
+
+    public static void genStringBuilderConstructor(InstructionAdapter v) {
+        v.visitTypeInsn(NEW, "java/lang/StringBuilder");
+        v.dup();
+        v.invokespecial("java/lang/StringBuilder", "<init>", "()V", false);
+    }
+
+    public static void genInvertBoolean(InstructionAdapter v) {
+        v.iconst(1);
+        v.xor(Type.INT_TYPE);
+    }
+
+    public static void numConst(int value, Type type, InstructionAdapter v) {
+        if (type == Type.FLOAT_TYPE) {
+            v.fconst(value);
+        }
+        else if (type == Type.DOUBLE_TYPE) {
+            v.dconst(value);
+        }
+        else if (type == Type.LONG_TYPE) {
+            v.lconst(value);
+        }
+        else if (type == Type.CHAR_TYPE || type == Type.BYTE_TYPE || type == Type.SHORT_TYPE || type == Type.INT_TYPE) {
+            v.iconst(value);
+        }
+        else {
+            throw new IllegalArgumentException("Primitive numeric type expected, got: " + type);
+        }
+    }
+
+    public static void swap(InstructionAdapter v, Type stackTop, Type afterTop) {
+        if (stackTop.getSize() == 1) {
+            if (afterTop.getSize() == 1) {
+                v.swap();
+            }
+            else {
+                v.dupX2();
+                v.pop();
+            }
+        }
+        else {
+            if (afterTop.getSize() == 1) {
+                v.dup2X1();
+            }
+            else {
+                v.dup2X2();
+            }
+            v.pop2();
+        }
+    }
+
+    public static void pushDefaultValueOnStack(@NotNull Type type, @NotNull InstructionAdapter v) {
+        v.visitInsn(defaultValueOpcode(type));
+    }
+
+    public static int defaultValueOpcode(@NotNull Type type) {
+        if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
+            return ACONST_NULL;
+        }
+        if (type.getSort() == Type.FLOAT) {
+            return FCONST_0;
+        }
+        if (type.getSort() == Type.DOUBLE) {
+            return DCONST_0;
+        }
+        if (type.getSort() == Type.LONG) {
+            return LCONST_0;
+        }
+        return ICONST_0;
+    }
+
+    public static Type comparisonOperandType(Type left, Type right) {
+        if (left == Type.DOUBLE_TYPE || right == Type.DOUBLE_TYPE) return Type.DOUBLE_TYPE;
+        if (left == Type.FLOAT_TYPE || right == Type.FLOAT_TYPE) return Type.FLOAT_TYPE;
+        if (left == Type.LONG_TYPE || right == Type.LONG_TYPE) return Type.LONG_TYPE;
+        if (left == Type.CHAR_TYPE || right == Type.CHAR_TYPE) return Type.CHAR_TYPE;
+        return Type.INT_TYPE;
+    }
+
+    @NotNull
+    public static Type numberFunctionOperandType(@NotNull Type expectedType) {
+        if (expectedType == Type.SHORT_TYPE || expectedType == Type.BYTE_TYPE || expectedType == Type.CHAR_TYPE) {
+            return Type.INT_TYPE;
+        }
+        return expectedType;
+    }
+
+    public static void pop(@NotNull MethodVisitor v, @NotNull Type type) {
+        if (type.getSize() == 2) {
+            v.visitInsn(Opcodes.POP2);
+        }
+        else {
+            v.visitInsn(Opcodes.POP);
+        }
+    }
+
+    public static void pop2(@NotNull MethodVisitor v, @NotNull Type topOfStack, @NotNull Type afterTop) {
+        if (topOfStack.getSize() == 1 && afterTop.getSize() == 1) {
+            v.visitInsn(POP2);
+        } else {
+            pop(v, topOfStack);
+            pop(v, afterTop);
+        }
+    }
+
+    public static void pop2(@NotNull MethodVisitor v, @NotNull Type type) {
+        if (type.getSize() == 2) {
+            v.visitInsn(Opcodes.POP2);
+            v.visitInsn(Opcodes.POP2);
+        }
+        else {
+            v.visitInsn(Opcodes.POP2);
+        }
+    }
+
+    public static void dup(@NotNull InstructionAdapter v, @NotNull Type type) {
+        dup(v, type.getSize());
+    }
+
+    private static void dup(@NotNull InstructionAdapter v, int size) {
+        if (size == 2) {
+            v.dup2();
+        }
+        else if (size == 1) {
+            v.dup();
+        }
+        else {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public static void dupx(@NotNull InstructionAdapter v, @NotNull Type type) {
+        dupx(v, type.getSize());
+    }
+
+    private static void dupx(@NotNull InstructionAdapter v, int size) {
+        if (size == 2) {
+            v.dup2X2();
+        }
+        else if (size == 1) {
+            v.dupX1();
+        }
+        else {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    // Duplicate the element afterTop and push it on the top of the stack.
+    public static void dupSecond(@NotNull InstructionAdapter v, @NotNull Type topOfStack, @NotNull Type afterTop) {
+        if (afterTop.getSize() == 0) {
+            return;
+        }
+
+        if (topOfStack.getSize() == 0) {
+            dup(v, afterTop);
+        } else if (topOfStack.getSize() == 1 && afterTop.getSize() == 1) {
+            v.dup2();
+            v.pop();
+        } else {
+            swap(v, topOfStack, afterTop);
+            if (topOfStack.getSize() == 1 && afterTop.getSize() == 2) {
+                v.dup2X1();
+            } else if (topOfStack.getSize() == 2 && afterTop.getSize() == 1) {
+                v.dupX2();
+            } else /* top = 2, after top = 2 */ {
+                v.dup2X2();
+            }
+        }
+    }
+
+    public static void dup(@NotNull InstructionAdapter v, @NotNull Type topOfStack, @NotNull Type afterTop) {
+        if (topOfStack.getSize() == 0 && afterTop.getSize() == 0) {
+            return;
+        }
+
+        if (topOfStack.getSize() == 0) {
+            dup(v, afterTop);
+        }
+        else if (afterTop.getSize() == 0) {
+            dup(v, topOfStack);
+        }
+        else if (afterTop.getSize() == 1) {
+            if (topOfStack.getSize() == 1) {
+                dup(v, 2);
+            }
+            else {
+                v.dup2X1();
+                v.pop2();
+                v.dupX2();
+                v.dupX2();
+                v.pop();
+                v.dup2X1();
+            }
+        }
+        else {
+            //Note: it's possible to write dup3 and dup4
+            throw new UnsupportedOperationException("Don't know how generate dup3/dup4 for: " + topOfStack + " and " + afterTop);
+        }
+    }
+
+    public static void writeAnnotationData(
+            @NotNull AnnotationVisitor av, @NotNull String[] data, @NotNull String[] strings
+    ) {
+        AnnotationVisitor dataVisitor = av.visitArray(JvmAnnotationNames.METADATA_DATA_FIELD_NAME);
+        for (String string : data) {
+            dataVisitor.visit(null, string);
+        }
+        dataVisitor.visitEnd();
+
+        AnnotationVisitor stringsVisitor = av.visitArray(JvmAnnotationNames.METADATA_STRINGS_FIELD_NAME);
+        for (String string : strings) {
+            stringsVisitor.visit(null, string);
+        }
+        stringsVisitor.visitEnd();
+    }
+
+    @NotNull
+    public static Type asmTypeByFqNameWithoutInnerClasses(@NotNull FqName fqName) {
+        return Type.getObjectType(internalNameByFqNameWithoutInnerClasses(fqName));
+    }
+
+    @NotNull
+    public static Type asmTypeByClassId(@NotNull ClassId classId) {
+        return Type.getObjectType(classId.asString().replace('.', '$'));
+    }
+
+    @NotNull
+    public static String internalNameByFqNameWithoutInnerClasses(@NotNull FqName fqName) {
+        return JvmClassName.byFqNameWithoutInnerClasses(fqName).getInternalName();
+    }
+
+
+    public static void wrapJavaClassIntoKClass(@NotNull InstructionAdapter v) {
+        v.invokestatic(REFLECTION, "getOrCreateKotlinClass", Type.getMethodDescriptor(K_CLASS_TYPE, getType(Class.class)), false);
+    }
+
+    public static void wrapJavaClassesIntoKClasses(@NotNull InstructionAdapter v) {
+        v.invokestatic(REFLECTION, "getOrCreateKotlinClasses", Type.getMethodDescriptor(K_CLASS_ARRAY_TYPE, getType(Class[].class)), false);
+    }
+
+    @Nullable
+    public static Integer getVisibilityAccessFlag(Visibility visibility) {
+        return visibilityToAccessFlag.get(visibility);
+    }
+}

compiler/backend.common.jvm/src/org/jetbrains/kotlin/codegen/CommonVariableAsmNameManglingUtils.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:JvmName("CommonVariableAsmNameManglingUtils")
+package org.jetbrains.kotlin.codegen
+
+import org.jetbrains.kotlin.resolve.jvm.checkers.isValidDalvikCharacter
+
+fun mangleNameIfNeeded(name: String): String {
+    if (name.all { it.isValidCharacter() }) {
+        return name
+    }
+
+    return buildString {
+        for (c in name) {
+            if (c.isValidCharacter()) {
+                append(c)
+            } else {
+                val hexString = Integer.toHexString(c.toInt())
+                assert(hexString.length <= 4)
+                append("_u").append(hexString)
+            }
+        }
+    }
+}
+
+private fun Char.isValidCharacter(): Boolean {
+    return this != '$' && this != '-' && isValidDalvikCharacter(this)
+}

compiler/backend.common.jvm/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -10,7 +10,11 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.PrimitiveType;
 import org.jetbrains.org.objectweb.asm.Type;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 
 public class AsmTypes {
     private static final Map<Class<?>, Type> TYPES_MAP = new HashMap<>();

compiler/backend.common.jvm/src/org/jetbrains/kotlin/resolve/jvm/checkers/dalvikIdentifierUtils.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:JvmName("DalvikIdentifierUtils")
+package org.jetbrains.kotlin.resolve.jvm.checkers
+
+fun isValidDalvikIdentifier(identifier: String): Boolean = identifier.all { isValidDalvikCharacter(it) }
+
+// https://source.android.com/devices/tech/dalvik/dex-format.html#string-syntax
+fun isValidDalvikCharacter(c: Char): Boolean = when (c) {
+    in 'A'..'Z' -> true
+    in 'a'..'z' -> true
+    in '0'..'9' -> true
+    '$', '-', '_' -> true
+    in '\u00a1' .. '\u1fff' -> true
+    in '\u2010' .. '\u2027' -> true
+    in '\u2030' .. '\ud7ff' -> true
+    in '\ue000' .. '\uffef' -> true
+    else -> false
+}

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

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.types
+
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.signature.AsmTypeFactory
+import org.jetbrains.kotlin.load.kotlin.JvmDescriptorTypeWriter
+import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
+import org.jetbrains.kotlin.load.kotlin.mapBuiltInType
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.types.model.*
+import org.jetbrains.org.objectweb.asm.Type
+
+interface TypeMappingContext<Writer : JvmDescriptorTypeWriter<Type>> {
+    val typeContext: TypeSystemCommonBackendContextForTypeMapping
+
+    fun getClassInternalName(typeConstructor: TypeConstructorMarker): String
+    fun Writer.writeGenericType(type: SimpleTypeMarker, asmType: Type, mode: TypeMappingMode)
+}
+
+object AbstractTypeMapper {
+    fun <Writer : JvmDescriptorTypeWriter<Type>> mapClass(context: TypeMappingContext<Writer>, typeConstructor: TypeConstructorMarker): Type {
+        return with(context.typeContext) {
+            when {
+                typeConstructor.isClassTypeConstructor() -> {
+                    mapType(context, typeConstructor.defaultType(), TypeMappingMode.CLASS_DECLARATION)
+                }
+                typeConstructor.isTypeParameter() -> {
+                    mapType(context, typeConstructor.defaultType())
+                }
+                else -> error("Unknown type constructor: $typeConstructor")
+            }
+        }
+    }
+
+    fun <Writer : JvmDescriptorTypeWriter<Type>> mapType(
+        context: TypeMappingContext<Writer>,
+        type: KotlinTypeMarker,
+        mode: TypeMappingMode = TypeMappingMode.DEFAULT,
+        sw: Writer? = null
+    ): Type = context.typeContext.mapType(context, type, mode, sw)
+
+    @OptIn(ExperimentalStdlibApi::class)
+    private fun <Writer : JvmDescriptorTypeWriter<Type>> TypeSystemCommonBackendContextForTypeMapping.mapType(
+        context: TypeMappingContext<Writer>,
+        type: KotlinTypeMarker,
+        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()) {
+            val argumentsCount = type.argumentsCount()
+            val argumentsList = type.asArgumentList()
+
+            @Suppress("RemoveExplicitTypeArguments") // Workaround for KT-42175
+            val arguments = buildList<KotlinTypeMarker> {
+                for (i in 0 until (argumentsCount - 1)) {
+                    this += argumentsList[i].adjustedType()
+                }
+                this += continuationTypeConstructor().typeWithArguments(argumentsList[argumentsCount - 1].adjustedType())
+                this += nullableAnyType()
+            }
+            val runtimeFunctionType = functionNTypeConstructor(arguments.size - 1).typeWithArguments(arguments)
+            return mapType(context, runtimeFunctionType, mode, sw)
+        }
+
+        mapBuiltInType(type, AsmTypeFactory, mode)?.let { builtInType ->
+            return boxTypeIfNeeded(builtInType, mode.needPrimitiveBoxing).also { asmType ->
+                with(context) { sw?.writeGenericType(type, asmType, mode) }
+            }
+        }
+
+        val typeConstructor = type.typeConstructor()
+
+        when {
+            type.isArrayOrNullableArray() -> {
+                val typeArgument = type.asArgumentList()[0]
+                val (variance, memberType) = when {
+                    typeArgument.isStarProjection() -> Variance.OUT_VARIANCE to nullableAnyType()
+                    else -> typeArgument.getVariance().toVariance() to typeArgument.getType()
+                }
+                require(memberType is SimpleTypeMarker)
+
+                val arrayElementType: Type
+                sw?.writeArrayType()
+                if (variance == Variance.IN_VARIANCE) {
+                    arrayElementType = AsmTypes.OBJECT_TYPE
+                    sw?.writeClass(arrayElementType)
+                } else {
+                    arrayElementType = mapType(context, memberType, mode.toGenericArgumentMode(variance, ofArray = true), sw)
+                }
+                sw?.writeArrayEnd()
+                return AsmUtil.getArrayType(arrayElementType)
+            }
+
+            typeConstructor.isClassTypeConstructor() -> {
+                if (typeConstructor.isInlineClass() && !mode.needInlineClassWrapping) {
+                    val expandedType = computeExpandedTypeForInlineClass(type)
+                    require(expandedType is SimpleTypeMarker?)
+                    if (expandedType != null) {
+                        return mapType(context, expandedType, mode.wrapInlineClassesMode(), sw)
+                    }
+                }
+
+                val asmType = if (mode.isForAnnotationParameter && type.isKClass())
+                    AsmTypes.JAVA_CLASS_TYPE
+                else
+                    Type.getObjectType(context.getClassInternalName(typeConstructor))
+
+                with(context) { sw?.writeGenericType(type, asmType, mode) }
+                return asmType
+            }
+
+            typeConstructor.isTypeParameter() -> {
+                val typeParameter = typeConstructor as TypeParameterMarker
+                return mapType(context, typeParameter.representativeUpperBound(), mode, null).also { asmType ->
+                    sw?.writeTypeVariable(typeParameter.getName(), asmType)
+                }
+            }
+
+            else -> throw UnsupportedOperationException("Unknown type $type")
+        }
+    }
+
+    private fun boxTypeIfNeeded(possiblyPrimitiveType: Type, needBoxedType: Boolean): Type =
+        if (needBoxedType) AsmUtil.boxType(possiblyPrimitiveType) else possiblyPrimitiveType
+
+    private fun TypeVariance.toVariance(): Variance = when (this) {
+        TypeVariance.IN -> Variance.IN_VARIANCE
+        TypeVariance.OUT -> Variance.OUT_VARIANCE
+        TypeVariance.INV -> Variance.INVARIANT
+    }
+}

compiler/backend/build.gradle.kts

@@ -10,6 +10,7 @@ dependencies {
     compile(project(":compiler:frontend"))
     compile(project(":compiler:frontend.java"))
     compile(project(":compiler:serialization"))
+    api(project(":compiler:backend.common.jvm"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "asm-all", "guava", rootProject = rootProject) }
     compileOnly(intellijDep()) { includeJars("trove4j", rootProject = rootProject) }
 }

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

@@ -27,7 +27,7 @@ class AccessorForCompanionObjectInstanceFieldDescriptor(
             null, null, emptyList(), emptyList(),
             companionObjectDescriptor.defaultType,
             Modality.FINAL,
-            Visibilities.LOCAL
+            DescriptorVisibilities.LOCAL
         )
     }
 
@@ -41,4 +41,4 @@ class AccessorForCompanionObjectInstanceFieldDescriptor(
     ): FunctionDescriptorImpl {
         throw UnsupportedOperationException("Accessor for companion object $companionObjectDescriptor should not be substituted")
     }
-}
+}

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

@@ -42,11 +42,11 @@ class AccessorForConstructorDescriptor(
     override fun substitute(substitutor: TypeSubstitutor) = super.substitute(substitutor) as ClassConstructorDescriptor
 
     override fun copy(
-        newOwner: DeclarationDescriptor,
-        modality: Modality,
-        visibility: Visibility,
-        kind: CallableMemberDescriptor.Kind,
-        copyOverrides: Boolean
+            newOwner: DeclarationDescriptor,
+            modality: Modality,
+            visibility: DescriptorVisibility,
+            kind: CallableMemberDescriptor.Kind,
+            copyOverrides: Boolean
     ): AccessorForConstructorDescriptor {
         throw UnsupportedOperationException()
     }
@@ -61,7 +61,7 @@ class AccessorForConstructorDescriptor(
             copyValueParameters(calleeDescriptor),
             calleeDescriptor.returnType,
             Modality.FINAL,
-            Visibilities.LOCAL
+            DescriptorVisibilities.LOCAL
         )
     }
 }

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

@@ -43,7 +43,7 @@ class AccessorForFunctionDescriptor(
             copyValueParameters(calleeDescriptor),
             calleeDescriptor.returnType,
             Modality.FINAL,
-            Visibilities.LOCAL
+            DescriptorVisibilities.LOCAL
         )
 
         isSuspend = calleeDescriptor.isSuspend

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

@@ -43,7 +43,7 @@ open class AccessorForPropertyDescriptor private constructor(
     null,
     Annotations.EMPTY,
     Modality.FINAL,
-    Visibilities.LOCAL,
+    DescriptorVisibilities.LOCAL,
     calleeDescriptor.isVar,
     Name.identifier("access$$accessorSuffix"),
     CallableMemberDescriptor.Kind.DECLARATION,
@@ -111,7 +111,7 @@ open class AccessorForPropertyDescriptor private constructor(
         property,
         Annotations.EMPTY,
         Modality.FINAL,
-        Visibilities.LOCAL,
+        DescriptorVisibilities.LOCAL,
         false,
         false,
         false,
@@ -136,7 +136,7 @@ open class AccessorForPropertyDescriptor private constructor(
         property,
         Annotations.EMPTY,
         Modality.FINAL,
-        Visibilities.LOCAL,
+        DescriptorVisibilities.LOCAL,
         false,
         false,
         false,

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

@@ -120,7 +120,7 @@ public abstract class AnnotationCodegen {
             @Nullable Type returnType,
             @Nullable KotlinType typeForTypeAnnotations,
             @Nullable DeclarationDescriptorWithVisibility parameterContainer,
-            @NotNull List<Class<?>> additionalAnnotations
+            @NotNull List<String> additionalVisibleAnnotations
     ) {
         if (annotated == null) return;
 
@@ -142,7 +142,7 @@ public abstract class AnnotationCodegen {
                 && !applicableTargets.contains(KotlinTarget.CLASS)
                 && !applicableTargets.contains(KotlinTarget.ANNOTATION_CLASS)) {
                 ClassDescriptor classDescriptor = (ClassDescriptor) annotated;
-                if (classDescriptor.getVisibility() == Visibilities.LOCAL) {
+                if (classDescriptor.getVisibility() == DescriptorVisibilities.LOCAL) {
                     assert applicableTargets.contains(KotlinTarget.EXPRESSION) :
                             "Inconsistent target list for object literal annotation: " + applicableTargets + " on " + annotated;
                     continue;
@@ -155,9 +155,9 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        for (Class<?> annotation : additionalAnnotations) {
-            String descriptor = generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation);
-            annotationDescriptorsAlreadyPresent.add(descriptor);
+        for (String annotation : additionalVisibleAnnotations) {
+            generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation, true);
+            annotationDescriptorsAlreadyPresent.add(annotation);
         }
 
         generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
@@ -221,7 +221,7 @@ public abstract class AnnotationCodegen {
     private static boolean isInvisibleFromTheOutside(@Nullable DeclarationDescriptor descriptor) {
         if (isAccessor(descriptor)) return true;
         if (descriptor instanceof MemberDescriptor) {
-            return AsmUtil.getVisibilityAccessFlag((MemberDescriptor) descriptor) == Opcodes.ACC_PRIVATE;
+            return DescriptorAsmUtil.getVisibilityAccessFlag((MemberDescriptor) descriptor) == Opcodes.ACC_PRIVATE;
         }
         return false;
     }
@@ -248,17 +248,17 @@ public abstract class AnnotationCodegen {
             if (!TypeUtils.isNullableType(flexibleType.getLowerBound()) && TypeUtils.isNullableType(flexibleType.getUpperBound())) {
                 AnnotationDescriptor notNull = type.getAnnotations().findAnnotation(JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION);
                 if (notNull != null) {
-                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, NotNull.class);
+                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, Type.getType(NotNull.class).getDescriptor(), false);
                 }
                 return;
             }
         }
 
-        boolean isNullableType = TypeUtils.isNullableType(type);
-
-        Class<?> annotationClass = isNullableType ? Nullable.class : NotNull.class;
-
-        generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
+        generateAnnotationIfNotPresent(
+                annotationDescriptorsAlreadyPresent,
+                TypeUtils.isNullableType(type) ? Type.getType(Nullable.class).getDescriptor() : Type.getType(NotNull.class).getDescriptor(),
+                false
+        );
     }
 
     private static final Map<JvmTarget, Map<KotlinTarget, ElementType>> annotationTargetMaps = new EnumMap<>(JvmTarget.class);
@@ -338,13 +338,14 @@ public abstract class AnnotationCodegen {
         visitor.visitEnd();
     }
 
-    @NotNull
-    private String generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
-        String descriptor = Type.getType(annotationClass).getDescriptor();
-        if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) {
-            visitAnnotation(descriptor, false).visitEnd();
+    private void generateAnnotationIfNotPresent(
+            Set<String> annotationDescriptorsAlreadyPresent,
+            String annotationDescriptor,
+            boolean visible
+    ) {
+        if (!annotationDescriptorsAlreadyPresent.contains(annotationDescriptor)) {
+            visitAnnotation(annotationDescriptor, visible).visitEnd();
         }
-        return descriptor;
     }
 
     private static boolean isBareTypeParameterWithNullableUpperBound(@NotNull KotlinType type) {

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.codegen
 
+import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.org.objectweb.asm.Type
@@ -42,7 +43,7 @@ interface Callable {
         }
     }
 
-    fun afterReceiverGeneration(v: InstructionAdapter, frameMap: FrameMap) {
+    fun afterReceiverGeneration(v: InstructionAdapter, frameMap: FrameMap, state: GenerationState) {
     }
 
 }

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

@@ -38,6 +38,7 @@ import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedS
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL;
+import static org.jetbrains.kotlin.util.DeclarationUtilKt.findImplementationFromInterface;
 import static org.jetbrains.kotlin.util.DeclarationUtilKt.findInterfaceImplementation;
 
 public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject> {
@@ -236,9 +237,12 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
             @NotNull GenerationState state,
             boolean isErasedInlineClass
     ) {
+        CallableMemberDescriptor actualImplementation =
+                interfaceFun.getKind().isReal() ? interfaceFun : findImplementationFromInterface(interfaceFun);
+        assert actualImplementation != null : "Can't find actual implementation for " + interfaceFun;
         // Skip Java 8 default methods
-        if (CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) ||
-            JvmAnnotationUtilKt.checkIsImplementationCompiledToJvmDefault(interfaceFun, state.getJvmDefaultMode())) {
+        if (CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(actualImplementation) ||
+            JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(actualImplementation, state.getJvmDefaultMode())) {
             return;
         }
 

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

@@ -50,8 +50,9 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD;
 import static org.jetbrains.kotlin.codegen.CallableReferenceUtilKt.*;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConst;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
@@ -139,7 +140,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
 
         this.asmType = typeMapper.mapClass(classDescriptor);
 
-        visibilityFlag = AsmUtil.getVisibilityAccessFlagForClass(classDescriptor);
+        visibilityFlag = DescriptorAsmUtil.getVisibilityAccessFlagForClass(classDescriptor);
     }
 
     @Override
@@ -589,4 +590,8 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         MemberScope scope = functionClass.getDefaultType().getMemberScope();
         return scope.getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next();
     }
+
+    public boolean isCallableReference() {
+        return functionReferenceTarget != null;
+    }
 }

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

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMapper
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION
@@ -52,13 +52,13 @@ import java.util.*
  * Kotlin's read-only collections. This is required on JVM because Kotlin's read-only collections are mapped to mutable JDK collections
  */
 class CollectionStubMethodGenerator(
-        private val typeMapper: KotlinTypeMapper,
-        private val descriptor: ClassDescriptor
+    private val typeMapper: KotlinTypeMapper,
+    private val descriptor: ClassDescriptor
 ) {
     private data class TasksToGenerate(
-            val methodStubsToGenerate: Set<JvmMethodGenericSignature>,
-            val syntheticStubsToGenerate: Set<JvmMethodGenericSignature>,
-            val bridgesToGenerate: Set<FunctionDescriptor>
+        val methodStubsToGenerate: Set<JvmMethodGenericSignature>,
+        val syntheticStubsToGenerate: Set<JvmMethodGenericSignature>,
+        val bridgesToGenerate: Set<FunctionDescriptor>
     )
 
     companion object {
@@ -70,9 +70,9 @@ class CollectionStubMethodGenerator(
         val superCollectionClasses = findRelevantSuperCollectionClasses()
         if (superCollectionClasses.isEmpty()) return NO_TASKS
 
-        val existingMethodsInSuperclasses = descriptor.getAllSuperclassesWithoutAny().flatMap {
-            val tasksFromSuperClass = CollectionStubMethodGenerator(typeMapper, it).computeTasksToGenerate()
-            (tasksFromSuperClass.methodStubsToGenerate + tasksFromSuperClass.syntheticStubsToGenerate).map { it.asmMethod }
+        val existingMethodsInSuperclasses = descriptor.getAllSuperclassesWithoutAny().flatMap { superClass ->
+            val tasksFromSuperClass = CollectionStubMethodGenerator(typeMapper, superClass).computeTasksToGenerate()
+            (tasksFromSuperClass.methodStubsToGenerate + tasksFromSuperClass.syntheticStubsToGenerate).map { stub -> stub.asmMethod }
         }
 
         val methodStubsToGenerate = LinkedHashSet<JvmMethodGenericSignature>()
@@ -126,43 +126,42 @@ class CollectionStubMethodGenerator(
                         val genericSignatureInfo = overriddenMethod.getSpecialSignatureInfo()
 
                         val specialGenericSignature =
-                                genericSignatureInfo?.replaceValueParametersIn(overriddenMethodSignature.genericsSignature)
+                            genericSignatureInfo?.replaceValueParametersIn(overriddenMethodSignature.genericsSignature)
                                 ?: overriddenMethodSignature.genericsSignature
 
                         val (asmMethod, valueParameters) =
-                                // if current method has special generic signature,
-                                // like `Collection.remove(E): Boolean` in Kotlin, use original signature to obtain `remove(Object)`
-                                if (genericSignatureInfo?.isObjectReplacedWithTypeParameter ?: false)
-                                    Pair(originalSignature.asmMethod, originalSignature.valueParameters)
-                                else
-                                    Pair(overriddenMethodSignature.asmMethod, overriddenMethodSignature.valueParameters)
+                        // if current method has special generic signature,
+                            // like `Collection.remove(E): Boolean` in Kotlin, use original signature to obtain `remove(Object)`
+                            if (genericSignatureInfo?.isObjectReplacedWithTypeParameter == true)
+                                Pair(originalSignature.asmMethod, originalSignature.valueParameters)
+                            else
+                                Pair(overriddenMethodSignature.asmMethod, overriddenMethodSignature.valueParameters)
 
                         JvmMethodGenericSignature(
-                                asmMethod,
-                                valueParameters,
-                                specialGenericSignature
+                            asmMethod,
+                            valueParameters,
+                            specialGenericSignature
                         )
-                    }
-                    else {
+                    } else {
                         method.signature()
                     }
 
                     if (commonSignature.asmMethod !in existingMethodsInSuperclasses &&
-                            // If original method already defined in a superclass we mustn't care about specialized version
-                            // The same way we do not generate specialized version in a common case like:
-                            // open class A<T> : MutableList<T> {
-                            //      fun add(x: T) = true
-                            // }
-                            // class B : A<String>() // No 'B.add(String)Z'
-                            originalSignature.asmMethod !in existingMethodsInSuperclasses) {
+                        // If original method already defined in a superclass we mustn't care about specialized version
+                        // The same way we do not generate specialized version in a common case like:
+                        // open class A<T> : MutableList<T> {
+                        //      fun add(x: T) = true
+                        // }
+                        // class B : A<String>() // No 'B.add(String)Z'
+                        originalSignature.asmMethod !in existingMethodsInSuperclasses
+                    ) {
                         methodStubsToGenerate.add(commonSignature)
 
                         if (originalSignature.asmMethod != commonSignature.asmMethod) {
                             syntheticStubsToGenerate.add(originalSignature)
                         }
                     }
-                }
-                else {
+                } else {
                     // If the fake override is non-abstract, its implementation is already present in the class or inherited from one of its
                     // super classes, but is not related to the MutableCollection hierarchy. So maybe it uses more specific return types
                     // and we may need to generate some bridges
@@ -192,13 +191,13 @@ class CollectionStubMethodGenerator(
 
     private fun isDefaultInJdk(method: FunctionDescriptor) =
         method.modality != Modality.ABSTRACT &&
-        method.original.overriddenTreeUniqueAsSequence(useOriginal = true).all {
-            it.kind == FAKE_OVERRIDE || KotlinBuiltIns.isBuiltIn(it)
-        }
+                method.original.overriddenTreeUniqueAsSequence(useOriginal = true).all {
+                    it.kind == FAKE_OVERRIDE || KotlinBuiltIns.isBuiltIn(it)
+                }
 
     private data class CollectionClassPair(
-            val readOnlyClass: TypeConstructor,
-            val mutableClass: TypeConstructor
+        val readOnlyClass: TypeConstructor,
+        val mutableClass: TypeConstructor
     )
 
     private fun findRelevantSuperCollectionClasses(): Collection<CollectionClassPair> {
@@ -206,14 +205,14 @@ class CollectionStubMethodGenerator(
 
         val collectionClasses = with(descriptor.builtIns) {
             listOf(
-                    collection to mutableCollection,
-                    set to mutableSet,
-                    list to mutableList,
-                    map to mutableMap,
-                    mapEntry to mutableMapEntry,
-                    iterable to mutableIterable,
-                    iterator to mutableIterator,
-                    listIterator to mutableListIterator
+                collection to mutableCollection,
+                set to mutableSet,
+                list to mutableList,
+                map to mutableMap,
+                mapEntry to mutableMapEntry,
+                iterable to mutableIterable,
+                iterator to mutableIterator,
+                listIterator to mutableListIterator
             ).map { (readOnly, mutable) ->
                 pair(readOnly.typeConstructor, mutable.typeConstructor)
             }
@@ -234,15 +233,16 @@ class CollectionStubMethodGenerator(
     }
 
     private fun findFakeOverridesForMethodsFromMutableCollection(
-            klass: ClassDescriptor,
-            mutableCollectionTypeConstructor: TypeConstructor
+        klass: ClassDescriptor,
+        mutableCollectionTypeConstructor: TypeConstructor
     ): List<FunctionDescriptor> {
         val result = ArrayList<FunctionDescriptor>()
 
         generateOverridesInAClass(klass, object : NonReportingOverrideStrategy() {
             override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                 if (fakeOverride !is FunctionDescriptor) return
-                val foundOverriddenFromDirectSuperClass = fakeOverride.findOverriddenFromDirectSuperClass(mutableCollectionTypeConstructor) ?: return
+                val foundOverriddenFromDirectSuperClass =
+                    fakeOverride.findOverriddenFromDirectSuperClass(mutableCollectionTypeConstructor) ?: return
                 if (foundOverriddenFromDirectSuperClass.kind == DECLARATION) {
                     // For regular classes there should no be fake overrides having return types incompatible with return types of their
                     // overridden, while here it's possible to create declaration like `fun remove(e: E): ImmutableCollection<E>`
@@ -254,23 +254,29 @@ class CollectionStubMethodGenerator(
                     // `fun iterator(): CharIterator` defined in read-only collection
                     // The problem is that 'CharIterator' is not a subtype of 'MutableIterator' while from Java's point of view it is,
                     // so we must hack our subtyping a little bit
-                     val newDescriptor =
-                            if (READ_ONLY_ARE_EQUAL_TO_MUTABLE_TYPE_CHECKER.isSubtypeOf(
-                                    fakeOverride.returnType!!, foundOverriddenFromDirectSuperClass.returnType!!))
-                                fakeOverride
-                            else
-                                foundOverriddenFromDirectSuperClass.copy(
-                                        fakeOverride.containingDeclaration,
-                                        foundOverriddenFromDirectSuperClass.modality,
-                                        foundOverriddenFromDirectSuperClass.visibility,
-                                        fakeOverride.kind, false)
+                    val newDescriptor =
+                        if (READ_ONLY_ARE_EQUAL_TO_MUTABLE_TYPE_CHECKER.isSubtypeOf(
+                                fakeOverride.returnType!!,
+                                foundOverriddenFromDirectSuperClass.returnType!!
+                            )
+                        )
+                            fakeOverride
+                        else
+                            foundOverriddenFromDirectSuperClass.copy(
+                                fakeOverride.containingDeclaration,
+                                foundOverriddenFromDirectSuperClass.modality,
+                                foundOverriddenFromDirectSuperClass.visibility,
+                                fakeOverride.kind, false
+                            )
 
                     newDescriptor.overriddenDescriptors =
-                            fakeOverride.overriddenDescriptors.filter {
-                                superDescriptor ->
-                                // filter out incompatible descriptors, e.g. `fun remove(e: E): ImmutableCollection<E>` for `fun remove(e: E): Boolean`
-                                READ_ONLY_ARE_EQUAL_TO_MUTABLE_TYPE_CHECKER.isSubtypeOf(newDescriptor.returnType!!, superDescriptor.returnType!!)
-                            }
+                        fakeOverride.overriddenDescriptors.filter { superDescriptor ->
+                            // filter out incompatible descriptors, e.g. `fun remove(e: E): ImmutableCollection<E>` for `fun remove(e: E): Boolean`
+                            READ_ONLY_ARE_EQUAL_TO_MUTABLE_TYPE_CHECKER.isSubtypeOf(
+                                newDescriptor.returnType!!,
+                                superDescriptor.returnType!!
+                            )
+                        }
 
                     result.add(newDescriptor)
                 }
@@ -298,11 +304,11 @@ class CollectionStubMethodGenerator(
     private fun generateOverridesInAClass(classDescriptor: ClassDescriptor, strategy: OverridingStrategy) {
         @Suppress("UNCHECKED_CAST")
         val membersFromSupertypesByName =
-                classDescriptor.typeConstructor.supertypes.flatMapTo(linkedSetOf()) { type ->
-                    DescriptorUtils.getAllDescriptors(type.memberScope).filter {
-                        it is PropertyDescriptor || it is SimpleFunctionDescriptor
-                    } as List<CallableMemberDescriptor>
-                }.groupBy { it.name }
+            classDescriptor.typeConstructor.supertypes.flatMapTo(linkedSetOf()) { type ->
+                DescriptorUtils.getAllDescriptors(type.memberScope).filter {
+                    it is PropertyDescriptor || it is SimpleFunctionDescriptor
+                } as List<CallableMemberDescriptor>
+            }.groupBy { it.name }
 
         for ((name, fromSupertypes) in membersFromSupertypesByName) {
             OverridingUtil.DEFAULT.generateOverridesInFunctionGroup(name, fromSupertypes, emptyList(), classDescriptor, strategy)
@@ -321,7 +327,7 @@ class CollectionStubMethodGenerator(
         )
 
         child.modality = Modality.FINAL
-        child.visibility = Visibilities.PUBLIC
+        child.visibility = DescriptorVisibilities.PUBLIC
         val typeParameters = descriptor.typeConstructor.parameters
         val newTypeParameters = ArrayList<TypeParameterDescriptor>(typeParameters.size)
         DescriptorSubstitutor.substituteTypeParameters(typeParameters, TypeSubstitution.EMPTY, child, newTypeParameters)
@@ -330,15 +336,16 @@ class CollectionStubMethodGenerator(
     }
 
     private fun FunctionDescriptor.findOverriddenFromDirectSuperClass(typeConstructor: TypeConstructor): FunctionDescriptor? =
-            this.overriddenDescriptors.firstOrNull {
-                (it.containingDeclaration as? ClassDescriptor)?.typeConstructor == typeConstructor
-            }
+        this.overriddenDescriptors.firstOrNull {
+            (it.containingDeclaration as? ClassDescriptor)?.typeConstructor == typeConstructor
+        }
 
     private fun newType(classDescriptor: ClassDescriptor, typeArguments: List<TypeProjection>): KotlinType {
         return KotlinTypeFactory.simpleNotNullType(Annotations.EMPTY, classDescriptor, typeArguments)
     }
 
-    private fun FunctionDescriptor.signature(): JvmMethodGenericSignature = typeMapper.mapSignatureWithGeneric(this, OwnerKind.IMPLEMENTATION)
+    private fun FunctionDescriptor.signature(): JvmMethodGenericSignature =
+        typeMapper.mapSignatureWithGeneric(this, OwnerKind.IMPLEMENTATION)
 
     private fun generateMethodStub(v: ClassBuilder, signature: JvmMethodGenericSignature, synthetic: Boolean) {
         assert(descriptor.kind != ClassKind.INTERFACE) { "No stubs should be generated for interface ${descriptor.fqNameUnsafe}" }
@@ -349,9 +356,10 @@ class CollectionStubMethodGenerator(
         val mv = v.newMethod(CollectionStub, access, asmMethod.name, asmMethod.descriptor, genericSignature, null)
         mv.visitCode()
         AsmUtil.genThrow(
-                InstructionAdapter(mv),
-                "java/lang/UnsupportedOperationException",
-                "Operation is not supported for read-only collection")
+            InstructionAdapter(mv),
+            "java/lang/UnsupportedOperationException",
+            "Operation is not supported for read-only collection"
+        )
         FunctionCodegen.endVisit(mv, "built-in stub for $signature")
     }
 }
@@ -360,7 +368,7 @@ private val READ_ONLY_ARE_EQUAL_TO_MUTABLE_TYPE_CHECKER = KotlinTypeCheckerImpl.
     val firstClass = x.declarationDescriptor as? ClassDescriptor ?: return@withAxioms x == y
     val secondClass = y.declarationDescriptor as? ClassDescriptor ?: return@withAxioms x == y
 
-    val j2k = JavaToKotlinClassMap
+    val j2k = JavaToKotlinClassMapper
     val firstReadOnly = if (j2k.isMutable(firstClass)) j2k.convertMutableToReadOnly(firstClass) else firstClass
     val secondReadOnly = if (j2k.isMutable(secondClass)) j2k.convertMutableToReadOnly(secondClass) else secondClass
     firstReadOnly.typeConstructor == secondReadOnly.typeConstructor

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

@@ -298,7 +298,7 @@ public class ConstructorCodegen {
 
             int k = 1;
             for (FieldInfo info : argsFromClosure) {
-                k = AsmUtil.genAssignInstanceFieldFromParam(info, k, iv);
+                k = DescriptorAsmUtil.genAssignInstanceFieldFromParam(info, k, iv);
             }
         }
     }

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

@@ -127,8 +127,8 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
         substituteCount: Int
     ) {
         val typeMapper = state.typeMapper
-        val isStatic = AsmUtil.isStaticMethod(contextKind, functionDescriptor)
-        val baseMethodFlags = AsmUtil.getCommonCallableFlags(functionDescriptor, state) and Opcodes.ACC_VARARGS.inv()
+        val isStatic = DescriptorAsmUtil.isStaticMethod(contextKind, functionDescriptor)
+        val baseMethodFlags = DescriptorAsmUtil.getCommonCallableFlags(functionDescriptor, state) and Opcodes.ACC_VARARGS.inv()
         val remainingParameters = getRemainingParameters(functionDescriptor.original, substituteCount)
         val remainingParametersDeclarations =
             remainingParameters.map { DescriptorToSourceUtils.descriptorToDeclaration(it) as? KtParameter }
@@ -268,7 +268,7 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
 
         if (CodegenBinding.canHaveOuter(state.bindingContext, classDescriptor)) return false
 
-        if (Visibilities.isPrivate(constructorDescriptor.visibility)) return false
+        if (DescriptorVisibilities.isPrivate(constructorDescriptor.visibility)) return false
 
         if (constructorDescriptor.valueParameters.isEmpty()) return false
         if (classOrObject is KtClass && hasSecondaryConstructorsWithNoParameters(classOrObject)) return false

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

@@ -0,0 +1,897 @@
+/*
+ * Copyright 2010-2018 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;
+
+import com.intellij.openapi.util.Pair;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.util.ArrayUtil;
+import kotlin.Unit;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
+import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
+import org.jetbrains.kotlin.codegen.context.CodegenContext;
+import org.jetbrains.kotlin.codegen.intrinsics.HashCode;
+import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods;
+import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
+import org.jetbrains.kotlin.config.JvmDefaultMode;
+import org.jetbrains.kotlin.config.JvmTarget;
+import org.jetbrains.kotlin.config.LanguageFeature;
+import org.jetbrains.kotlin.config.LanguageVersionSettings;
+import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil;
+import org.jetbrains.kotlin.metadata.jvm.serialization.JvmStringTable;
+import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.protobuf.MessageLite;
+import org.jetbrains.kotlin.renderer.DescriptorRenderer;
+import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.DescriptorUtils;
+import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver;
+import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
+import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver;
+import org.jetbrains.kotlin.resolve.inline.InlineUtil;
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
+import org.jetbrains.kotlin.resolve.jvm.InlineClassManglingRulesKt;
+import org.jetbrains.kotlin.resolve.jvm.RuntimeAssertionInfo;
+import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
+import org.jetbrains.kotlin.serialization.DescriptorSerializer;
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
+import org.jetbrains.kotlin.types.KotlinType;
+import org.jetbrains.kotlin.types.SimpleType;
+import org.jetbrains.org.objectweb.asm.*;
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isBoolean;
+import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isPrimitiveClass;
+import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isToArrayFromCollection;
+import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation;
+import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
+import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
+import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
+import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineWithReified;
+import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
+import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmSyntheticAnnotation;
+import static org.jetbrains.kotlin.types.TypeUtils.isNullableType;
+import static org.jetbrains.org.objectweb.asm.Opcodes.*;
+
+public class DescriptorAsmUtil {
+    private DescriptorAsmUtil() {
+    }
+
+    @NotNull
+    public static String getNameForCapturedReceiverField(
+            @NotNull CallableDescriptor descriptor,
+            @NotNull BindingContext bindingContext,
+            @NotNull LanguageVersionSettings languageVersionSettings
+    ) {
+        return getLabeledThisNameForReceiver(
+                descriptor, bindingContext, languageVersionSettings, LABELED_THIS_FIELD, CAPTURED_RECEIVER_FIELD);
+    }
+
+    @NotNull
+    public static String getNameForReceiverParameter(
+            @NotNull CallableDescriptor descriptor,
+            @NotNull BindingContext bindingContext,
+            @NotNull LanguageVersionSettings languageVersionSettings
+    ) {
+        return getLabeledThisNameForReceiver(
+                descriptor, bindingContext, languageVersionSettings, LABELED_THIS_PARAMETER, RECEIVER_PARAMETER_NAME);
+    }
+
+    @NotNull
+    private static String getLabeledThisNameForReceiver(
+            @NotNull CallableDescriptor descriptor,
+            @NotNull BindingContext bindingContext,
+            @NotNull LanguageVersionSettings languageVersionSettings,
+            @NotNull String prefix,
+            @NotNull String defaultName
+    ) {
+        if (!languageVersionSettings.supportsFeature(LanguageFeature.NewCapturedReceiverFieldNamingConvention)) {
+            return defaultName;
+        }
+
+        Name callableName = null;
+
+        if (descriptor instanceof FunctionDescriptor) {
+            String labelName = bindingContext.get(CodegenBinding.CALL_LABEL_FOR_LAMBDA_ARGUMENT, (FunctionDescriptor) descriptor);
+            if (labelName != null) {
+                return getLabeledThisName(labelName, prefix, defaultName);
+            }
+
+            if (descriptor instanceof VariableAccessorDescriptor) {
+                VariableAccessorDescriptor accessor = (VariableAccessorDescriptor) descriptor;
+                callableName = accessor.getCorrespondingVariable().getName();
+            }
+        }
+
+        if (callableName == null) {
+            callableName = descriptor.getName();
+        }
+
+        if (callableName.isSpecial()) {
+            return defaultName;
+        }
+
+        return getLabeledThisName(callableName.asString(), prefix, defaultName);
+    }
+
+    @NotNull
+    public static Type boxType(@NotNull Type type, @NotNull KotlinType kotlinType, @NotNull KotlinTypeMapper typeMapper) {
+        if (InlineClassesUtilsKt.isInlineClassType(kotlinType)) {
+            return typeMapper.mapTypeAsDeclaration(kotlinType);
+        }
+
+        Type boxedPrimitiveType = boxPrimitiveType(type);
+        return boxedPrimitiveType != null ? boxedPrimitiveType : type;
+    }
+
+    public static boolean isPrimitiveNumberClassDescriptor(DeclarationDescriptor descriptor) {
+        if (!(descriptor instanceof ClassDescriptor)) {
+            return false;
+        }
+        return isPrimitiveClass((ClassDescriptor) descriptor) && !isBoolean((ClassDescriptor) descriptor);
+    }
+
+    public static boolean isAbstractMethod(FunctionDescriptor functionDescriptor, OwnerKind kind, JvmDefaultMode jvmDefaultMode) {
+        return (functionDescriptor.getModality() == Modality.ABSTRACT ||
+                (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !JvmAnnotationUtilKt
+                        .isCompiledToJvmDefault(functionDescriptor, jvmDefaultMode)))
+               && !isStaticMethod(kind, functionDescriptor);
+    }
+
+    public static boolean isStaticMethod(OwnerKind kind, CallableMemberDescriptor functionDescriptor) {
+        return isStaticKind(kind) ||
+               KotlinTypeMapper.isStaticAccessor(functionDescriptor) ||
+               CodegenUtilKt.isJvmStaticInObjectOrClassOrInterface(functionDescriptor);
+    }
+
+    public static boolean isStaticKind(OwnerKind kind) {
+        return kind == OwnerKind.PACKAGE || kind == OwnerKind.DEFAULT_IMPLS || kind == OwnerKind.ERASED_INLINE_CLASS;
+    }
+
+    public static int getMethodAsmFlags(FunctionDescriptor functionDescriptor, OwnerKind kind, GenerationState state) {
+        return getMethodAsmFlags(functionDescriptor, kind, state.getDeprecationProvider(), state.getJvmDefaultMode());
+    }
+
+    public static int getMethodAsmFlags(
+            FunctionDescriptor functionDescriptor,
+            OwnerKind kind,
+            DeprecationResolver deprecationResolver,
+            JvmDefaultMode jvmDefaultMode
+    ) {
+        int flags = getCommonCallableFlags(functionDescriptor, kind, deprecationResolver);
+
+        for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.METHOD_FLAGS) {
+            flags |= flagAnnotation.getJvmFlag(functionDescriptor.getOriginal());
+        }
+
+        if (functionDescriptor.getOriginal().isExternal()) {
+            flags |= Opcodes.ACC_NATIVE;
+        }
+
+        if (CodegenUtilKt.isJvmStaticInCompanionObject(functionDescriptor)) {
+            // Native method will be a member of the class, the companion object method will be delegated to it
+            flags &= ~Opcodes.ACC_NATIVE;
+        }
+
+        if (functionDescriptor.getModality() == Modality.FINAL && !(functionDescriptor instanceof ConstructorDescriptor)) {
+            DeclarationDescriptor containingDeclaration = functionDescriptor.getContainingDeclaration();
+            if (!(containingDeclaration instanceof ClassDescriptor) ||
+                ((ClassDescriptor) containingDeclaration).getKind() != ClassKind.INTERFACE) {
+                flags |= ACC_FINAL;
+            }
+        }
+
+        if (isStaticMethod(kind, functionDescriptor)) {
+            flags |= ACC_STATIC;
+        }
+
+        if (isAbstractMethod(functionDescriptor, kind, jvmDefaultMode)) {
+            flags |= ACC_ABSTRACT;
+        }
+
+        if (KotlinTypeMapper.isAccessor(functionDescriptor) ||
+            hasJvmSyntheticAnnotation(functionDescriptor) ||
+            isInlineClassWrapperConstructor(functionDescriptor, kind) ||
+            InlineClassDescriptorResolver.isSynthesizedBoxMethod(functionDescriptor) ||
+            InlineClassDescriptorResolver.isSynthesizedUnboxMethod(functionDescriptor)
+        ) {
+            flags |= ACC_SYNTHETIC;
+        }
+
+        return flags;
+    }
+
+    private static boolean isInlineClassWrapperConstructor(@NotNull FunctionDescriptor functionDescriptor, @Nullable OwnerKind kind) {
+        if (!(functionDescriptor instanceof ConstructorDescriptor)) return false;
+        ClassDescriptor classDescriptor = ((ConstructorDescriptor) functionDescriptor).getConstructedClass();
+        return classDescriptor.isInline() && kind == OwnerKind.IMPLEMENTATION;
+    }
+
+    public static int getCommonCallableFlags(FunctionDescriptor functionDescriptor, @NotNull GenerationState state) {
+        return getCommonCallableFlags(functionDescriptor, null, state.getDeprecationProvider());
+    }
+
+    private static int getCommonCallableFlags(
+            FunctionDescriptor functionDescriptor,
+            @Nullable OwnerKind kind,
+            @NotNull DeprecationResolver deprecationResolver
+    ) {
+        int flags = getVisibilityAccessFlag(functionDescriptor, kind);
+        flags |= getVarargsFlag(functionDescriptor);
+        flags |= getDeprecatedAccessFlag(functionDescriptor);
+        if (deprecationResolver.isDeprecatedHidden(functionDescriptor) ||
+            isInlineWithReified(functionDescriptor) ||
+            functionDescriptor.isSuspend() && functionDescriptor.getVisibility().equals(DescriptorVisibilities.PRIVATE)) {
+            flags |= ACC_SYNTHETIC;
+        }
+        return flags;
+    }
+
+    public static int getVisibilityAccessFlag(@NotNull MemberDescriptor descriptor) {
+        return getVisibilityAccessFlag(descriptor, null);
+    }
+
+    private static int getVisibilityAccessFlag(@NotNull MemberDescriptor descriptor, @Nullable OwnerKind kind) {
+        Integer specialCase = specialCaseVisibility(descriptor, kind);
+        if (specialCase != null) {
+            return specialCase;
+        }
+        DescriptorVisibility visibility = descriptor.getVisibility();
+        Integer defaultMapping = getVisibilityAccessFlag(visibility);
+        if (defaultMapping == null) {
+            throw new IllegalStateException(visibility + " is not a valid visibility in backend for " + DescriptorRenderer.DEBUG_TEXT.render(descriptor));
+        }
+        return defaultMapping;
+    }
+
+    @Nullable
+    public static Integer getVisibilityAccessFlag(DescriptorVisibility visibility) {
+        return AsmUtil.getVisibilityAccessFlag(visibility.getDelegate());
+    }
+
+    /*
+        Use this method to get visibility flag for class to define it in byte code (v.defineClass method).
+        For other cases use getVisibilityAccessFlag(MemberDescriptor descriptor)
+        Classes in byte code should be public or package private
+     */
+    public static int getVisibilityAccessFlagForClass(@NotNull ClassDescriptor descriptor) {
+        if (descriptor instanceof SyntheticClassDescriptorForLambda) {
+            return getVisibilityAccessFlagForAnonymous(descriptor);
+        }
+        if (descriptor.getKind() == ClassKind.ENUM_ENTRY) {
+            return NO_FLAG_PACKAGE_PRIVATE;
+        }
+        if (descriptor.getVisibility() == DescriptorVisibilities.PUBLIC ||
+            descriptor.getVisibility() == DescriptorVisibilities.PROTECTED ||
+            // TODO: should be package private, but for now Kotlin's reflection can't access members of such classes
+            descriptor.getVisibility() == DescriptorVisibilities.LOCAL ||
+            descriptor.getVisibility() == DescriptorVisibilities.INTERNAL) {
+            return ACC_PUBLIC;
+        }
+        return NO_FLAG_PACKAGE_PRIVATE;
+    }
+
+    private static int getVisibilityAccessFlagForAnonymous(@NotNull ClassDescriptor descriptor) {
+        return InlineUtil.isInlineOrContainingInline(descriptor.getContainingDeclaration()) ? ACC_PUBLIC : NO_FLAG_PACKAGE_PRIVATE;
+    }
+
+    public static int getSyntheticAccessFlagForLambdaClass(@NotNull ClassDescriptor descriptor) {
+        return descriptor instanceof SyntheticClassDescriptorForLambda &&
+               ((SyntheticClassDescriptorForLambda) descriptor).isCallableReference() ? ACC_SYNTHETIC : 0;
+    }
+
+    public static int calculateInnerClassAccessFlags(@NotNull ClassDescriptor innerClass) {
+        int visibility =
+                innerClass instanceof SyntheticClassDescriptorForLambda
+                ? getVisibilityAccessFlagForAnonymous(innerClass)
+                : innerClass.getVisibility() == DescriptorVisibilities.LOCAL
+                  ? ACC_PUBLIC
+                  : getVisibilityAccessFlag(innerClass);
+        return visibility |
+               getSyntheticAccessFlagForLambdaClass(innerClass) |
+               innerAccessFlagsForModalityAndKind(innerClass) |
+               (innerClass.isInner() ? 0 : ACC_STATIC);
+    }
+
+    private static int innerAccessFlagsForModalityAndKind(@NotNull ClassDescriptor innerClass) {
+        switch (innerClass.getKind()) {
+            case INTERFACE:
+                return ACC_ABSTRACT | ACC_INTERFACE;
+            case ENUM_CLASS:
+                return ACC_FINAL | ACC_ENUM;
+            case ANNOTATION_CLASS:
+                return ACC_ABSTRACT | ACC_ANNOTATION | ACC_INTERFACE;
+            default:
+                Modality modality = innerClass.getModality();
+                if (modality == Modality.FINAL) {
+                    return ACC_FINAL;
+                }
+                else if (modality == Modality.ABSTRACT || modality == Modality.SEALED) {
+                    return ACC_ABSTRACT;
+                }
+        }
+        return 0;
+    }
+
+    public static int getDeprecatedAccessFlag(@NotNull MemberDescriptor descriptor) {
+        if (descriptor instanceof PropertyAccessorDescriptor) {
+            return KotlinBuiltIns.isDeprecated(descriptor)
+                   ? ACC_DEPRECATED
+                   : getDeprecatedAccessFlag(((PropertyAccessorDescriptor) descriptor).getCorrespondingProperty());
+        }
+        else if (KotlinBuiltIns.isDeprecated(descriptor)) {
+            return ACC_DEPRECATED;
+        }
+        return 0;
+    }
+
+    private static int getVarargsFlag(FunctionDescriptor functionDescriptor) {
+        if (!functionDescriptor.getValueParameters().isEmpty()
+            && functionDescriptor.getValueParameters().get(functionDescriptor.getValueParameters().size() - 1)
+                       .getVarargElementType() != null) {
+            return ACC_VARARGS;
+        }
+        return 0;
+    }
+
+    @Nullable
+    private static Integer specialCaseVisibility(@NotNull MemberDescriptor memberDescriptor, @Nullable OwnerKind kind) {
+        DeclarationDescriptor containingDeclaration = memberDescriptor.getContainingDeclaration();
+        DescriptorVisibility memberVisibility = memberDescriptor.getVisibility();
+
+        if (JvmCodegenUtil.isNonIntrinsicPrivateCompanionObjectInInterface(memberDescriptor)) {
+            return ACC_PUBLIC;
+        }
+
+        if (memberDescriptor instanceof FunctionDescriptor &&
+            isInlineClassWrapperConstructor((FunctionDescriptor) memberDescriptor, kind)) {
+            return ACC_PRIVATE;
+        }
+
+        if (kind != OwnerKind.ERASED_INLINE_CLASS &&
+            memberDescriptor instanceof ConstructorDescriptor &&
+            !(memberDescriptor instanceof AccessorForConstructorDescriptor) &&
+            InlineClassManglingRulesKt.shouldHideConstructorDueToInlineClassTypeValueParameters((ConstructorDescriptor) memberDescriptor)
+        ) {
+            return ACC_PRIVATE;
+        }
+
+        if (isInlineOnlyPrivateInBytecode(memberDescriptor)) {
+            return ACC_PRIVATE;
+        }
+
+        if (memberVisibility == DescriptorVisibilities.LOCAL && memberDescriptor instanceof CallableMemberDescriptor) {
+            return ACC_PUBLIC;
+        }
+
+        if (isEnumEntry(memberDescriptor)) {
+            return NO_FLAG_PACKAGE_PRIVATE;
+        }
+
+        if (isToArrayFromCollection(memberDescriptor)) {
+            return ACC_PUBLIC;
+        }
+
+        if (memberDescriptor instanceof ConstructorDescriptor && isAnonymousObject(memberDescriptor.getContainingDeclaration())) {
+            return getVisibilityAccessFlagForAnonymous((ClassDescriptor) memberDescriptor.getContainingDeclaration());
+        }
+
+        if (memberDescriptor instanceof SyntheticJavaPropertyDescriptor) {
+            return getVisibilityAccessFlag(((SyntheticJavaPropertyDescriptor) memberDescriptor).getGetMethod());
+        }
+        if (memberDescriptor instanceof PropertyAccessorDescriptor) {
+            PropertyDescriptor property = ((PropertyAccessorDescriptor) memberDescriptor).getCorrespondingProperty();
+            if (property instanceof SyntheticJavaPropertyDescriptor) {
+                FunctionDescriptor method = memberDescriptor == property.getGetter()
+                                            ? ((SyntheticJavaPropertyDescriptor) property).getGetMethod()
+                                            : ((SyntheticJavaPropertyDescriptor) property).getSetMethod();
+                assert method != null : "No get/set method in SyntheticJavaPropertyDescriptor: " + property;
+                return getVisibilityAccessFlag(method);
+            }
+        }
+
+        if (memberDescriptor instanceof CallableDescriptor && memberVisibility == DescriptorVisibilities.PROTECTED) {
+            for (CallableDescriptor overridden : DescriptorUtils.getAllOverriddenDescriptors((CallableDescriptor) memberDescriptor)) {
+                if (isJvmInterface(overridden.getContainingDeclaration())) {
+                    return ACC_PUBLIC;
+                }
+            }
+        }
+
+        if (!DescriptorVisibilities.isPrivate(memberVisibility)) {
+            return null;
+        }
+
+        if (memberDescriptor instanceof FunctionDescriptor && ((FunctionDescriptor) memberDescriptor).isSuspend()) {
+            return NO_FLAG_PACKAGE_PRIVATE;
+        }
+
+        if (memberDescriptor instanceof AccessorForCompanionObjectInstanceFieldDescriptor) {
+            return NO_FLAG_PACKAGE_PRIVATE;
+        }
+
+        if (memberDescriptor instanceof ConstructorDescriptor && isEnumEntry(containingDeclaration)) {
+            return NO_FLAG_PACKAGE_PRIVATE;
+        }
+
+        return null;
+    }
+
+    public static void genClosureFields(
+            @NotNull CalculatedClosure closure,
+            ClassBuilder v,
+            KotlinTypeMapper typeMapper,
+            @NotNull LanguageVersionSettings languageVersionSettings
+    ) {
+        List<Pair<String, Type>> allFields = new ArrayList<>();
+
+        ClassifierDescriptor captureThis = closure.getCapturedOuterClassDescriptor();
+        if (captureThis != null) {
+            allFields.add(Pair.create(CAPTURED_THIS_FIELD, typeMapper.mapType(captureThis)));
+        }
+
+        KotlinType captureReceiverType = closure.getCapturedReceiverFromOuterContext();
+        if (captureReceiverType != null && !CallableReferenceUtilKt.isForCallableReference(closure)) {
+            String fieldName = closure.getCapturedReceiverFieldName(typeMapper.getBindingContext(), languageVersionSettings);
+            allFields.add(Pair.create(fieldName, typeMapper.mapType(captureReceiverType)));
+        }
+
+        allFields.addAll(closure.getRecordedFields());
+        genClosureFields(allFields, v);
+    }
+
+    public static void genClosureFields(List<Pair<String, Type>> allFields, ClassBuilder builder) {
+        int access = NO_FLAG_PACKAGE_PRIVATE | ACC_SYNTHETIC | ACC_FINAL;
+        for (Pair<String, Type> field : allFields) {
+            builder.newField(JvmDeclarationOrigin.NO_ORIGIN, access, field.first, field.second.getDescriptor(), null, null);
+        }
+    }
+
+    public static int genAssignInstanceFieldFromParam(FieldInfo info, int index, InstructionAdapter iv) {
+        return genAssignInstanceFieldFromParam(info, index, iv, 0, false);
+    }
+
+    public static int genAssignInstanceFieldFromParam(
+            FieldInfo info,
+            int index,
+            InstructionAdapter iv,
+            int ownerIndex,
+            boolean cast
+    ) {
+        assert !info.isStatic();
+        Type fieldType = info.getFieldType();
+        KotlinType fieldKotlinType = info.getFieldKotlinType();
+        KotlinType nullableAny;
+        if (fieldKotlinType != null) {
+            nullableAny = fieldKotlinType.getConstructor().getBuiltIns().getNullableAnyType();
+        } else {
+            nullableAny = null;
+        }
+
+        iv.load(ownerIndex, info.getOwnerType());//this
+        if (cast) {
+            iv.load(index, AsmTypes.OBJECT_TYPE); //param
+            StackValue.coerce(AsmTypes.OBJECT_TYPE, nullableAny, fieldType, fieldKotlinType, iv);
+        } else {
+            iv.load(index, fieldType); //param
+        }
+        iv.visitFieldInsn(PUTFIELD, info.getOwnerInternalName(), info.getFieldName(), fieldType.getDescriptor());
+        index += fieldType.getSize();
+        return index;
+    }
+
+    public static void genInvokeAppendMethod(
+            @NotNull StringConcatGenerator generator,
+            @NotNull Type type,
+            @Nullable KotlinType kotlinType,
+            @Nullable KotlinTypeMapper typeMapper,
+            @NotNull StackValue stackValue
+    ) {
+        CallableMethod specializedToString = getSpecializedToStringCallableMethodOrNull(kotlinType, typeMapper);
+        if (specializedToString != null) {
+            stackValue.put(type, kotlinType, generator.getMv());
+            specializedToString.genInvokeInstruction(generator.getMv());
+            generator.invokeAppend(AsmTypes.JAVA_STRING_TYPE);
+        }
+        else if (kotlinType != null && InlineClassesUtilsKt.isInlineClassType(kotlinType)) {
+            SimpleType nullableAnyType = kotlinType.getConstructor().getBuiltIns().getNullableAnyType();
+            stackValue.put(type, kotlinType, generator.getMv());
+            StackValue.coerce(type, kotlinType, OBJECT_TYPE, nullableAnyType, generator.getMv());
+            generator.invokeAppend(OBJECT_TYPE);
+        }
+        else {
+            generator.putValueOrProcessConstant(stackValue, type, kotlinType);
+        }
+    }
+
+    public static StackValue genToString(
+            @NotNull StackValue receiver,
+            @NotNull Type receiverType,
+            @Nullable KotlinType receiverKotlinType,
+            @Nullable KotlinTypeMapper typeMapper
+    ) {
+        return StackValue.operation(JAVA_STRING_TYPE, v -> {
+            CallableMethod specializedToString = getSpecializedToStringCallableMethodOrNull(receiverKotlinType, typeMapper);
+            if (specializedToString != null) {
+                receiver.put(receiverType, receiverKotlinType, v);
+                specializedToString.genInvokeInstruction(v);
+                return null;
+            }
+
+            Type type;
+            KotlinType kotlinType;
+            if (receiverKotlinType != null && InlineClassesUtilsKt.isInlineClassType(receiverKotlinType)) {
+                type = OBJECT_TYPE;
+                kotlinType = receiverKotlinType.getConstructor().getBuiltIns().getNullableAnyType();
+            }
+            else {
+                type = stringValueOfType(receiverType);
+                kotlinType = null;
+            }
+
+            receiver.put(type, kotlinType, v);
+            v.invokestatic("java/lang/String", "valueOf", "(" + type.getDescriptor() + ")Ljava/lang/String;", false);
+            return null;
+        });
+    }
+
+    @Nullable
+    private static CallableMethod getSpecializedToStringCallableMethodOrNull(
+            @Nullable KotlinType receiverKotlinType,
+            @Nullable KotlinTypeMapper typeMapper
+    ) {
+        if (typeMapper == null) return null;
+
+        if (receiverKotlinType == null) return null;
+        if (!InlineClassesUtilsKt.isInlineClassType(receiverKotlinType)) return null;
+        if (receiverKotlinType.isMarkedNullable()) return null;
+
+        DeclarationDescriptor receiverTypeDescriptor = receiverKotlinType.getConstructor().getDeclarationDescriptor();
+        assert receiverTypeDescriptor instanceof ClassDescriptor && ((ClassDescriptor) receiverTypeDescriptor).isInline() :
+                "Inline class type expected: " + receiverKotlinType;
+        ClassDescriptor receiverClassDescriptor = (ClassDescriptor) receiverTypeDescriptor;
+        FunctionDescriptor toStringDescriptor = receiverClassDescriptor.getUnsubstitutedMemberScope()
+                .getContributedFunctions(Name.identifier("toString"), NoLookupLocation.FROM_BACKEND)
+                .stream()
+                .filter(
+                        f -> f.getValueParameters().size() == 0
+                             && KotlinBuiltIns.isString(f.getReturnType())
+                             && f.getDispatchReceiverParameter() != null
+                             && f.getExtensionReceiverParameter() == null
+                )
+                .findFirst()
+                .orElseThrow(() -> new AssertionError("'toString' not found in member scope of " + receiverClassDescriptor));
+
+        return typeMapper.mapToCallableMethod(toStringDescriptor, false, OwnerKind.ERASED_INLINE_CLASS);
+    }
+
+    public static void genHashCode(MethodVisitor mv, InstructionAdapter iv, Type type, JvmTarget jvmTarget) {
+        if (type.getSort() == Type.ARRAY) {
+            Type elementType = correctElementType(type);
+            if (elementType.getSort() == Type.OBJECT || elementType.getSort() == Type.ARRAY) {
+                iv.invokestatic("java/util/Arrays", "hashCode", "([Ljava/lang/Object;)I", false);
+            }
+            else {
+                iv.invokestatic("java/util/Arrays", "hashCode", "(" + type.getDescriptor() + ")I", false);
+            }
+        }
+        else if (type.getSort() == Type.OBJECT) {
+            iv.invokevirtual("java/lang/Object", "hashCode", "()I", false);
+        }
+        else if (type.getSort() == Type.BOOLEAN) {
+            Label end = new Label();
+            iv.dup();
+            iv.ifeq(end);
+            iv.pop();
+            iv.iconst(1);
+            iv.mark(end);
+        }
+        else {
+            if (JvmTarget.JVM_1_6 == jvmTarget) {
+                if (type.getSort() == Type.LONG) {
+                    genLongHashCode(mv, iv);
+                }
+                else if (type.getSort() == Type.DOUBLE) {
+                    iv.invokestatic("java/lang/Double", "doubleToLongBits", "(D)J", false);
+                    genLongHashCode(mv, iv);
+                }
+                else if (type.getSort() == Type.FLOAT) {
+                    iv.invokestatic("java/lang/Float", "floatToIntBits", "(F)I", false);
+                }
+                else { // byte short char int
+                    // do nothing
+                }
+            } else {
+                HashCode.Companion.invokeHashCode(iv, type);
+            }
+        }
+    }
+
+    private static void genLongHashCode(MethodVisitor mv, InstructionAdapter iv) {
+        iv.dup2();
+        iv.iconst(32);
+        iv.ushr(Type.LONG_TYPE);
+        iv.xor(Type.LONG_TYPE);
+        mv.visitInsn(L2I);
+    }
+
+    @NotNull
+    public static StackValue genEqualsForExpressionsOnStack(
+            @NotNull IElementType opToken,
+            @NotNull StackValue left,
+            @NotNull StackValue right
+    ) {
+        Type leftType = left.type;
+        Type rightType = right.type;
+        if (isPrimitive(leftType) && leftType == rightType) {
+            return StackValue.cmp(opToken, leftType, left, right);
+        }
+
+        return StackValue.operation(Type.BOOLEAN_TYPE, v -> {
+            left.put(AsmTypes.OBJECT_TYPE, left.kotlinType, v);
+            right.put(AsmTypes.OBJECT_TYPE, right.kotlinType, v);
+            return genAreEqualCall(v, opToken);
+        });
+    }
+
+    @NotNull
+    public static BranchedValue genTotalOrderEqualsForExpressionOnStack(
+            @NotNull StackValue left,
+            @NotNull StackValue right,
+            @NotNull Type asmType
+    ) {
+        return new BranchedValue(left, right, asmType, Opcodes.IFEQ) {
+            @Override
+            public void condJump(@NotNull Label jumpLabel, @NotNull InstructionAdapter iv, boolean jumpIfFalse) {
+                if (asmType.getSort() == Type.FLOAT) {
+                    left.put(asmType, kotlinType, iv);
+                    right.put(asmType, kotlinType, iv);
+                    iv.invokestatic("java/lang/Float", "compare", "(FF)I", false);
+                    iv.visitJumpInsn(patchOpcode(jumpIfFalse ? Opcodes.IFNE : Opcodes.IFEQ, iv), jumpLabel);
+                } else if (asmType.getSort() == Type.DOUBLE) {
+                    left.put(asmType, kotlinType, iv);
+                    right.put(asmType, kotlinType, iv);
+                    iv.invokestatic("java/lang/Double", "compare", "(DD)I", false);
+                    iv.visitJumpInsn(patchOpcode(jumpIfFalse ? Opcodes.IFNE : Opcodes.IFEQ, iv), jumpLabel);
+                } else {
+                    StackValue value = genEqualsForExpressionsOnStack(KtTokens.EQEQ, left, right);
+                    BranchedValue.Companion.condJump(value, jumpLabel, jumpIfFalse, iv);
+                }
+            }
+        };
+    }
+
+    @NotNull
+    public static StackValue genEqualsBoxedOnStack(@NotNull IElementType opToken) {
+        return StackValue.operation(Type.BOOLEAN_TYPE, v -> genAreEqualCall(v, opToken));
+    }
+
+    public static void genAreEqualCall(InstructionAdapter v) {
+        v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual", "(Ljava/lang/Object;Ljava/lang/Object;)Z", false);
+    }
+
+    @NotNull
+    private static Unit genAreEqualCall(InstructionAdapter v, @NotNull IElementType opToken) {
+        genAreEqualCall(v);
+
+        if (opToken == KtTokens.EXCLEQ || opToken == KtTokens.EXCLEQEQEQ) {
+            genInvertBoolean(v);
+        }
+
+        return Unit.INSTANCE;
+    }
+
+    public static void genIEEE754EqualForNullableTypesCall(InstructionAdapter v, Type left, Type right) {
+        v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual", "(" + left.getDescriptor() + right.getDescriptor() + ")Z", false);
+    }
+
+    public static void genIncrement(Type baseType, int myDelta, InstructionAdapter v) {
+        Type operationType = numberFunctionOperandType(baseType);
+        numConst(myDelta, operationType, v);
+        v.add(operationType);
+        StackValue.coerce(operationType, baseType, v);
+    }
+
+    static void genNotNullAssertionsForParameters(
+            @NotNull InstructionAdapter v,
+            @NotNull GenerationState state,
+            @NotNull FunctionDescriptor descriptor,
+            @NotNull FrameMap frameMap
+    ) {
+        if (state.isParamAssertionsDisabled()) return;
+        // currently when resuming a suspend function we pass default values instead of real arguments (i.e. nulls for references)
+        if (descriptor.isSuspend()) return;
+
+        if (getVisibilityAccessFlag(descriptor) == ACC_PRIVATE) {
+            // Private method is not accessible from other classes, no assertions needed,
+            // unless we have a private operator function, in which we should generate a parameter assertion for an extension receiver.
+
+            // HACK: this provides "fail fast" behavior for operator functions.
+            // Such functions can be invoked in operator conventions desugaring,
+            // which is currently done on ad hoc basis in ExpressionCodegen.
+
+            if (state.isReceiverAssertionsDisabled()) return;
+            if (descriptor.isOperator()) {
+                ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
+                if (receiverParameter != null) {
+                    String name = getNameForReceiverParameter(descriptor, state.getBindingContext(), state.getLanguageVersionSettings());
+                    genParamAssertion(v, state, frameMap, receiverParameter, name, descriptor);
+                }
+            }
+            return;
+        }
+
+        ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
+        if (receiverParameter != null) {
+            String name = getNameForReceiverParameter(descriptor, state.getBindingContext(), state.getLanguageVersionSettings());
+            genParamAssertion(v, state, frameMap, receiverParameter, name, descriptor);
+        }
+
+        for (ValueParameterDescriptor parameter : descriptor.getValueParameters()) {
+            genParamAssertion(v, state, frameMap, parameter, parameter.getName().asString(), descriptor);
+        }
+    }
+
+    private static void genParamAssertion(
+            @NotNull InstructionAdapter v,
+            @NotNull GenerationState state,
+            @NotNull FrameMap frameMap,
+            @NotNull ParameterDescriptor parameter,
+            @NotNull String name,
+            @NotNull FunctionDescriptor containingDeclaration
+    ) {
+        KotlinType type = parameter.getType();
+        if (isNullableType(type) || InlineClassesUtilsKt.isNullableUnderlyingType(type)) return;
+
+        Type asmType = state.getTypeMapper().mapType(type);
+        if (asmType.getSort() == Type.OBJECT || asmType.getSort() == Type.ARRAY) {
+            StackValue value;
+            if (JvmCodegenUtil.isDeclarationOfBigArityFunctionInvoke(containingDeclaration) ||
+                JvmCodegenUtil.isDeclarationOfBigArityCreateCoroutineMethod(containingDeclaration)) {
+                int index = getIndexOfParameterInVarargInvokeArray(parameter);
+                value = StackValue.arrayElement(
+                        OBJECT_TYPE, null, StackValue.local(1, getArrayType(OBJECT_TYPE)), StackValue.constant(index)
+                );
+            }
+            else {
+                int index = frameMap.getIndex(parameter);
+                value = StackValue.local(index, asmType);
+            }
+            value.put(asmType, v);
+            v.visitLdcInsn(name);
+            String methodName = state.getUnifiedNullChecks() ? "checkNotNullParameter" : "checkParameterIsNotNull";
+            v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false);
+        }
+    }
+
+    @NotNull
+    public static StackValue genNotNullAssertions(
+            @NotNull GenerationState state,
+            @NotNull StackValue stackValue,
+            @Nullable RuntimeAssertionInfo runtimeAssertionInfo
+    ) {
+        if (state.isCallAssertionsDisabled()) return stackValue;
+        if (runtimeAssertionInfo == null || !runtimeAssertionInfo.getNeedNotNullAssertion()) return stackValue;
+
+        return new StackValue(stackValue.type, stackValue.kotlinType) {
+            @Override
+            public void putSelector(@NotNull Type type, @Nullable KotlinType kotlinType, @NotNull InstructionAdapter v) {
+                Type innerType = stackValue.type;
+                KotlinType innerKotlinType = stackValue.kotlinType;
+                stackValue.put(innerType, innerKotlinType, v);
+                if (innerType.getSort() == Type.OBJECT || innerType.getSort() == Type.ARRAY) {
+                    v.dup();
+                    v.visitLdcInsn(runtimeAssertionInfo.getMessage());
+                    String methodName = state.getUnifiedNullChecks() ? "checkNotNullExpressionValue" : "checkExpressionValueIsNotNull";
+                    v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false);
+                }
+                StackValue.coerce(innerType, innerKotlinType, type, kotlinType, v);
+            }
+        };
+    }
+
+    private static int getIndexOfParameterInVarargInvokeArray(@NotNull ParameterDescriptor parameter) {
+        if (parameter instanceof ReceiverParameterDescriptor) return 0;
+
+        DeclarationDescriptor container = parameter.getContainingDeclaration();
+        assert parameter instanceof ValueParameterDescriptor : "Non-extension-receiver parameter must be a value parameter: " + parameter;
+        int extensionShift = ((CallableDescriptor) container).getExtensionReceiverParameter() == null ? 0 : 1;
+
+        return extensionShift + ((ValueParameterDescriptor) parameter).getIndex();
+    }
+
+    // At the beginning of the vararg invoke of a function with big arity N, generates an assert that the vararg parameter has N elements
+    public static void generateVarargInvokeArityAssert(InstructionAdapter v, int functionArity) {
+        Label start = new Label();
+        v.load(1, getArrayType(OBJECT_TYPE));
+        v.arraylength();
+        v.iconst(functionArity);
+        v.ificmpeq(start);
+        v.visitLdcInsn("Vararg argument must contain " + functionArity + " elements.");
+        v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "throwIllegalArgument", "(Ljava/lang/String;)V", false);
+        v.visitLabel(start);
+    }
+
+    public static boolean isInstancePropertyWithStaticBackingField(@NotNull PropertyDescriptor propertyDescriptor) {
+        return propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE &&
+               isObject(propertyDescriptor.getContainingDeclaration());
+    }
+
+    public static int getVisibilityForBackingField(@NotNull PropertyDescriptor propertyDescriptor, boolean isDelegate) {
+        boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
+        if (isDelegate || isExtensionProperty) {
+            return ACC_PRIVATE;
+        }
+        else {
+            return propertyDescriptor.isLateInit() || isConstOrHasJvmFieldAnnotation(propertyDescriptor)
+                   ? getVisibilityAccessFlag(descriptorForVisibility(propertyDescriptor))
+                   : ACC_PRIVATE;
+        }
+    }
+
+    private static MemberDescriptor descriptorForVisibility(@NotNull PropertyDescriptor propertyDescriptor) {
+        if (!propertyDescriptor.isVar()) {
+            return propertyDescriptor;
+        }
+        else {
+            return propertyDescriptor.getSetter() != null ? propertyDescriptor.getSetter() : propertyDescriptor;
+        }
+    }
+
+    public static boolean isPropertyWithBackingFieldCopyInOuterClass(@NotNull PropertyDescriptor propertyDescriptor) {
+        DeclarationDescriptor propertyContainer = propertyDescriptor.getContainingDeclaration();
+        return propertyDescriptor.isConst()
+               && isCompanionObject(propertyContainer) && isJvmInterface(propertyContainer.getContainingDeclaration())
+               && getVisibilityForBackingField(propertyDescriptor, false) == ACC_PUBLIC;
+    }
+
+    public static void writeAnnotationData(
+            @NotNull AnnotationVisitor av,
+            @NotNull DescriptorSerializer serializer,
+            @NotNull MessageLite message
+    ) {
+        writeAnnotationData(av, message, (JvmStringTable) serializer.getStringTable());
+    }
+
+    public static void writeAnnotationData(
+            @NotNull AnnotationVisitor av, @NotNull MessageLite message, @NotNull JvmStringTable stringTable
+    ) {
+        AsmUtil.writeAnnotationData(av, JvmProtoBufUtil.writeData(message, stringTable), ArrayUtil.toStringArray(stringTable.getStrings()));
+    }
+
+    public static void putJavaLangClassInstance(
+            @NotNull InstructionAdapter v,
+            @NotNull Type type,
+            @Nullable KotlinType kotlinType,
+            @NotNull KotlinTypeMapper typeMapper
+    ) {
+        if (kotlinType != null && InlineClassesUtilsKt.isInlineClassType(kotlinType)) {
+            v.aconst(boxType(type, kotlinType, typeMapper));
+        }
+        else if (isPrimitive(type)) {
+            v.getstatic(AsmUtil.boxType(type).getInternalName(), "TYPE", "Ljava/lang/Class;");
+        }
+        else {
+            v.aconst(type);
+        }
+    }
+
+    public static int getReceiverIndex(@NotNull CodegenContext context, @NotNull CallableMemberDescriptor descriptor) {
+        OwnerKind kind = context.getContextKind();
+        //Trait always should have this descriptor
+        return kind != OwnerKind.DEFAULT_IMPLS && isStaticMethod(kind, descriptor) ? 0 : 1;
+    }
+}

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

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.codegen.AsmUtil.genTotalOrderEqualsForExpressionOnStack
+import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.genTotalOrderEqualsForExpressionOnStack
 import org.jetbrains.kotlin.codegen.context.ClassContext
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper

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

@@ -51,9 +51,9 @@ import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.KtTokens;
-import org.jetbrains.kotlin.load.java.JvmAbi;
+import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
+import org.jetbrains.kotlin.load.kotlin.DescriptorBasedTypeSignatureMappingKt;
 import org.jetbrains.kotlin.load.kotlin.MethodSignatureMappingKt;
-import org.jetbrains.kotlin.load.kotlin.TypeSignatureMappingKt;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
@@ -97,8 +97,11 @@ import java.util.function.Supplier;
 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.CodegenUtilKt.*;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.boxType;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.*;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.*;
@@ -173,7 +176,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return null;
     }
 
-    static class BlockStackElement {
+    public static class BlockStackElement {
     }
 
     static class LoopBlockStackElement extends BlockStackElement {
@@ -312,6 +315,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
             stackValue = suspendFunctionTypeWrapperIfNeeded(selector, stackValue);
 
+            stackValue = coerceAndBoxInlineClassIfNeeded(selector, stackValue);
+
             RuntimeAssertionInfo runtimeAssertionInfo = null;
             if (selector instanceof KtExpression) {
                 KtExpression expression = (KtExpression) selector;
@@ -360,6 +365,53 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return stackValue;
     }
 
+    private StackValue coerceAndBoxInlineClassIfNeeded(KtElement selector, StackValue stackValue) {
+        ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt.getResolvedCall(selector, bindingContext);
+        if (resolvedCall == null) return stackValue;
+        CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
+        if (!(descriptor instanceof FunctionDescriptor)) return stackValue;
+        FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
+        if (!functionDescriptor.isSuspend()) return stackValue;
+
+        KotlinType unboxedInlineClass = CoroutineCodegenUtilKt
+                .originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(functionDescriptor, typeMapper);
+
+        StackValue stackValueToWrap = stackValue;
+        KotlinType originalKotlinType;
+        if (unboxedInlineClass != null) {
+            originalKotlinType = unboxedInlineClass;
+        } else {
+            originalKotlinType = stackValueToWrap.kotlinType;
+        }
+        Type originalType;
+        if (unboxedInlineClass != null) {
+            originalType = typeMapper.mapType(unboxedInlineClass);
+        } else {
+            originalType = stackValueToWrap.type;
+        }
+
+        stackValue = new StackValue(originalType, originalKotlinType) {
+            @Override
+            public void putSelector(
+                    @NotNull Type type, @Nullable KotlinType kotlinType, @NotNull InstructionAdapter v
+            ) {
+                if (((originalKotlinType != null && InlineClassesUtilsKt.isInlineClassType(originalKotlinType)) ||
+                    (kotlinType != null && InlineClassesUtilsKt.isInlineClassType(kotlinType)))
+                ) {
+                    stackValueToWrap.put(v);
+                    // Suspend functions always return Ljava/lang/Object;, so, before inline-class boxing/unboxing we need to generate CHECKCAST
+                    StackValue.coerce(OBJECT_TYPE, originalType, v);
+                    // Box/unbox inline class
+                    StackValue.coerce(originalType, originalKotlinType, type, kotlinType, v);
+                } else {
+                    // No inline class -> usual coerce is enough
+                    stackValueToWrap.put(type, kotlinType, v);
+                }
+            }
+        };
+        return stackValue;
+    }
+
     public StackValue gen(KtElement expr) {
         StackValue tempVar = tempVariables.get(expr);
         return tempVar != null ? tempVar : genQualified(StackValue.none(), expr);
@@ -873,28 +925,27 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
         else {
             return StackValue.operation(type, v -> {
-                genStringBuilderConstructor(v);
-                invokeAppendForEntries(v, entries);
-                v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
+                StringConcatGenerator generator = StringConcatGenerator.Companion.create(state, v);
+                generator.genStringBuilderConstructorIfNeded();
+                invokeAppendForEntries(generator, entries);
+                generator.genToString();
                 return Unit.INSTANCE;
             });
         }
     }
 
-    private void invokeAppendForEntries(InstructionAdapter v, List<StringTemplateEntry> entries) {
+    private void invokeAppendForEntries(StringConcatGenerator generator, List<StringTemplateEntry> entries) {
         for (StringTemplateEntry entry : entries) {
             if (entry instanceof StringTemplateEntry.Expression) {
-                invokeAppend(v, ((StringTemplateEntry.Expression) entry).expression);
+                invokeAppend(generator, ((StringTemplateEntry.Expression) entry).expression);
             }
             else {
                 String value = ((StringTemplateEntry.Constant) entry).value;
                 if (value.length() == 1) {
-                    v.iconst(value.charAt(0));
-                    genInvokeAppendMethod(v, Type.CHAR_TYPE, null);
+                    generator.putValueOrProcessConstant(StackValue.constant(value.charAt(0), Type.CHAR_TYPE, null));
                 }
                 else {
-                    v.aconst(value);
-                    genInvokeAppendMethod(v, JAVA_STRING_TYPE, null);
+                    generator.addStringConstant(value);
                 }
             }
         }
@@ -1476,7 +1527,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             assert !functionIndex.isEmpty();
 
             String localVariableName = AsmUtil.LOCAL_FUNCTION_VARIABLE_PREFIX
-                    + VariableAsmNameManglingUtils.mangleNameIfNeeded(functionDescriptor.getName().asString())
+                    + CommonVariableAsmNameManglingUtils.mangleNameIfNeeded(functionDescriptor.getName().asString())
                     + "$" + functionIndex;
 
             v.visitLocalVariable(localVariableName, type.getDescriptor(), null, scopeStart, blockEnd, index);
@@ -1654,12 +1705,32 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             Type returnType;
             KotlinType returnKotlinType;
             if (isNonLocalReturn) {
-                returnType = nonLocalReturn.returnType.getType();
-                returnKotlinType = nonLocalReturn.returnType.getKotlinType();
+                // This is inline lambda. Find inline-site and check, whether it is suspend functions returning unboxed inline class
+                CodegenContext<?> inlineSiteContext = this.context.getFirstCrossInlineOrNonInlineContext();
+                KotlinType originalInlineClass = null;
+                if (inlineSiteContext instanceof MethodContext) {
+                     originalInlineClass = CoroutineCodegenUtilKt
+                            .originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(
+                                    ((MethodContext) inlineSiteContext).getFunctionDescriptor(), typeMapper);
+                }
+                if (originalInlineClass != null) {
+                    returnType = typeMapper.mapType(originalInlineClass);
+                    returnKotlinType = originalInlineClass;
+                } else {
+                    returnType = nonLocalReturn.returnType.getType();
+                    returnKotlinType = nonLocalReturn.returnType.getKotlinType();
+                }
             }
             else {
-                returnType = this.returnType;
-                returnKotlinType = typeMapper.getReturnValueType(this.context.getFunctionDescriptor());
+                KotlinType originalInlineClass = CoroutineCodegenUtilKt
+                        .originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(context.getFunctionDescriptor(), typeMapper);
+                if (originalInlineClass != null) {
+                    returnType = typeMapper.mapType(originalInlineClass);
+                    returnKotlinType = originalInlineClass;
+                } else {
+                    returnType = this.returnType;
+                    returnKotlinType = this.context.getFunctionDescriptor().getReturnType();
+                }
             }
             StackValue valueToReturn = returnedExpression != null ? gen(returnedExpression) : StackValue.none();
 
@@ -1714,7 +1785,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     return new NonLocalReturnInfo(
                             new JvmKotlinType(
                                     typeMapper.mapReturnType(containingFunction),
-                                    typeMapper.getReturnValueType(containingFunction)
+                                    containingFunction.getReturnType()
                             ),
                             FIRST_FUN_LABEL
                     );
@@ -1744,18 +1815,27 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         FunctionDescriptor originalSuspendLambdaDescriptor = getOriginalSuspendLambdaDescriptorFromContext(context);
         boolean isVoidCoroutineLambda =
-                originalSuspendLambdaDescriptor != null && TypeSignatureMappingKt.hasVoidReturnType(originalSuspendLambdaDescriptor);
+                originalSuspendLambdaDescriptor != null && DescriptorBasedTypeSignatureMappingKt
+                        .hasVoidReturnType(originalSuspendLambdaDescriptor);
+
+        KotlinType originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass =
+                CoroutineCodegenUtilKt.originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(
+                        context.getFunctionDescriptor(), typeMapper);
 
         // If generating body for named block-bodied function or Unit-typed coroutine lambda, generate it as sequence of statements
         Type typeForExpression =
                 isBlockedNamedFunction || isVoidCoroutineLambda
                 ? Type.VOID_TYPE
-                : returnType;
+                : originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass != null
+                  ? typeMapper.mapType(originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass)
+                  : returnType;
 
         KotlinType kotlinTypeForExpression =
                 isBlockedNamedFunction || isVoidCoroutineLambda
                 ? null
-                : typeMapper.getReturnValueType(context.getFunctionDescriptor());
+                : originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass != null
+                  ? originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass
+                  : context.getFunctionDescriptor().getReturnType();
 
         gen(expr, typeForExpression, kotlinTypeForExpression);
 
@@ -2174,14 +2254,14 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
 
-        boolean isBackingFieldMovedFromCompanion = JvmAbi.isPropertyWithBackingFieldInOuterClass(propertyDescriptor);
+        boolean isBackingFieldMovedFromCompanion = DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor);
         AccessorKind fieldAccessorKind;
         if (skipLateinitAssertion) {
             fieldAccessorKind = AccessorKind.LATEINIT_INTRINSIC;
         }
         else if (isBackingFieldMovedFromCompanion &&
                  (forceField ||
-                  (Visibilities.isPrivate(propertyDescriptor.getVisibility()) &&
+                  (DescriptorVisibilities.isPrivate(propertyDescriptor.getVisibility()) &&
                    isDefaultAccessor(propertyDescriptor.getGetter()) && isDefaultAccessor(propertyDescriptor.getSetter())))) {
             fieldAccessorKind = JvmCodegenUtil.isDebuggerContext(context) ? AccessorKind.NORMAL : AccessorKind.IN_CLASS_COMPANION;
         }
@@ -2194,7 +2274,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             fieldAccessorKind = AccessorKind.NORMAL;
         }
         boolean isStaticBackingField = DescriptorUtils.isStaticDeclaration(propertyDescriptor) ||
-                                       AsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor);
+                                       DescriptorAsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor);
         boolean isSuper = superCallTarget != null;
         boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
 
@@ -2207,7 +2287,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         CodegenContext<?> backingFieldContext = getBackingFieldContext(fieldAccessorKind, containingDeclaration);
         boolean isPrivateProperty =
                 fieldAccessorKind != AccessorKind.NORMAL &&
-                (AsmUtil.getVisibilityForBackingField(propertyDescriptor, isDelegatedProperty) & ACC_PRIVATE) != 0;
+                (DescriptorAsmUtil.getVisibilityForBackingField(propertyDescriptor, isDelegatedProperty) & ACC_PRIVATE) != 0;
         DeclarationDescriptor ownerDescriptor;
         boolean skipPropertyAccessors;
 
@@ -2224,8 +2304,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
             if (!skipPropertyAccessors) {
                 if (isBackingFieldMovedFromCompanion && context.getContextDescriptor() instanceof AccessorForPropertyBackingField) {
-                    propertyDescriptor = (PropertyDescriptor) backingFieldContext.getParentContext()
-                            .getAccessor(propertyDescriptor, AccessorKind.IN_CLASS_COMPANION, delegateType, superCallTarget);
+                    CodegenContext<?> parentContext = backingFieldContext.getParentContext();
+                    propertyDescriptor =
+                            parentContext.getAccessor(propertyDescriptor, AccessorKind.IN_CLASS_COMPANION, delegateType, superCallTarget);
                 }
                 else {
                     propertyDescriptor =
@@ -2253,7 +2334,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             skipPropertyAccessors = forceField;
 
             if (JvmCodegenUtil.isDebuggerContext(context)
-                && Visibilities.isPrivate(propertyDescriptor.getVisibility())
+                && DescriptorVisibilities.isPrivate(propertyDescriptor.getVisibility())
                 && bindingContext.get(BACKING_FIELD_REQUIRED, propertyDescriptor) == Boolean.TRUE
             ) {
                 skipPropertyAccessors = true;
@@ -2612,7 +2693,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         SuspensionPointKind suspensionPointKind =
                 CoroutineCodegenUtilKt.isSuspensionPoint(resolvedCall, this, state.getLanguageVersionSettings());
-        boolean maybeSuspensionPoint = suspensionPointKind != SuspensionPointKind.NEVER;
+        boolean maybeSuspensionPoint = suspensionPointKind != SuspensionPointKind.NEVER && !insideCallableReference();
         boolean isConstructor = resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor;
         if (!(callableMethod instanceof IntrinsicWithSpecialReceiver)) {
             putReceiverAndInlineMarkerIfNeeded(callableMethod, resolvedCall, receiver, maybeSuspensionPoint, isConstructor);
@@ -2656,11 +2737,23 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         callGenerator.genCall(callableMethod, resolvedCall, defaultMaskWasGenerated, this);
 
         if (maybeSuspensionPoint) {
+            // The order is important! Do not reorder!
+            // CoroutineTransformerMethodVisitor expects the marker exactly in this order.
             addReturnsUnitMarkerIfNecessary(v, resolvedCall);
             addSuspendMarker(v, false, suspensionPointKind == SuspensionPointKind.NOT_INLINE);
+            addUnboxInlineClassMarkersIfNeeded(v, resolvedCall.getResultingDescriptor(), typeMapper);
             addInlineMarker(v, false);
         }
 
+        // If a suspend function returns unboxed inline class, we should check for COROUTINE_SUSPENDED and only then box the inline class.
+        if (insideCallableReference() && resolvedCall.getResultingDescriptor() instanceof FunctionDescriptor) {
+            KotlinType unboxedInlineClass = CoroutineCodegenUtilKt.originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(
+                    (FunctionDescriptor) resolvedCall.getResultingDescriptor(), typeMapper);
+            if (unboxedInlineClass != null) {
+                CoroutineCodegenUtilKt.generateCoroutineSuspendedCheck(v, state.getLanguageVersionSettings());
+            }
+        }
+
         KotlinType returnType = resolvedCall.getResultingDescriptor().getReturnType();
         if (returnType != null && KotlinBuiltIns.isNothing(returnType)) {
             if (state.getUseKotlinNothingValueException()) {
@@ -2674,6 +2767,10 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
     }
 
+    private boolean insideCallableReference() {
+        return (parentCodegen instanceof ClosureCodegen) && ((ClosureCodegen) parentCodegen).isCallableReference();
+    }
+
     private void putReceiverAndInlineMarkerIfNeeded(
             @NotNull Callable callableMethod,
             @NotNull ResolvedCall<?> resolvedCall,
@@ -2742,7 +2839,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                 myFrameMap.leaveTemp(firstReceiverType);
             }
 
-            callableMethod.afterReceiverGeneration(v, myFrameMap);
+            callableMethod.afterReceiverGeneration(v, myFrameMap, state);
         }
     }
 
@@ -2835,7 +2932,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             TypeApproximator approximator = new TypeApproximator(state.getModule().getBuiltIns());
 
             KotlinType approximatedType =
-                    CapturedTypeConstructorKt.isCaptured(type) ?
+                    TypeUtils.contains(type, (containedType) -> CapturedTypeConstructorKt.isCaptured(containedType)) ?
                     (KotlinType) approximator.approximateToSuperType(
                             type, TypeApproximatorConfiguration.InternalTypesApproximation.INSTANCE
                     ) : null;
@@ -2936,7 +3033,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             return null;
         }
 
-        int accessFlag = AsmUtil.getVisibilityAccessFlag(companionObjectDescriptor);
+        int accessFlag = DescriptorAsmUtil.getVisibilityAccessFlag(companionObjectDescriptor);
 
         CodegenContext context = contextBeforeInline.getFirstCrossInlineOrNonInlineContext();
         boolean isInlineMethodContext = context.isInlineMethodContext();
@@ -3906,7 +4003,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         Type rightType = right754Type.isNullable ? AsmUtil.boxType(right754Type.type) : right754Type.type;
         gen(right, rightType);
 
-        AsmUtil.genIEEE754EqualForNullableTypesCall(v, leftType, rightType);
+        DescriptorAsmUtil.genIEEE754EqualForNullableTypesCall(v, leftType, rightType);
 
         if (opToken == KtTokens.EXCLEQ) {
             genInvertBoolean(v);
@@ -4103,15 +4200,14 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         TypeAndNullability right754Type = calcTypeForIeee754ArithmeticIfNeeded(right, getRightOperandType(primitiveNumericComparisonInfo));
         boolean isSame754ArithmeticTypes = left754Type != null && right754Type != null && left754Type.type.equals(right754Type.type);
         boolean properIeee754Comparisons = shouldUseProperIeee754Comparisons();
+        boolean isStandardCompareTo = primitiveNumericComparisonInfo != null;
 
-        if (properIeee754Comparisons && left754Type != null && right754Type != null) {
+        if (properIeee754Comparisons && isStandardCompareTo && left754Type != null && right754Type != null) {
             type = comparisonOperandType(left754Type.type, right754Type.type);
-            //type = comparisonOperandType(leftType, rightType);
             leftValue = gen(left);
             rightValue = gen(right);
         }
-        else if (!properIeee754Comparisons &&
-                 state.getIntrinsics().getIntrinsic((FunctionDescriptor) resolvedCall.getResultingDescriptor()) instanceof CompareTo &&
+        else if (!properIeee754Comparisons && isStandardCompareTo &&
                  ((isPrimitive(leftType) && isPrimitive(rightType)) || isSame754ArithmeticTypes)) {
             type = isSame754ArithmeticTypes ? left754Type.type : comparisonOperandType(leftType, rightType);
             leftValue = gen(left);
@@ -4204,7 +4300,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
     }
 
-    public void invokeAppend(InstructionAdapter v, KtExpression expr) {
+    public void invokeAppend(StringConcatGenerator generator, KtExpression expr) {
         expr = KtPsiUtil.safeDeparenthesize(expr);
 
         ConstantValue<?> compileTimeConstant = getPrimitiveOrStringCompileTimeConstant(expr);
@@ -4218,28 +4314,29 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     Type leftType = expressionType(left);
 
                     if (leftType.equals(JAVA_STRING_TYPE)) {
-                        invokeAppend(v, left);
-                        invokeAppend(v, right);
+                        invokeAppend(generator, left);
+                        invokeAppend(generator, right);
                         return;
                     }
                 }
             }
             else if (expr instanceof KtStringTemplateExpression) {
                 List<StringTemplateEntry> entries = preprocessStringTemplate((KtStringTemplateExpression) expr);
-                invokeAppendForEntries(v, entries);
+                invokeAppendForEntries(generator, entries);
                 return;
             }
         }
 
         Type exprType = expressionType(expr);
         KotlinType exprKotlinType = kotlinType(expr);
+        StackValue value;
         if (compileTimeConstant != null) {
-            StackValue.constant(compileTimeConstant.getValue(), exprType, exprKotlinType).put(exprType, exprKotlinType, v);
+            value = StackValue.constant(compileTimeConstant.getValue(), exprType, exprKotlinType);
         } else {
-            gen(expr, exprType, exprKotlinType);
+            value = gen(expr);
         }
 
-        genInvokeAppendMethod(v, exprType, exprKotlinType, typeMapper);
+        genInvokeAppendMethod(generator, exprType, exprKotlinType, typeMapper, value);
     }
 
     @Nullable
@@ -5051,7 +5148,9 @@ The "returned" value of try expression with no finally is either the last expres
                 return Unit.INSTANCE;
             }
 
-            CodegenUtilKt.generateAsCast(v, rightKotlinType, boxedRightType, safeAs, state.getLanguageVersionSettings());
+            CodegenUtilKt.generateAsCast(
+                    v, rightKotlinType, boxedRightType, safeAs, state.getLanguageVersionSettings(), state.getUnifiedNullChecks()
+            );
 
             return Unit.INSTANCE;
         });

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.CompanionObjectMapping;
+import org.jetbrains.kotlin.builtins.CompanionObjectMappingUtilsKt;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.load.java.JvmAbi;
@@ -24,7 +25,7 @@ public class FieldInfo {
             throw new UnsupportedOperationException("Can't create singleton field for class: " + classDescriptor);
         }
 
-        if (isNonCompanionObject(classDescriptor) || CompanionObjectMapping.INSTANCE.isMappedIntrinsicCompanionObject(classDescriptor)) {
+        if (isNonCompanionObject(classDescriptor) || CompanionObjectMappingUtilsKt.isMappedIntrinsicCompanionObject(CompanionObjectMapping.INSTANCE, classDescriptor)) {
             return createSingletonViaInstance(classDescriptor, typeMapper, JvmAbi.INSTANCE_FIELD);
         }
 

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

@@ -67,13 +67,15 @@ import java.io.StringWriter;
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD;
+import static org.jetbrains.kotlin.codegen.AsmUtil.boxType;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.generateBridgeForMainFunctionIfNecessary;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
 import static org.jetbrains.kotlin.codegen.state.KotlinTypeMapper.isAccessor;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION;
-import static org.jetbrains.kotlin.descriptors.ModalityKt.isOverridable;
+import static org.jetbrains.kotlin.descriptors.ModalityUtilsKt.isOverridable;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.getSourceFromDescriptor;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
@@ -83,6 +85,8 @@ import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class FunctionCodegen {
+    private static final String JAVA_LANG_DEPRECATED = Type.getType(Deprecated.class).getDescriptor();
+
     public final GenerationState state;
     private final KotlinTypeMapper typeMapper;
     private final BindingContext bindingContext;
@@ -221,7 +225,7 @@ public class FunctionCodegen {
                 InlineClassDescriptorResolver.isSpecializedEqualsMethod(functionDescriptor);
         generateMethodAnnotationsIfRequired(
                 functionDescriptor, asmMethod, jvmSignature, mv,
-                isCompatibilityStubInDefaultImpls ? Collections.singletonList(Deprecated.class) : Collections.emptyList(),
+                isCompatibilityStubInDefaultImpls ? Collections.singletonList(JAVA_LANG_DEPRECATED) : Collections.emptyList(),
                 skipNullabilityAnnotations
         );
         GenerateJava8ParameterNamesKt.generateParameterNames(functionDescriptor, mv, jvmSignature, state, (flags & ACC_SYNTHETIC) != 0);
@@ -285,7 +289,7 @@ public class FunctionCodegen {
             @NotNull Method asmMethod,
             @NotNull JvmMethodGenericSignature jvmSignature,
             @NotNull MethodVisitor mv,
-            @NotNull List<Class<?>> additionalNoArgAnnotations,
+            @NotNull List<String> additionalVisibleAnnotations,
             boolean skipNullabilityAnnotations
     ) {
         FunctionDescriptor annotationsOwner;
@@ -302,7 +306,7 @@ public class FunctionCodegen {
         }
 
         AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
-                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType(), null, additionalNoArgAnnotations);
+                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType(), null, additionalVisibleAnnotations);
 
         generateParameterAnnotations(
                 annotationsOwner, mv, jvmSignature,
@@ -607,7 +611,7 @@ public class FunctionCodegen {
         else if (isCompatibilityStubInDefaultImpls(functionDescriptor, context, jvmDefaultMode)) {
             FunctionDescriptor compatibility = ((DefaultImplsClassContext) context.getParentContext()).getInterfaceContext()
                     .getAccessorForJvmDefaultCompatibility(functionDescriptor);
-            int flags = AsmUtil.getMethodAsmFlags(functionDescriptor, OwnerKind.DEFAULT_IMPLS, context.getState());
+            int flags = DescriptorAsmUtil.getMethodAsmFlags(functionDescriptor, OwnerKind.DEFAULT_IMPLS, context.getState());
             assert (flags & Opcodes.ACC_ABSTRACT) == 0 : "Interface method with body should be non-abstract" + functionDescriptor;
             CallableMethod method = typeMapper.mapToCallableMethod(compatibility, false);
 
@@ -759,7 +763,7 @@ public class FunctionCodegen {
         generateLocalVariablesForParameters(mv,
                                             jvmMethodSignature, functionDescriptor,
                                             thisType, methodBegin, methodEnd, functionDescriptor.getValueParameters(),
-                                            AsmUtil.isStaticMethod(ownerKind, functionDescriptor), state
+                                            DescriptorAsmUtil.isStaticMethod(ownerKind, functionDescriptor), state
         );
     }
 
@@ -807,7 +811,7 @@ public class FunctionCodegen {
                             : nameForDestructuredParameter;
                     break;
                 case RECEIVER:
-                    parameterName = AsmUtil.getNameForReceiverParameter(
+                    parameterName = DescriptorAsmUtil.getNameForReceiverParameter(
                             functionDescriptor, typeMapper.getBindingContext(), state.getLanguageVersionSettings());
                     break;
                 case OUTER:
@@ -1058,7 +1062,7 @@ public class FunctionCodegen {
         // or all return types are supertypes of inline class (and can't be inline classes).
 
         for (DescriptorBasedFunctionHandleForJvm handle : bridge.getOriginalFunctions()) {
-            return state.getTypeMapper().getReturnValueType(handle.getDescriptor());
+            return handle.getDescriptor().getReturnType();
         }
 
         if (state.getClassBuilderMode().mightBeIncorrectCode) {
@@ -1150,7 +1154,7 @@ public class FunctionCodegen {
         // $default methods are never private to be accessible from other class files (e.g. inner) without the need of synthetic accessors
         // $default methods are never protected to be accessible from subclass nested classes
         int visibilityFlag =
-                Visibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor)
+                DescriptorVisibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor)
                 ? AsmUtil.NO_FLAG_PACKAGE_PRIVATE : Opcodes.ACC_PUBLIC;
         int flags = visibilityFlag | getDeprecatedAccessFlag(functionDescriptor) | ACC_SYNTHETIC;
         if (!(functionDescriptor instanceof ConstructorDescriptor &&
@@ -1409,7 +1413,7 @@ public class FunctionCodegen {
         if (isVarargInvoke) {
             assert argTypes.length == 1 && argTypes[0].equals(AsmUtil.getArrayType(OBJECT_TYPE)) :
                     "Vararg invoke must have one parameter of type [Ljava/lang/Object;: " + bridge;
-            AsmUtil.generateVarargInvokeArityAssert(iv, originalArgTypes.length);
+            DescriptorAsmUtil.generateVarargInvokeArityAssert(iv, originalArgTypes.length);
         }
         else {
             assert argTypes.length == originalArgTypes.length :
@@ -1455,7 +1459,7 @@ public class FunctionCodegen {
             }
         }
 
-        KotlinType returnValueType = state.getTypeMapper().getReturnValueType(descriptor);
+        KotlinType returnValueType = descriptor.getReturnType();
         StackValue.coerce(delegateTo.getReturnType(), returnValueType, bridge.getReturnType(), bridgeReturnType, iv);
         iv.areturn(bridge.getReturnType());
 
@@ -1614,7 +1618,7 @@ public class FunctionCodegen {
                         }
 
                         //noinspection ConstantConditions
-                        StackValue stackValue = AsmUtil.genNotNullAssertions(
+                        StackValue stackValue = DescriptorAsmUtil.genNotNullAssertions(
                                 state,
                                 StackValue.onStack(delegateToMethod.getReturnType(), delegatedTo.getReturnType()),
                                 RuntimeAssertionInfo.create(
@@ -1675,7 +1679,8 @@ public class FunctionCodegen {
         assert isInterface(containingDeclaration) : "'processInterfaceMethod' method should be called only for interfaces, but: " +
                                                     containingDeclaration;
 
-        if (JvmAnnotationUtilKt.isCompiledToJvmDefault(memberDescriptor, mode)) {
+        // Fake overrides in interfaces should be expanded to implementation to make proper default check
+        if (JvmAnnotationUtilKt.checkIsImplementationCompiledToJvmDefault(memberDescriptor, mode)) {
             return (kind != OwnerKind.DEFAULT_IMPLS && !isSynthetic) ||
                    (kind == OwnerKind.DEFAULT_IMPLS &&
                     (isSynthetic || //TODO: move synthetic method generation into interface
@@ -1683,7 +1688,7 @@ public class FunctionCodegen {
         } else {
             switch (kind) {
                 case DEFAULT_IMPLS: return true;
-                case IMPLEMENTATION: return !Visibilities.isPrivate(memberDescriptor.getVisibility()) && !isDefault && !isSynthetic;
+                case IMPLEMENTATION: return !DescriptorVisibilities.isPrivate(memberDescriptor.getVisibility()) && !isDefault && !isSynthetic;
                 default: return false;
             }
         }

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

@@ -11,6 +11,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.FunctionsFromAnyGenerator;
 import org.jetbrains.kotlin.codegen.context.FieldOwnerContext;
 import org.jetbrains.kotlin.codegen.context.MethodContext;
+import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
@@ -29,10 +30,12 @@ import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
+import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.List;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.JAVA_STRING_TYPE;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
@@ -78,7 +81,8 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String toStringMethodName = mapFunctionName(function);
-        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), toStringMethodName, getToStringDesc(), null, null);
+        String toStringMethodDesc = getToStringDesc();
+        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), toStringMethodName, toStringMethodDesc, null, null);
 
         if (!isInErasedInlineClass && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
@@ -97,18 +101,19 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         InstructionAdapter iv = new InstructionAdapter(mv);
 
         mv.visitCode();
-        genStringBuilderConstructor(iv);
 
+        StringConcatGenerator generator = StringConcatGenerator.Companion.create(generationState, iv);
+        generator.genStringBuilderConstructorIfNeded();
         boolean first = true;
+
         for (PropertyDescriptor propertyDescriptor : properties) {
             if (first) {
-                iv.aconst(classDescriptor.getName() + "(" + propertyDescriptor.getName().asString() + "=");
+                generator.addStringConstant(classDescriptor.getName() + "(" + propertyDescriptor.getName().asString() + "=");
                 first = false;
             }
             else {
-                iv.aconst(", " + propertyDescriptor.getName().asString() + "=");
+                generator.addStringConstant(", " + propertyDescriptor.getName().asString() + "=");
             }
-            genInvokeAppendMethod(iv, JAVA_STRING_TYPE, null);
 
             JvmKotlinType type = genOrLoadOnStack(iv, context, propertyDescriptor, 0);
             Type asmType = type.getType();
@@ -127,16 +132,23 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
                     kotlinType = DescriptorUtilsKt.getBuiltIns(function).getStringType();
                 }
             }
-            genInvokeAppendMethod(iv, asmType, kotlinType, typeMapper);
+            genInvokeAppendMethod(generator, asmType, kotlinType, typeMapper, StackValue.onStack(asmType));
         }
 
-        iv.aconst(")");
-        genInvokeAppendMethod(iv, JAVA_STRING_TYPE, null);
+        generator.addStringConstant(")");
 
-        iv.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
+        generator.genToString();
         iv.areturn(JAVA_STRING_TYPE);
 
         FunctionCodegen.endVisit(mv, toStringMethodName, getDeclaration());
+
+        recordMethodForFunctionIfRequired(function, toStringMethodName, toStringMethodDesc);
+    }
+
+    private void recordMethodForFunctionIfRequired(@NotNull FunctionDescriptor function, @NotNull String name, @NotNull String desc) {
+        if (isInErasedInlineClass) {
+            v.getSerializationBindings().put(JvmSerializationBindings.METHOD_FOR_FUNCTION, function, new Method(name, desc));
+        }
     }
 
     @Override
@@ -146,7 +158,8 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String hashCodeMethodName = mapFunctionName(function);
-        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), hashCodeMethodName, getHashCodeDesc(), null, null);
+        String hashCodeMethodDesc = getHashCodeDesc();
+        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), hashCodeMethodName, hashCodeMethodDesc, null, null);
 
         if (!isInErasedInlineClass && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
@@ -202,6 +215,8 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         mv.visitInsn(IRETURN);
 
         FunctionCodegen.endVisit(mv, hashCodeMethodName, getDeclaration());
+
+        recordMethodForFunctionIfRequired(function, hashCodeMethodName, hashCodeMethodDesc);
     }
 
     private String mapFunctionName(@NotNull FunctionDescriptor functionDescriptor) {
@@ -215,7 +230,8 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String equalsMethodName = mapFunctionName(function);
-        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), equalsMethodName, getEqualsDesc(), null, null);
+        String equalsMethodDesc = getEqualsDesc();
+        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), equalsMethodName, equalsMethodDesc, null, null);
 
         if (!isInErasedInlineClass && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
@@ -266,6 +282,8 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         iv.areturn(Type.INT_TYPE);
 
         FunctionCodegen.endVisit(mv, equalsMethodName, getDeclaration());
+
+        recordMethodForFunctionIfRequired(function, equalsMethodName, equalsMethodDesc);
     }
 
     private static void visitEndForAnnotationVisitor(@Nullable AnnotationVisitor annotation) {

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

@@ -62,13 +62,18 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.*;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.builtins.StandardNames.ENUM_VALUES;
+import static org.jetbrains.kotlin.builtins.StandardNames.ENUM_VALUE_OF;
+import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isGenericToArray;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isNonGenericToArray;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.*;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedSubclass;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.getDelegatedLocalVariableMetadata;
-import static org.jetbrains.kotlin.load.java.JvmAbi.*;
+import static org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil.*;
+import static org.jetbrains.kotlin.load.java.JvmAbi.HIDDEN_INSTANCE_FIELD;
+import static org.jetbrains.kotlin.load.java.JvmAbi.INSTANCE_FIELD;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_GET;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_SET;
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.getNotNull;
@@ -814,7 +819,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         }
         if (properVisibilityForCompanionObjectInstanceField &&
             JvmCodegenUtil.isCompanionObjectInInterfaceNotIntrinsic(companionObjectDescriptor) &&
-            Visibilities.isPrivate(companionObjectDescriptor.getVisibility())) {
+            DescriptorVisibilities.isPrivate(companionObjectDescriptor.getVisibility())) {
             fieldAccessFlags |= ACC_SYNTHETIC;
         }
         StackValue.Field field = StackValue.singleton(companionObjectDescriptor, typeMapper);

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

@@ -65,7 +65,7 @@ class InterfaceImplBodyCodegen(
             if (memberDescriptor !is CallableMemberDescriptor) continue
 
             if (memberDescriptor.kind.isReal) continue
-            if (memberDescriptor.visibility == Visibilities.INVISIBLE_FAKE) continue
+            if (memberDescriptor.visibility == DescriptorVisibilities.INVISIBLE_FAKE) continue
             if (memberDescriptor.modality == Modality.ABSTRACT) continue
 
             val implementation = findImplementationFromInterface(memberDescriptor) ?: continue

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMapper
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
@@ -42,7 +42,7 @@ class JvmBackendClassResolverForModuleWithDependencies(
 
         val platformClass = moduleDescriptor.findClassAcrossModuleDependencies(type.classId) ?: return emptyList()
 
-        return JavaToKotlinClassMap.mapPlatformClass(platformClass) + platformClass
+        return JavaToKotlinClassMapper.mapPlatformClass(platformClass) + platformClass
     }
 }
 
@@ -54,4 +54,4 @@ val Type.classId: ClassId
         val classRelativeNameWithDollars = if (lastDotIndex >= 0) className.substring(lastDotIndex + 1) else className
         val classFQN = FqName(classRelativeNameWithDollars.replace('$', '.'))
         return ClassId(packageFQN, classFQN, false)
-    }
+    }

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

@@ -12,6 +12,8 @@ import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
+import org.jetbrains.kotlin.builtins.StandardNames;
+import org.jetbrains.kotlin.builtins.functions.BuiltInFunctionArity;
 import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor;
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
 import org.jetbrains.kotlin.codegen.context.CodegenContext;
@@ -27,7 +29,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
-import org.jetbrains.kotlin.load.java.JvmAbi;
+import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor;
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityUtilsKt;
@@ -106,7 +108,7 @@ public class JvmCodegenUtil {
         boolean isDelegate = descriptor.getKind() == CallableMemberDescriptor.Kind.DELEGATION;
 
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration().getOriginal();
-        if (JvmAbi.isPropertyWithBackingFieldInOuterClass(descriptor)) {
+        if (DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(descriptor)) {
             // For property with backed field, check if the access is done in the same class containing the backed field and
             // not the class that declared the field.
             containingDeclaration = containingDeclaration.getContainingDeclaration();
@@ -219,7 +221,7 @@ public class JvmCodegenUtil {
         if (DescriptorPsiUtilsKt.hasBody(accessor)) return false;
 
         // If the accessor is private or final, it can't be overridden in the subclass and thus we can use direct access
-        return Visibilities.isPrivate(accessor.getVisibility()) || accessor.getModality() == FINAL;
+        return DescriptorVisibilities.isPrivate(accessor.getVisibility()) || accessor.getModality() == FINAL;
     }
 
     public static boolean isDebuggerContext(@NotNull CodegenContext context) {
@@ -338,12 +340,12 @@ public class JvmCodegenUtil {
     public static boolean isCompanionObjectInInterfaceNotIntrinsic(@NotNull DeclarationDescriptor companionObject) {
         return isCompanionObject(companionObject) &&
                isJvmInterface(companionObject.getContainingDeclaration()) &&
-               !JvmAbi.isMappedIntrinsicCompanionObject((ClassDescriptor) companionObject);
+               !DescriptorsJvmAbiUtil.isMappedIntrinsicCompanionObject((ClassDescriptor) companionObject);
     }
 
     public static boolean isNonIntrinsicPrivateCompanionObjectInInterface(@NotNull DeclarationDescriptorWithVisibility companionObject) {
         return isCompanionObjectInInterfaceNotIntrinsic(companionObject) &&
-               Visibilities.isPrivate(companionObject.getVisibility());
+               DescriptorVisibilities.isPrivate(companionObject.getVisibility());
     }
 
     public static boolean isDeclarationOfBigArityFunctionInvoke(@Nullable DeclarationDescriptor descriptor) {
@@ -352,7 +354,7 @@ public class JvmCodegenUtil {
 
     public static boolean isDeclarationOfBigArityCreateCoroutineMethod(@Nullable DeclarationDescriptor descriptor) {
         return descriptor instanceof SimpleFunctionDescriptor && descriptor.getName().asString().equals(SUSPEND_FUNCTION_CREATE_METHOD_NAME) &&
-               ((SimpleFunctionDescriptor) descriptor).getValueParameters().size() >= FunctionInvokeDescriptor.BIG_ARITY - 1 &&
+               ((SimpleFunctionDescriptor) descriptor).getValueParameters().size() >= BuiltInFunctionArity.BIG_ARITY - 1 &&
                descriptor.getContainingDeclaration() instanceof AnonymousFunctionDescriptor && ((AnonymousFunctionDescriptor) descriptor.getContainingDeclaration()).isSuspend();
     }
 
@@ -404,7 +406,7 @@ public class JvmCodegenUtil {
         // The Result class is the only inline class in the standard library without special rules for equality.
         // We only call Result.equals-impl0 if we are compiling for Kotlin 1.4 or later. Otherwise, the code
         // might well be running against an older version of the standard library.
-        if (DescriptorUtils.getFqNameSafe(classDescriptor).equals(DescriptorUtils.RESULT_FQ_NAME)) {
+        if (DescriptorUtils.getFqNameSafe(classDescriptor).equals(StandardNames.RESULT_FQ_NAME)) {
             return state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_4) >= 0;
         } else {
             return ((DeserializedClassDescriptor) descriptor).getMetadataVersion().isAtLeast(1, 1, 16);

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

@@ -24,6 +24,8 @@ import org.jetbrains.kotlin.resolve.calls.checkers.isRestrictsSuspensionReceiver
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
+
 
 class JvmRuntimeTypes(
     module: ModuleDescriptor,
@@ -84,7 +86,7 @@ class JvmRuntimeTypes(
             packageFragment, classKind, false, false, Name.identifier(name), SourceElement.NO_SOURCE, LockBasedStorageManager.NO_LOCKS
         ).apply {
             modality = Modality.FINAL
-            visibility = Visibilities.PUBLIC
+            visibility = DescriptorVisibilities.PUBLIC
             setTypeParameterDescriptors(emptyList())
             createTypeConstructor()
         }
@@ -96,6 +98,14 @@ class JvmRuntimeTypes(
             else
                 descriptor
 
+        if (actualFunctionDescriptor.returnType == null)
+            throw KotlinExceptionWithAttachments(
+                "Return type for function description is null. Super type cannot be calculated." +
+                        "initDesc=${descriptor}, actDesc=${actualFunctionDescriptor}, isReleaseCoroutines=${
+                            languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)
+                        }"
+            )
+
         val functionType = createFunctionType(
             descriptor.builtIns,
             Annotations.EMPTY,
@@ -152,7 +162,7 @@ class JvmRuntimeTypes(
             referencedFunction.isSuspend || isSuspendConversion
         )
 
-        val suspendFunctionType = if (referencedFunction.isSuspend) suspendFunctionInterface?.defaultType else null
+        val suspendFunctionType = if (referencedFunction.isSuspend || isSuspendConversion) suspendFunctionInterface?.defaultType else null
         val superClass = when {
             generateOptimizedCallableReferenceSuperClasses -> when {
                 isAdaptedCallableReference || isSuspendConversion -> adaptedFunctionReference

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

@@ -25,7 +25,8 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotatedImpl;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
-import org.jetbrains.kotlin.load.java.JavaVisibilities;
+import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
+import org.jetbrains.kotlin.load.java.JavaDescriptorVisibilities;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
@@ -56,8 +57,8 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.*;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.calculateInnerClassAccessFlags;
 import static org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.calculateInnerClassAccessFlags;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isNonDefaultInterfaceMember;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.getInlineName;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED;
@@ -257,7 +258,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
             @NotNull Method syntheticMethod,
             @NotNull Annotations annotations
     ) {
-        int flags = ACC_DEPRECATED | ACC_STATIC | ACC_SYNTHETIC | AsmUtil.getVisibilityAccessFlag(descriptor);
+        int flags = ACC_DEPRECATED | ACC_STATIC | ACC_SYNTHETIC | DescriptorAsmUtil.getVisibilityAccessFlag(descriptor);
         MethodVisitor mv = v.newMethod(JvmDeclarationOriginKt.OtherOrigin(descriptor), flags, syntheticMethod.getName(),
                                        syntheticMethod.getDescriptor(), null, null);
         AnnotationCodegen.forMethod(mv, this, state).genAnnotations(new AnnotatedImpl(annotations), Type.VOID_TYPE, null);
@@ -468,7 +469,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
                 Name.special("<clinit>"), SYNTHESIZED, KotlinSourceElementKt.toSourceElement(element));
         clInit.initialize(null, null, Collections.emptyList(), Collections.emptyList(),
                           DescriptorUtilsKt.getModule(descriptor).getBuiltIns().getUnitType(),
-                          Modality.FINAL, Visibilities.PRIVATE);
+                          Modality.FINAL, DescriptorVisibilities.PRIVATE);
         return clInit;
     }
 
@@ -726,7 +727,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     public SourceMapper getOrCreateSourceMapper() {
         if (sourceMapper == null) {
             // note: this is used in InlineCodegen and the element is always physical (KtElement) there
-            sourceMapper = new SourceMapper(SourceInfo.Companion.createInfo((KtElement)element, getClassName()));
+            sourceMapper = new SourceMapper(SourceInfo.Companion.createFromPsi((KtElement)element, getClassName()));
         }
         return sourceMapper;
     }
@@ -877,11 +878,11 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
                     AccessorKind fieldAccessorKind = accessor instanceof AccessorForPropertyBackingField
                                                           ? accessor.getAccessorKind() : null;
                     boolean syntheticBackingField = fieldAccessorKind == AccessorKind.FIELD_FROM_LOCAL;
-                    boolean forceFieldForCompanionProperty = JvmAbi.isPropertyWithBackingFieldInOuterClass(original) &&
+                    boolean forceFieldForCompanionProperty = DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(original) &&
                                                              !isCompanionObject(accessor.getContainingDeclaration());
                     boolean forceField = forceFieldForCompanionProperty ||
                                          syntheticBackingField ||
-                                         original.getVisibility() == JavaVisibilities.PROTECTED_STATIC_VISIBILITY;
+                                         original.getVisibility() == JavaDescriptorVisibilities.PROTECTED_STATIC_VISIBILITY;
                     StackValue property = codegen.intermediateValueForProperty(
                             original, forceField, syntheticBackingField, accessor.getSuperCallTarget(),
                             forceFieldForCompanionProperty, StackValue.none(), null,

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

@@ -224,8 +224,8 @@ class MultifileClassCodegenImpl(
     }
 
     private fun shouldGenerateInFacade(descriptor: MemberDescriptor): Boolean {
-        if (Visibilities.isPrivate(descriptor.visibility)) return false
-        if (AsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE) return false
+        if (DescriptorVisibilities.isPrivate(descriptor.visibility)) return false
+        if (DescriptorAsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE) return false
 
         if (!state.classBuilderMode.generateBodies) return true
 

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

@@ -97,7 +97,7 @@ class MultifileClassPartCodegen(
         val extraFlags = if (shouldGeneratePartHierarchy) JvmAnnotationNames.METADATA_MULTIFILE_PARTS_INHERIT_FLAG else 0
 
         writeKotlinMetadata(v, state, KotlinClassHeader.Kind.MULTIFILE_CLASS_PART, extraFlags) { av ->
-            AsmUtil.writeAnnotationData(av, serializer, packageProto)
+            DescriptorAsmUtil.writeAnnotationData(av, serializer, packageProto)
             av.visit(JvmAnnotationNames.METADATA_MULTIFILE_CLASS_NAME_FIELD_NAME, facadeClassType.internalName)
 
             val kotlinPackageFqName = element.packageFqName

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

@@ -43,7 +43,7 @@ import org.jetbrains.org.objectweb.asm.Type;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.writeAnnotationData;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.writeAnnotationData;
 import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.METADATA_PACKAGE_NAME_FIELD_NAME;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 

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

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
+import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -43,8 +44,8 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.List;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.getDeprecatedAccessFlag;
-import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityForBackingField;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getDeprecatedAccessFlag;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getVisibilityForBackingField;
 import static org.jetbrains.kotlin.codegen.FunctionCodegen.processInterfaceMethod;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
@@ -159,7 +160,7 @@ public class PropertyCodegen {
 
     private void genBackingFieldAndAnnotations(@NotNull PropertyDescriptor descriptor) {
         // Fields and '$annotations' methods for non-private const properties are generated in the multi-file facade
-        boolean isBackingFieldOwner = descriptor.isConst() && !Visibilities.isPrivate(descriptor.getVisibility())
+        boolean isBackingFieldOwner = descriptor.isConst() && !DescriptorVisibilities.isPrivate(descriptor.getVisibility())
                                       ? !(context instanceof MultifileClassPartContext)
                                       : CodegenContextUtil.isImplementationOwner(context, descriptor);
 
@@ -217,7 +218,7 @@ public class PropertyCodegen {
         // and setter, in this case, the property can always be accessed through the accessor 'access<property name>$cp' and avoid some
         // useless indirection by using others accessors.
         if (isCompanionObject(descriptor.getContainingDeclaration())) {
-            if (Visibilities.isPrivate(descriptor.getVisibility()) && isDefaultGetterAndSetter) {
+            if (DescriptorVisibilities.isPrivate(descriptor.getVisibility()) && isDefaultGetterAndSetter) {
                 return false;
             }
             return true;
@@ -227,14 +228,14 @@ public class PropertyCodegen {
         if (isTopLevelInJvmMultifileClass(descriptor)) return true;
 
         // Private class properties have accessors only in cases when those accessors are non-trivial
-        if (Visibilities.isPrivate(descriptor.getVisibility())) {
+        if (DescriptorVisibilities.isPrivate(descriptor.getVisibility())) {
             return !isDefaultAccessor;
         }
 
         // Non-private properties with private setter should not be generated for trivial properties
         // as the class will use direct field access instead
         //noinspection ConstantConditions
-        if (accessor != null && accessor.isSetter() && Visibilities.isPrivate(descriptor.getSetter().getVisibility())) {
+        if (accessor != null && accessor.isSetter() && DescriptorVisibilities.isPrivate(descriptor.getSetter().getVisibility())) {
             return !isDefaultAccessor;
         }
 
@@ -253,12 +254,12 @@ public class PropertyCodegen {
         if (hasJvmFieldAnnotation(descriptor)) return false;
         if (kind == OwnerKind.ERASED_INLINE_CLASS) return false;
 
-        Visibility visibility = descriptor.getVisibility();
+        DescriptorVisibility visibility = descriptor.getVisibility();
         if (InlineClassesUtilsKt.isInlineClass(descriptor.getContainingDeclaration())) {
             return visibility.isPublicAPI();
         }
         else {
-            return !Visibilities.isPrivate(visibility);
+            return !DescriptorVisibilities.isPrivate(visibility);
         }
     }
 
@@ -407,10 +408,10 @@ public class PropertyCodegen {
         ClassBuilder builder = v;
 
         FieldOwnerContext backingFieldContext = context;
-        if (AsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor) ) {
+        if (DescriptorAsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor) ) {
             modifiers |= ACC_STATIC;
 
-            if (JvmAbi.isPropertyWithBackingFieldInOuterClass(propertyDescriptor)) {
+            if (DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor)) {
                 ImplementationBodyCodegen codegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
                 builder = codegen.v;
                 backingFieldContext = codegen.context;
@@ -418,7 +419,7 @@ public class PropertyCodegen {
         }
         modifiers |= getVisibilityForBackingField(propertyDescriptor, isDelegate);
 
-        if (AsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) {
+        if (DescriptorAsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) {
             ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
             parentBodyCodegen.addCompanionObjectPropertyToCopy(propertyDescriptor, defaultValue);
         }
@@ -435,10 +436,10 @@ public class PropertyCodegen {
 
             if (annotatedField != null) {
                 // Don't emit nullability annotations for backing field if:
-                // - backing field is invisible from Java (private or synthetic);
+                // - backing field is synthetic;
                 // - property is lateinit (since corresponding field is actually nullable).
                 boolean skipNullabilityAnnotations =
-                        (modifiers & ACC_PRIVATE) != 0 || (modifiers & ACC_SYNTHETIC) != 0 ||
+                        (modifiers & ACC_SYNTHETIC) != 0 ||
                         propertyDescriptor.isLateInit();
                 AnnotationCodegen.forField(fv, memberCodegen, state, skipNullabilityAnnotations)
                         .genAnnotations(annotatedField, type, propertyDescriptor.getType());
@@ -511,8 +512,8 @@ public class PropertyCodegen {
 
     private void generateAccessor(@Nullable KtPropertyAccessor accessor, @NotNull PropertyAccessorDescriptor descriptor) {
         if (context instanceof MultifileClassFacadeContext &&
-            (Visibilities.isPrivate(descriptor.getVisibility()) ||
-             AsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE)) {
+            (DescriptorVisibilities.isPrivate(descriptor.getVisibility()) ||
+             DescriptorAsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE)) {
             return;
         }
 

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

@@ -92,8 +92,8 @@ class PropertyReferenceCodegen(
             element,
             state.classFileVersion,
             ACC_FINAL or ACC_SUPER or
-                    AsmUtil.getVisibilityAccessFlagForClass(classDescriptor) or
-                    AsmUtil.getSyntheticAccessFlagForLambdaClass(classDescriptor),
+                    DescriptorAsmUtil.getVisibilityAccessFlagForClass(classDescriptor) or
+                    DescriptorAsmUtil.getSyntheticAccessFlagForLambdaClass(classDescriptor),
             asmType.internalName,
             null,
             superAsmType.internalName,
@@ -108,7 +108,7 @@ class PropertyReferenceCodegen(
         if (JvmCodegenUtil.isConst(closure)) {
             generateConstInstance(asmType, wrapperMethod.returnType)
         } else {
-            AsmUtil.genClosureFields(closure, v, typeMapper, state.languageVersionSettings)
+            DescriptorAsmUtil.genClosureFields(closure, v, typeMapper, state.languageVersionSettings)
         }
 
         generateConstructor()

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

@@ -46,7 +46,9 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 import java.util.Collections;
 import java.util.Map;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.codegen.AsmUtil.NO_FLAG_PACKAGE_PRIVATE;
+import static org.jetbrains.kotlin.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.genAreEqualCall;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
@@ -106,7 +108,7 @@ public class SamWrapperCodegen {
         SimpleFunctionDescriptor erasedInterfaceFunction = samType.getOriginalAbstractMethod().copy(
                 classDescriptor,
                 Modality.FINAL,
-                Visibilities.PUBLIC,
+                DescriptorVisibilities.PUBLIC,
                 CallableMemberDescriptor.Kind.SYNTHESIZED,
                 /*copyOverrides=*/ false
         );
@@ -268,12 +270,12 @@ public class SamWrapperCodegen {
             if (!(descriptor instanceof CallableMemberDescriptor)) continue;
             CallableMemberDescriptor member = (CallableMemberDescriptor) descriptor;
             if (member.getModality() == Modality.ABSTRACT ||
-                Visibilities.isPrivate(member.getVisibility()) ||
-                member.getVisibility() == Visibilities.INVISIBLE_FAKE ||
+                DescriptorVisibilities.isPrivate(member.getVisibility()) ||
+                member.getVisibility() == DescriptorVisibilities.INVISIBLE_FAKE ||
                 DescriptorUtils.isMethodOfAny(member)) continue;
 
             for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.INSTANCE.copyFunctions(
-                    member, member, classDescriptor, Modality.OPEN, Visibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, false
+                    member, member, classDescriptor, Modality.OPEN, DescriptorVisibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, false
             ).entrySet()) {
                 ClassBodyCodegen.generateDelegationToDefaultImpl(entry.getKey(), entry.getValue(), receiverType, functionCodegen, state, false);
             }

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.codegen.AsmUtil.writeAnnotationData
 import org.jetbrains.kotlin.codegen.context.CodegenContext
 import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.context.ScriptContext
@@ -71,7 +70,7 @@ class ScriptCodegen private constructor(
         val serializer = DescriptorSerializer.create(scriptDescriptor, JvmSerializerExtension(v.serializationBindings, state), null)
         val classProto = serializer.classProto(scriptDescriptor).build()
         writeKotlinMetadata(v, state, KotlinClassHeader.Kind.CLASS, JvmAnnotationNames.METADATA_SCRIPT_FLAG) { av ->
-            writeAnnotationData(av, serializer, classProto)
+            DescriptorAsmUtil.writeAnnotationData(av, serializer, classProto)
         }
     }
 

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

@@ -21,28 +21,26 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 
-data class SourceInfo(val source: String, val pathOrCleanFQN: String, val linesInFile: Int) {
+data class SourceInfo(
+    val sourceFileName: String?,
+    val pathOrCleanFQN: String,
+    val linesInFile: Int
+) {
 
     companion object {
-        fun createInfo(element: KtElement?, internalClassName: String): SourceInfo {
+        fun createFromPsi(element: KtElement?, internalClassName: String): SourceInfo {
             assert(element != null) { "Couldn't create source mapper for null element $internalClassName" }
             val lineNumbers = CodegenUtil.getLineNumberForElement(element!!.containingFile, true)
-                    ?: error("Couldn't extract line count in ${element.containingFile}")
+                ?: error("Couldn't extract line count in ${element.containingFile}")
 
             //TODO hack condition for package parts cleaning
             val isTopLevel = element is KtFile || (element is KtNamedFunction && element.getParent() is KtFile)
             val cleanedClassFqName = if (!isTopLevel) internalClassName else internalClassName.substringBefore('$')
 
-            return SourceInfo(element.containingKtFile.name, cleanedClassFqName, lineNumbers)
+            val fileName = element.containingKtFile.name
+            return SourceInfo(fileName, cleanedClassFqName, lineNumbers)
         }
 
-        fun createInfoForIr(lineNumbers: Int, internalClassName: String, containingFileName: String): SourceInfo {
-            //TODO cut topLevel names
-//            val isTopLevel = element is KtFile || (element is KtNamedFunction && element.getParent() is KtFile)
-//            val cleanedClassFqName = if (!isTopLevel) internalClassName else internalClassName.substringBefore('$')
-
-            return SourceInfo(containingFileName, internalClassName, lineNumbers)
-        }
     }
 }
 

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

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
+import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.KtExpression;
@@ -1543,7 +1544,7 @@ public abstract class StackValue {
 
                 //TODO: try to don't generate defaults at all in CollectionElementReceiver
 
-                List<ResolvedValueArgument> getterArguments = new ArrayList(collectionElementReceiver.valueArguments);
+                List<ResolvedValueArgument> getterArguments = new ArrayList<>(collectionElementReceiver.valueArguments);
                 List<ResolvedValueArgument> getterDefaults = CollectionsKt.takeLastWhile(getterArguments,
                                                                                          argument -> argument instanceof DefaultValueArgument);
 
@@ -1761,7 +1762,7 @@ public abstract class StackValue {
                 // is from a different context), the assertion will be generated on each access, see KT-28331.
                 if (descriptor instanceof AccessorForPropertyBackingField) {
                     PropertyDescriptor property = ((AccessorForPropertyBackingField) descriptor).getCalleeDescriptor();
-                    if (!skipLateinitAssertion && property.isLateInit() && JvmAbi.isPropertyWithBackingFieldInOuterClass(property) &&
+                    if (!skipLateinitAssertion && property.isLateInit() && DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(property) &&
                         !JvmCodegenUtil.couldUseDirectAccessToProperty(property, true, false, codegen.context, false)) {
                         genNonNullAssertForLateinit(v, property.getName().asString());
                     }

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

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.codegen
+
+import com.google.common.collect.Sets
+import org.jetbrains.kotlin.codegen.BranchedValue.Companion.FALSE
+import org.jetbrains.kotlin.codegen.BranchedValue.Companion.TRUE
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.config.JvmStringConcat
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes.JAVA_STRING_TYPE
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Handle
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import java.lang.StringBuilder
+
+class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapter) {
+
+    private val template = StringBuilder("")
+    private val paramTypes = arrayListOf<Type>()
+    private var justFlushed = false
+
+    @JvmOverloads
+    fun genStringBuilderConstructorIfNeded(swap: Boolean = false) {
+        if (mode.isDynamic) return
+        mv.visitTypeInsn(Opcodes.NEW, "java/lang/StringBuilder")
+        mv.dup()
+        mv.invokespecial("java/lang/StringBuilder", "<init>", "()V", false)
+        if (swap) {
+            mv.swap()
+        }
+    }
+
+    @JvmOverloads
+    fun putValueOrProcessConstant(stackValue: StackValue, type: Type = stackValue.type, kotlinType: KotlinType? = stackValue.kotlinType) {
+        justFlushed = false
+        if (mode == JvmStringConcat.INDY_WITH_CONSTANTS) {
+            when (stackValue) {
+                is StackValue.Constant -> {
+                    template.append(stackValue.value)
+                    return
+                }
+                TRUE -> {
+                    template.append(true)
+                    return
+                }
+                FALSE -> {
+                    template.append(false)
+                    return
+                }
+            }
+        }
+        stackValue.put(type, kotlinType, mv)
+        invokeAppend(type)
+    }
+
+    fun addStringConstant(value: String) {
+        putValueOrProcessConstant(StackValue.constant(value, JAVA_STRING_TYPE, null))
+    }
+
+    fun invokeAppend(type: Type) {
+        if (!mode.isDynamic) {
+            mv.invokevirtual(
+                "java/lang/StringBuilder",
+                "append",
+                "(" + stringBuilderAppendType(type) + ")Ljava/lang/StringBuilder;",
+                false
+            )
+        } else {
+            justFlushed = false
+            paramTypes.add(type)
+            template.append("\u0001")
+            if (paramTypes.size == 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"
+                genToString()
+                justFlushed = true
+            }
+        }
+    }
+
+    fun genToString() {
+        if (!mode.isDynamic) {
+            mv.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false)
+        } else {
+            //if state was flushed in `invokeAppend` do nothing
+            if (justFlushed) return
+            if (mode == JvmStringConcat.INDY_WITH_CONSTANTS) {
+                val bootstrap = Handle(
+                    Opcodes.H_INVOKESTATIC,
+                    "java/lang/invoke/StringConcatFactory",
+                    "makeConcatWithConstants",
+                    "(Ljava/lang/invoke/MethodHandles\$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;",
+                    false
+                )
+
+                mv.invokedynamic(
+                    "makeConcatWithConstants",
+                    Type.getMethodDescriptor(JAVA_STRING_TYPE, *paramTypes.toTypedArray()),
+                    bootstrap,
+                    arrayOf(template.toString())
+                )
+            } else {
+                val bootstrap = Handle(
+                    Opcodes.H_INVOKESTATIC,
+                    "java/lang/invoke/StringConcatFactory",
+                    "makeConcat",
+                    "(Ljava/lang/invoke/MethodHandles\$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;",
+                    false
+                )
+
+                mv.invokedynamic(
+                    "makeConcat",
+                    Type.getMethodDescriptor(JAVA_STRING_TYPE, *paramTypes.toTypedArray()),
+                    bootstrap,
+                    arrayOf()
+                )
+            }
+            template.clear()
+            paramTypes.clear()
+            paramTypes.add(JAVA_STRING_TYPE)
+            template.append("\u0001")
+        }
+    }
+
+    companion object {
+        private val STRING_BUILDER_OBJECT_APPEND_ARG_TYPES: Set<Type> = Sets.newHashSet(
+            AsmTypes.getType(String::class.java),
+            AsmTypes.getType(StringBuffer::class.java),
+            AsmTypes.getType(CharSequence::class.java)
+        )
+
+        private fun stringBuilderAppendType(type: Type): Type {
+            return when (type.sort) {
+                Type.OBJECT -> if (STRING_BUILDER_OBJECT_APPEND_ARG_TYPES.contains(type)) type else AsmTypes.OBJECT_TYPE
+                Type.ARRAY -> AsmTypes.OBJECT_TYPE
+                Type.BYTE, Type.SHORT -> Type.INT_TYPE
+                else -> type
+            }
+        }
+
+        fun create(state: GenerationState, mv: InstructionAdapter) =
+            StringConcatGenerator(state.runtimeStringConcat, mv)
+
+    }
+}

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
-import org.jetbrains.kotlin.resolve.jvm.checkers.isValidDalvikCharacter
 
 const val DESTRUCTURED_LAMBDA_ARGUMENT_VARIABLE_PREFIX = "\$dstr\$"
 
@@ -26,25 +25,3 @@ fun getNameForDestructuredParameterOrNull(valueParameterDescriptor: ValueParamet
         )
     }
 }
-
-fun mangleNameIfNeeded(name: String): String {
-    if (name.all { it.isValidCharacter() }) {
-        return name
-    }
-
-    return buildString {
-        for (c in name) {
-            if (c.isValidCharacter()) {
-                append(c)
-            } else {
-                val hexString = Integer.toHexString(c.toInt())
-                assert(hexString.length <= 4)
-                append("_u").append(hexString)
-            }
-        }
-    }
-}
-
-private fun Char.isValidCharacter(): Boolean {
-    return this != '$' && this != '-' && isValidDalvikCharacter(this)
-}

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

@@ -616,7 +616,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         String nameForClassOrPackageMember = getNameForClassOrPackageMember(functionDescriptor);
 
         if (functionDescriptor instanceof SimpleFunctionDescriptor && functionDescriptor.isSuspend() &&
-            !functionDescriptor.getVisibility().equals(Visibilities.LOCAL)) {
+            !functionDescriptor.getVisibility().equals(DescriptorVisibilities.LOCAL)) {
 
             if (nameForClassOrPackageMember != null) {
                 nameStack.push(nameForClassOrPackageMember);
@@ -821,20 +821,17 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
 
         Map<ValueParameterDescriptor, ResolvedValueArgument> arguments = newResolvedCall.getValueArguments();
         for (ValueParameterDescriptor valueParameter : arguments.keySet()) {
-            SamType samType = SamType.createByValueParameter(valueParameter);
-            if (samType == null) continue;
-
             ResolvedValueArgument argument = arguments.get(valueParameter);
             if (argument instanceof ExpressionValueArgument) {
                 ValueArgument valueArgument = ((ExpressionValueArgument) argument).getValueArgument();
                 if (valueArgument != null && newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) != null) {
-                    recordSamTypeOnArgumentExpression(samType, valueArgument);
+                    recordSamTypeOnArgumentExpression(valueParameter, valueArgument);
                 }
             } else if (argument instanceof VarargValueArgument) {
                 VarargValueArgument varargValueArgument = (VarargValueArgument) argument;
                 for (ValueArgument valueArgument : varargValueArgument.getArguments()) {
                     if (valueArgument != null && newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) != null) {
-                        recordSamTypeOnArgumentExpression(samType, valueArgument);
+                        recordSamTypeOnArgumentExpression(valueParameter, valueArgument);
                     }
                 }
             }
@@ -872,6 +869,13 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         }
     }
 
+    private void recordSamTypeOnArgumentExpression(ValueParameterDescriptor valueParameter, ValueArgument valueArgument) {
+        SamType samType = SamType.createByValueParameter(valueParameter);
+        if (samType == null) return;
+
+        recordSamTypeOnArgumentExpression(samType, valueArgument);
+    }
+
     private void recordSamTypeOnArgumentExpression(SamType samType, ValueArgument valueArgument) {
         KtExpression argumentExpression = valueArgument.getArgumentExpression();
         assert argumentExpression != null : valueArgument.asElement().getText();

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

@@ -20,6 +20,7 @@ import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.AsmUtil;
+import org.jetbrains.kotlin.codegen.DescriptorAsmUtil;
 import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.config.LanguageVersionSettings;
@@ -113,7 +114,7 @@ public final class MutableClosure implements CalculatedClosure {
                 return AsmUtil.CAPTURED_RECEIVER_FIELD;
             }
 
-            String labeledThis = AsmUtil.getNameForCapturedReceiverField(
+            String labeledThis = DescriptorAsmUtil.getNameForCapturedReceiverField(
                     enclosingFunWithReceiverDescriptor, bindingContext, languageVersionSettings);
 
             return AsmUtil.getCapturedFieldName(labeledThis);

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

@@ -87,7 +87,7 @@ fun InstructionAdapter.generateClosureFieldsInitializationFromParameters(
             k += fieldInfo.fieldType.size
             continue
         }
-        k = AsmUtil.genAssignInstanceFieldFromParam(fieldInfo, k, this)
+        k = DescriptorAsmUtil.genAssignInstanceFieldFromParam(fieldInfo, k, this)
     }
 
     return boundReferenceReceiverFieldInfo?.let { Pair(boundReferenceReceiverParameterIndex, it) }
@@ -122,7 +122,7 @@ internal fun generateCallableReferenceDeclarationContainerClass(
             // TODO: would it work for arrays?
             val containerKotlinType = container.defaultType
             val containerType = typeMapper.mapClass(container)
-            AsmUtil.putJavaLangClassInstance(iv, containerType, containerKotlinType, typeMapper)
+            DescriptorAsmUtil.putJavaLangClassInstance(iv, containerType, containerKotlinType, typeMapper)
         }
         container is PackageFragmentDescriptor -> {
             iv.aconst(typeMapper.mapOwner(descriptor))
@@ -211,4 +211,4 @@ private fun getSignatureString(callable: CallableDescriptor, state: GenerationSt
             state.typeMapper.mapAsmMethod(declaration)
     }
     return method.name + method.descriptor
-}
+}

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

@@ -19,14 +19,13 @@ import org.jetbrains.kotlin.codegen.inline.ReificationArgument
 import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
-import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.deserialization.PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.SpecialSignatureInfo
-import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -98,11 +97,12 @@ fun generateAsCast(
     kotlinType: KotlinType,
     asmType: Type,
     isSafe: Boolean,
-    languageVersionSettings: LanguageVersionSettings
+    languageVersionSettings: LanguageVersionSettings,
+    unifiedNullChecks: Boolean,
 ) {
     if (!isSafe) {
         if (!TypeUtils.isNullableType(kotlinType)) {
-            generateNullCheckForNonSafeAs(v, kotlinType, languageVersionSettings)
+            generateNullCheckForNonSafeAs(v, kotlinType, unifiedNullChecks)
         }
     } else {
         with(v) {
@@ -122,15 +122,13 @@ fun generateAsCast(
 private fun generateNullCheckForNonSafeAs(
     v: InstructionAdapter,
     type: KotlinType,
-    languageVersionSettings: LanguageVersionSettings
+    unifiedNullChecks: Boolean,
 ) {
     with(v) {
         dup()
         val nonnull = Label()
         ifnonnull(nonnull)
-        val exceptionClass =
-            if (languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4) "java/lang/NullPointerException"
-            else "kotlin/TypeCastException"
+        val exceptionClass = if (unifiedNullChecks) "java/lang/NullPointerException" else "kotlin/TypeCastException"
         AsmUtil.genThrow(
             v,
             exceptionClass,
@@ -154,7 +152,7 @@ fun populateCompanionBackingFieldNamesToOuterContextIfNeeded(
         return
     }
 
-    if (!JvmAbi.isClassCompanionObjectWithBackingFieldsInOuter(descriptor)) {
+    if (!DescriptorsJvmAbiUtil.isClassCompanionObjectWithBackingFieldsInOuter(descriptor)) {
         return
     }
     val properties = companion.declarations.filterIsInstance<KtProperty>()
@@ -590,7 +588,7 @@ private fun generateLambdaForRunSuspend(
 
     lambdaBuilder.newField(
         JvmDeclarationOrigin.NO_ORIGIN,
-        ACC_PRIVATE or ACC_FINAL,
+        ACC_PRIVATE or ACC_FINAL or ACC_SYNTHETIC,
         "args",
         ARRAY_OF_STRINGS_TYPE.descriptor, null, null
     )
@@ -685,4 +683,4 @@ internal fun LabelNode.linkWithLabel(): LabelNode {
     return this
 }
 
-fun linkedLabel(): Label = LabelNode().linkWithLabel().label
+fun linkedLabel(): Label = LabelNode().linkWithLabel().label

compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java

@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.config.JvmDefaultMode;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.load.java.JavaVisibilities;
-import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor;
+import org.jetbrains.kotlin.load.java.JavaDescriptorVisibilities;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
+import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.storage.NullableLazyValue;
 import org.jetbrains.kotlin.types.KotlinType;
@@ -27,7 +27,7 @@ import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.*;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityAccessFlag;
+import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getVisibilityAccessFlag;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isInSamePackage;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isNonDefaultInterfaceMember;
 import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
@@ -625,7 +625,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
         }
 
         if (descriptorContext == null &&
-            JavaVisibilities.PROTECTED_STATIC_VISIBILITY == descriptor.getVisibility() &&
+            JavaDescriptorVisibilities.PROTECTED_STATIC_VISIBILITY == descriptor.getVisibility() &&
             (!(descriptor.getOriginal() instanceof SamConstructorDescriptor))) {
             //seems we need static receiver in resolved call
             descriptorContext = ExpressionCodegen.getParentContextSubclassOf((ClassDescriptor) enclosed, this);
@@ -672,7 +672,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
             PropertySetterDescriptor setter = propertyDescriptor.getSetter();
 
             int setterAccessFlag = propertyAccessFlag;
-            if (setter != null && setter.getVisibility().normalize() != Visibilities.INVISIBLE_FAKE) {
+            if (setter != null && setter.getVisibility().normalize() != DescriptorVisibilities.INVISIBLE_FAKE) {
                 setterAccessFlag = propertyAccessFlag | getVisibilityAccessFlag(setter);
             }
             boolean setterAccessorRequired = isAccessorRequired(setterAccessFlag, unwrappedDescriptor, descriptorContext,

compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.codegen.context;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.codegen.AsmUtil;
+import org.jetbrains.kotlin.codegen.DescriptorAsmUtil;
 import org.jetbrains.kotlin.codegen.JvmCodegenUtil;
 import org.jetbrains.kotlin.codegen.OwnerKind;
 import org.jetbrains.kotlin.codegen.StackValue;
@@ -67,7 +67,7 @@ public class MethodContext extends CodegenContext<CallableMemberDescriptor> {
         @SuppressWarnings("ConstantConditions")
         KotlinType kotlinType = getCallableDescriptorWithReceiver().getExtensionReceiverParameter().getType();
         Type asmType = typeMapper.mapType(kotlinType);
-        return StackValue.local(AsmUtil.getReceiverIndex(this, getContextDescriptor()), asmType, kotlinType);
+        return StackValue.local(DescriptorAsmUtil.getReceiverIndex(this, getContextDescriptor()), asmType, kotlinType);
     }
 
     @Override

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

@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.typeUtil.makeNullable
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.kotlin.utils.sure
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.MethodVisitor
@@ -95,7 +94,7 @@ abstract class AbstractCoroutineCodegen(
                 },
                 builtIns.nullableAnyType,
                 Modality.FINAL,
-                Visibilities.PUBLIC,
+                DescriptorVisibilities.PUBLIC,
                 userDataForDoResume
             )
         }
@@ -104,9 +103,9 @@ abstract class AbstractCoroutineCodegen(
         ValueParameterDescriptorImpl(
             this, null, index, Annotations.EMPTY, name,
             type,
-            false, false,
-            false,
-            null, SourceElement.NO_SOURCE
+            declaresDefaultValue = false, isCrossinline = false,
+            isNoinline = false,
+            varargElementType = null, source = SourceElement.NO_SOURCE
         )
 
     override fun generateConstructor(): Method {
@@ -157,7 +156,7 @@ abstract class AbstractCoroutineCodegen(
         return constructor
     }
 
-    abstract protected val passArityToSuperClass: Boolean
+    protected abstract val passArityToSuperClass: Boolean
 }
 
 class CoroutineCodegenForLambda private constructor(
@@ -187,6 +186,23 @@ class CoroutineCodegenForLambda private constructor(
 
     private val endLabel = Label()
 
+    private val varsCountByType = hashMapOf<Type, Int>()
+
+    private val fieldsForParameters: Map<ParameterDescriptor, FieldInfo> = createFieldsForParameters()
+
+    private fun createFieldsForParameters(): Map<ParameterDescriptor, FieldInfo> {
+        val result = hashMapOf<ParameterDescriptor, FieldInfo>()
+        for (parameter in allFunctionParameters()) {
+            if (parameter.isUnused()) continue
+            val type = state.typeMapper.mapType(parameter.type)
+            val normalizedType = type.normalize()
+            val index = varsCountByType[normalizedType]?.plus(1) ?: 0
+            varsCountByType[normalizedType] = index
+            result[parameter] = createHiddenFieldInfo(parameter.type, "${normalizedType.descriptor[0]}$$index")
+        }
+        return result
+    }
+
     private fun getCreateFunction(): SimpleFunctionDescriptor = SimpleFunctionDescriptorImpl.create(
         funDescriptor.containingDeclaration,
         Annotations.EMPTY,
@@ -204,7 +220,7 @@ class CoroutineCodegenForLambda private constructor(
                 state.languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)
             ),
             funDescriptor.modality,
-            Visibilities.PUBLIC
+            DescriptorVisibilities.PUBLIC
         )
     }
 
@@ -232,11 +248,10 @@ class CoroutineCodegenForLambda private constructor(
 
     override fun generateClosureBody() {
         for (parameter in allFunctionParameters()) {
-            if (parameter.isUnused()) continue
-            val fieldInfo = parameter.getFieldInfoForCoroutineLambdaParameter()
+            val fieldInfo = fieldsForParameters[parameter] ?: continue
             v.newField(
                 OtherOrigin(parameter),
-                Opcodes.ACC_PRIVATE,
+                Opcodes.ACC_PRIVATE + Opcodes.ACC_SYNTHETIC,
                 fieldInfo.fieldName,
                 fieldInfo.fieldType.descriptor, null, null
             )
@@ -257,7 +272,7 @@ class CoroutineCodegenForLambda private constructor(
         super.generateBody()
 
         if (doNotGenerateInvokeBridge) {
-            v.serializationBindings.put<FunctionDescriptor, Method>(
+            v.serializationBindings.put(
                 METHOD_FOR_FUNCTION,
                 originalSuspendFunctionDescriptor,
                 typeMapper.mapAsmMethod(erasedInvokeFunction)
@@ -296,7 +311,7 @@ class CoroutineCodegenForLambda private constructor(
         val untypedAsmMethod = typeMapper.mapAsmMethod(untypedDescriptor)
         val jvmMethodSignature = typeMapper.mapSignatureSkipGeneric(untypedDescriptor)
         val mv = v.newMethod(
-            OtherOrigin(element, funDescriptor), AsmUtil.getVisibilityAccessFlag(untypedDescriptor) or Opcodes.ACC_FINAL,
+            OtherOrigin(element, funDescriptor), DescriptorAsmUtil.getVisibilityAccessFlag(untypedDescriptor) or Opcodes.ACC_FINAL,
             untypedAsmMethod.name, untypedAsmMethod.descriptor, null, ArrayUtil.EMPTY_STRING_ARRAY
         )
         mv.visitCode()
@@ -320,7 +335,7 @@ class CoroutineCodegenForLambda private constructor(
             newarray(AsmTypes.OBJECT_TYPE)
             // 0 - this
             // 1..22 - parameters
-            // 23 - first empy slot
+            // 23 - first empty slot
             val arraySlot = 23
             store(arraySlot, AsmTypes.OBJECT_TYPE)
             for ((varIndex, type) in parameterTypes.withVariableIndices()) {
@@ -405,8 +420,8 @@ class CoroutineCodegenForLambda private constructor(
             // Pass lambda parameters to 'invoke' call on newly constructed object
             var index = 1
             for (parameter in allFunctionParameters()) {
-                val fieldInfoForCoroutineLambdaParameter = parameter.getFieldInfoForCoroutineLambdaParameter()
-                if (!parameter.isUnused()) {
+                val fieldInfoForCoroutineLambdaParameter = fieldsForParameters[parameter]
+                if (fieldInfoForCoroutineLambdaParameter != null) {
                     if (isBigArity) {
                         load(cloneIndex, fieldInfoForCoroutineLambdaParameter.ownerType)
                         load(1, AsmTypes.OBJECT_TYPE)
@@ -433,7 +448,7 @@ class CoroutineCodegenForLambda private constructor(
                         } else {
                             load(index, fieldInfoForCoroutineLambdaParameter.fieldType)
                         }
-                        AsmUtil.genAssignInstanceFieldFromParam(
+                        DescriptorAsmUtil.genAssignInstanceFieldFromParam(
                             fieldInfoForCoroutineLambdaParameter,
                             index,
                             this,
@@ -442,7 +457,7 @@ class CoroutineCodegenForLambda private constructor(
                         )
                     }
                 }
-                index += if (isBigArity || generateErasedCreate) 1 else fieldInfoForCoroutineLambdaParameter.fieldType.size
+                index += if (isBigArity || generateErasedCreate) 1 else state.typeMapper.mapType(parameter.type).size
             }
 
             load(cloneIndex, AsmTypes.OBJECT_TYPE)
@@ -452,26 +467,31 @@ class CoroutineCodegenForLambda private constructor(
 
     private fun ExpressionCodegen.initializeCoroutineParameters() {
         for (parameter in allFunctionParameters()) {
-            if (parameter.isUnused()) continue
-            val fieldStackValue =
-                StackValue.field(
-                    parameter.getFieldInfoForCoroutineLambdaParameter(), generateThisOrOuter(context.thisDescriptor, false)
-                )
+            val fieldForParameter = fieldsForParameters[parameter] ?: continue
+            val fieldStackValue = StackValue.field(fieldForParameter, generateThisOrOuter(context.thisDescriptor, false))
 
-            val mappedType = typeMapper.mapType(parameter.type)
-            fieldStackValue.put(mappedType, v)
+            val originalType = typeMapper.mapType(parameter.type)
+            // If a parameter has reference type, it has prefix L$,
+            // however, when the type is primitive, its prefix is ${type.descriptor}$.
+            // In other words, it the type is Boolean, the prefix is Z$.
+            // This is different from spilled variables, where all int-like primitives have prefix I$.
+            // This is not a problem, since we do not clean spilled primitives up
+            // and we do not coerce Int to Boolean, which takes quite a bit of bytecode (see coerceInt).
+            val normalizedType = originalType.normalize()
+            fieldStackValue.put(normalizedType, v)
 
-            val newIndex = myFrameMap.enter(parameter, mappedType)
-            v.store(newIndex, mappedType)
+            val newIndex = myFrameMap.enter(parameter, originalType)
+            StackValue.coerce(normalizedType, originalType, v)
+            v.store(newIndex, originalType)
 
             val name =
                 if (parameter is ReceiverParameterDescriptor)
-                    AsmUtil.getNameForReceiverParameter(originalSuspendFunctionDescriptor, bindingContext, languageVersionSettings)
+                    DescriptorAsmUtil.getNameForReceiverParameter(originalSuspendFunctionDescriptor, bindingContext, languageVersionSettings)
                 else
                     (getNameForDestructuredParameterOrNull(parameter as ValueParameterDescriptor) ?: parameter.name.asString())
             val label = Label()
             v.mark(label)
-            v.visitLocalVariable(name, mappedType.descriptor, null, label, endLabel, newIndex)
+            v.visitLocalVariable(name, originalType.descriptor, null, label, endLabel, newIndex)
         }
 
         initializeVariablesForDestructuredLambdaParameters(
@@ -485,13 +505,10 @@ class CoroutineCodegenForLambda private constructor(
         originalSuspendFunctionDescriptor.extensionReceiverParameter.let(::listOfNotNull) +
                 originalSuspendFunctionDescriptor.valueParameters
 
-    private fun ParameterDescriptor.getFieldInfoForCoroutineLambdaParameter() =
-        createHiddenFieldInfo(type, COROUTINE_LAMBDA_PARAMETER_PREFIX + (this.safeAs<ValueParameterDescriptor>()?.index ?: ""))
-
     private fun createHiddenFieldInfo(type: KotlinType, name: String) =
         FieldInfo.createForHiddenField(
             typeMapper.mapClass(closureContext.thisDescriptor),
-            typeMapper.mapType(type),
+            typeMapper.mapType(type).normalize(),
             type,
             name
         )
@@ -514,7 +531,8 @@ class CoroutineCodegenForLambda private constructor(
                         isForNamedFunction = false,
                         languageVersionSettings = languageVersionSettings,
                         disableTailCallOptimizationForFunctionReturningUnit = false,
-                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
+                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS),
+                        initialVarsCountByType = varsCountByType
                     )
                     val maybeWithForInline = if (forInline)
                         SuspendForInlineCopyingMethodVisitor(stateMachineBuilder, access, name, desc, functionCodegen::newMethod)
@@ -618,6 +636,9 @@ class CoroutineCodegenForNamedFunction private constructor(
 
     override val passArityToSuperClass get() = false
 
+    private val inlineClassToBoxInInvokeSuspend: KotlinType? =
+        originalSuspendFunctionDescriptor.originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(state.typeMapper)
+
     override fun generateBridges() {
         // Do not generate any closure bridges
     }
@@ -701,6 +722,17 @@ class CoroutineCodegenForNamedFunction private constructor(
                         callableMethod.genInvokeInstruction(codegen.v)
                     }
 
+                    if (inlineClassToBoxInInvokeSuspend != null) {
+                        with(codegen.v) {
+                            // We need to box the returned inline class in resume path.
+                            // But first, check for COROUTINE_SUSPENDED, since the function can return it
+                            generateCoroutineSuspendedCheck(languageVersionSettings)
+                            // Now we box the inline class
+                            StackValue.coerce(AsmTypes.OBJECT_TYPE, typeMapper.mapType(inlineClassToBoxInInvokeSuspend), this)
+                            StackValue.boxInlineClass(inlineClassToBoxInInvokeSuspend, this)
+                        }
+                    }
+
                     codegen.v.visitInsn(Opcodes.ARETURN)
                 }
             }
@@ -746,7 +778,7 @@ class CoroutineCodegenForNamedFunction private constructor(
                 serializer.functionProto(
                     createFreeFakeLambdaDescriptor(suspendFunctionJvmView, state.typeApproximator)
                 )?.build() ?: return@writeKotlinMetadata
-            AsmUtil.writeAnnotationData(av, serializer, functionProto)
+            DescriptorAsmUtil.writeAnnotationData(av, serializer, functionProto)
         }
     }
 
@@ -758,16 +790,11 @@ class CoroutineCodegenForNamedFunction private constructor(
             declaration: KtFunction
         ): CoroutineCodegenForNamedFunction {
             val bindingContext = expressionCodegen.state.bindingContext
-            val closure =
-                bindingContext[
-                        CodegenBinding.CLOSURE,
-                        bindingContext[CodegenBinding.CLASS_FOR_CALLABLE, originalSuspendDescriptor]
-                ].sure { "There must be a closure defined for $originalSuspendDescriptor" }
+            val closure = bindingContext[CLOSURE, bindingContext[CodegenBinding.CLASS_FOR_CALLABLE, originalSuspendDescriptor]]
+                .sure { "There must be a closure defined for $originalSuspendDescriptor" }
 
-            val suspendFunctionView =
-                bindingContext[
-                        CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendDescriptor
-                ].sure { "There must be a jvm view defined for $originalSuspendDescriptor" }
+            val suspendFunctionView = bindingContext[CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendDescriptor]
+                .sure { "There must be a jvm view defined for $originalSuspendDescriptor" }
 
             if (suspendFunctionView.dispatchReceiverParameter != null) {
                 closure.setNeedsCaptureOuterClass()
@@ -785,10 +812,8 @@ class CoroutineCodegenForNamedFunction private constructor(
     }
 }
 
-private const val COROUTINE_LAMBDA_PARAMETER_PREFIX = "p$"
-
 private object FailingFunctionGenerationStrategy : FunctionGenerationStrategy() {
-    override fun skipNotNullAssertionsForParameters(): kotlin.Boolean {
+    override fun skipNotNullAssertionsForParameters(): Boolean {
         error("This functions must not be called")
     }
 
@@ -805,4 +830,4 @@ private object FailingFunctionGenerationStrategy : FunctionGenerationStrategy()
 
 fun reportSuspensionPointInsideMonitor(element: KtElement, state: GenerationState, stackTraceElement: String) {
     state.diagnostics.report(ErrorsJvm.SUSPENSION_POINT_INSIDE_MONITOR.on(element, stackTraceElement))
-}
+}

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

@@ -20,6 +20,7 @@ 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.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import kotlin.math.max
 
 private const val COROUTINES_DEBUG_METADATA_VERSION = 1
@@ -63,7 +64,9 @@ class CoroutineTransformerMethodVisitor(
     // JVM_IR backend generates $completion, while old backend does not
     private val putContinuationParameterToLvt: Boolean = true,
     // New SourceInterpreter-less analyser can be somewhat unstable, disable it
-    private val useOldSpilledVarTypeAnalysis: Boolean = false
+    private val useOldSpilledVarTypeAnalysis: Boolean = false,
+    // Parameters of suspend lambda are put to the same fields as spilled variables
+    private val initialVarsCountByType: Map<Type, Int> = emptyMap()
 ) : TransformationMethodVisitor(delegate, access, name, desc, signature, exceptions) {
 
     private val classBuilderForCoroutineState: ClassBuilder by lazy(obtainClassBuilderForCoroutineState)
@@ -111,6 +114,7 @@ class CoroutineTransformerMethodVisitor(
             if (examiner.allSuspensionPointsAreTailCalls(suspensionPoints)) {
                 examiner.replacePopsBeforeSafeUnitInstancesWithCoroutineSuspendedChecks()
                 dropSuspensionMarkers(methodNode)
+                dropUnboxInlineClassMarkers(methodNode, suspensionPoints)
                 return
             }
 
@@ -132,15 +136,19 @@ class CoroutineTransformerMethodVisitor(
 
         UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
 
+        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
+
         val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)
 
         val suspendMarkerVarIndex = methodNode.maxLocals++
 
         val suspensionPointLineNumbers = suspensionPoints.map { findSuspensionPointLineNumber(it) }
 
-        val continuationLabels = suspensionPoints.withIndex().map {
-            transformCallAndReturnContinuationLabel(
-                it.index + 1, it.value, methodNode, suspendMarkerVarIndex, suspensionPointLineNumbers[it.index])
+        // Create states in state-machine, to which state-machine can jump
+        val stateLabels = suspensionPoints.withIndex().map {
+            transformCallAndReturnStateLabel(
+                it.index + 1, it.value, methodNode, suspendMarkerVarIndex, suspensionPointLineNumbers[it.index]
+            )
         }
 
         methodNode.instructions.apply {
@@ -163,7 +171,7 @@ class CoroutineTransformerMethodVisitor(
                         0,
                         suspensionPoints.size,
                         defaultLabel,
-                        firstStateLabel, *continuationLabels.toTypedArray()
+                        firstStateLabel, *stateLabels.toTypedArray()
                     ),
                     firstStateLabel
                 )
@@ -180,25 +188,39 @@ class CoroutineTransformerMethodVisitor(
             })
         }
 
+        initializeFakeInlinerVariables(methodNode, stateLabels)
+
         dropSuspensionMarkers(methodNode)
+        dropUnboxInlineClassMarkers(methodNode, suspensionPoints)
         methodNode.removeEmptyCatchBlocks()
 
-        // The parameters (and 'this') shall live throughout the method, otherwise, d8 emits warning about invalid debug info
-        val startLabel = LabelNode()
-        val endLabel = LabelNode()
-        methodNode.instructions.insertBefore(methodNode.instructions.first, startLabel)
-        methodNode.instructions.insert(methodNode.instructions.last, endLabel)
-
-        fixLvtForParameters(methodNode, startLabel, endLabel)
-
         if (languageVersionSettings.isReleaseCoroutines()) {
             writeDebugMetadata(methodNode, suspensionPointLineNumbers, spilledToVariableMapping)
         }
     }
 
+    // When suspension point is inlined, it is in range of fake inliner variables.
+    // Path from TABLESWITCH into unspilling goes to latter part of the range.
+    // In this case the variables are uninitialized, initialize them
+    private fun initializeFakeInlinerVariables(methodNode: MethodNode, stateLabels: List<LabelNode>) {
+        for (stateLabel in stateLabels) {
+            for (record in methodNode.localVariables) {
+                if (isFakeLocalVariableForInline(record.name) &&
+                    methodNode.instructions.indexOf(record.start) < methodNode.instructions.indexOf(stateLabel) &&
+                    methodNode.instructions.indexOf(stateLabel) < methodNode.instructions.indexOf(record.end)
+                ) {
+                    methodNode.instructions.insert(stateLabel, withInstructionAdapter {
+                        iconst(0)
+                        store(record.index, Type.INT_TYPE)
+                    })
+                }
+            }
+        }
+    }
+
     private fun addCompletionParameterToLVT(methodNode: MethodNode) {
         val index =
-                /*  all args */ Type.getMethodType(methodNode.desc).argumentTypes.fold(0) { a, b -> a + b.size } +
+            /*  all args */ Type.getMethodType(methodNode.desc).argumentTypes.fold(0) { a, b -> a + b.size } +
                 /* this */ (if (isStatic(methodNode.access)) 0 else 1) -
                 /* only last */ 1
         val startLabel = with(methodNode.instructions) {
@@ -210,6 +232,16 @@ class CoroutineTransformerMethodVisitor(
             if (last is LabelNode) last as LabelNode
             else LabelNode().also { insert(last, it) }
         }
+
+        // When compiling with the old backend against the bytecode generated by JVM IR, $completion may already be in LVT.
+        if (methodNode.localVariables.any {
+                it.name == SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME &&
+                        areLabelsBeforeSameInsn(startLabel, it.start) &&
+                        areLabelsBeforeSameInsn(endLabel, it.end)
+            }) {
+            return
+        }
+
         methodNode.localVariables.add(
             LocalVariableNode(
                 SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME,
@@ -311,31 +343,10 @@ class CoroutineTransformerMethodVisitor(
         }
     }
 
-    private fun fixLvtForParameters(methodNode: MethodNode, startLabel: LabelNode, endLabel: LabelNode) {
-        val paramsNum =
-                /* this */ (if (isStatic(methodNode.access)) 0 else 1) +
-                /* real params */ Type.getArgumentTypes(methodNode.desc).fold(0) { a, b -> a + b.size }
-
-        for (i in 0 until paramsNum) {
-            fixRangeOfLvtRecord(methodNode, i, startLabel, endLabel)
-        }
-    }
-
-    private fun fixRangeOfLvtRecord(methodNode: MethodNode, index: Int, startLabel: LabelNode, endLabel: LabelNode) {
-        val vars = methodNode.localVariables.filter { it.index == index }
-        assert(vars.size <= 1) {
-            "Someone else occupies parameter's slot at $index"
-        }
-        vars.firstOrNull()?.let {
-            it.start = startLabel
-            it.end = endLabel
-        }
-    }
-
     private fun writeDebugMetadata(
         methodNode: MethodNode,
         suspensionPointLineNumbers: List<LineNumberNode?>,
-        spilledToLocalMapping: List<List<SpilledVariableDescriptor>>
+        spilledToLocalMapping: List<List<SpilledVariableAndField>>
     ) {
         val lines = suspensionPointLineNumbers.map { it?.line ?: -1 }
         val metadata = classBuilderForCoroutineState.newAnnotation(DEBUG_METADATA_ANNOTATION_ASM_TYPE.descriptor, true)
@@ -590,7 +601,19 @@ class CoroutineTransformerMethodVisitor(
         }
     }
 
-    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableDescriptor>> {
+    private fun dropUnboxInlineClassMarkers(methodNode: MethodNode, suspensionPoints: List<SuspensionPoint>) {
+        for (marker in methodNode.instructions.asSequence().filter { isBeforeUnboxInlineClassMarker(it) }.toList()) {
+            methodNode.instructions.removeAll(listOf(marker.previous, marker))
+        }
+        for (marker in methodNode.instructions.asSequence().filter { isAfterUnboxInlineClassMarker(it) }.toList()) {
+            methodNode.instructions.removeAll(listOf(marker.previous.previous, marker.previous, marker))
+        }
+        for (suspension in suspensionPoints) {
+            methodNode.instructions.removeAll(suspension.unboxInlineClassInstructions)
+        }
+    }
+
+    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableAndField>> {
         val instructions = methodNode.instructions
         val frames =
             if (useOldSpilledVarTypeAnalysis) performRefinedTypeAnalysis(methodNode, containingClassInternalName)
@@ -598,11 +621,23 @@ class CoroutineTransformerMethodVisitor(
 
         fun AbstractInsnNode.index() = instructions.indexOf(this)
 
-        // We postpone these actions because they change instruction indices that we use when obtaining frames
-        val postponedActions = mutableListOf<() -> Unit>()
         val maxVarsCountByType = mutableMapOf<Type, Int>()
+        var initialSpilledVariablesCount = 0
+        for ((type, count) in initialVarsCountByType) {
+            if (type == AsmTypes.OBJECT_TYPE) {
+                initialSpilledVariablesCount = count
+            }
+            maxVarsCountByType[type] = count
+        }
+
         val livenessFrames = analyzeLiveness(methodNode)
-        val spilledToVariableMapping = arrayListOf<List<SpilledVariableDescriptor>>()
+
+        // References shall be cleaned up after uspill (during spill in next suspension point) to prevent memory leaks,
+        val referencesToSpillBySuspensionPointIndex = arrayListOf<List<ReferenceToSpill>>()
+        // while primitives shall not
+        val primitivesToSpillBySuspensionPointIndex = arrayListOf<List<PrimitiveToSpill>>()
+
+        // Collect information about spillable variables, that we use to determine which variables we need to cleanup
 
         for (suspension in suspensionPoints) {
             val suspensionCallBegin = suspension.suspensionCallBegin
@@ -629,7 +664,8 @@ class CoroutineTransformerMethodVisitor(
             // NB: it's also rather useful for sake of optimization
             val livenessFrame = livenessFrames[suspensionCallBegin.index()]
 
-            val spilledToVariable = arrayListOf<SpilledVariableDescriptor>()
+            val referencesToSpill = arrayListOf<ReferenceToSpill>()
+            val primitivesToSpill = arrayListOf<PrimitiveToSpill>()
 
             // 0 - this
             // 1 - parameter
@@ -637,77 +673,181 @@ class CoroutineTransformerMethodVisitor(
             // k - continuation
             // k + 1 - data
             // k + 2 - exception
-            val variablesToSpill =
-                (0 until localsCount)
-                    .filterNot { it in setOf(continuationIndex, dataIndex, exceptionIndex) }
-                    .map { Pair(it, frame.getLocal(it)) }
-                    .filter { (index, value) ->
-                        (index == 0 && needDispatchReceiver && isForNamedFunction) ||
-                                (value.type != null && livenessFrame.isAlive(index))
-                    }
+            for (slot in 0 until localsCount) {
+                if (slot == continuationIndex || slot == dataIndex || slot == exceptionIndex) continue
+                val value = frame.getLocal(slot)
+                if (value.type == null || !livenessFrame.isAlive(slot)) continue
 
-            for ((index, basicValue) in variablesToSpill) {
-                if (basicValue == StrictBasicValue.NULL_VALUE) {
-                    postponedActions.add {
-                        with(instructions) {
-                            insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                                aconst(null)
-                                store(index, AsmTypes.OBJECT_TYPE)
-                            })
-                        }
-                    }
+                if (value == StrictBasicValue.NULL_VALUE) {
+                    referencesToSpill += slot to null
                     continue
                 }
 
-                val type = basicValue.type!!
+                val type = value.type!!
                 val normalizedType = type.normalize()
 
                 val indexBySort = varsCountByType[normalizedType]?.plus(1) ?: 0
                 varsCountByType[normalizedType] = indexBySort
 
                 val fieldName = normalizedType.fieldNameForVar(indexBySort)
-                localVariableName(methodNode, index, suspension.suspensionCallEnd.next.index())
-                    ?.let { spilledToVariable.add(SpilledVariableDescriptor(fieldName, it)) }
-
-                postponedActions.add {
-                    with(instructions) {
-                        // store variable before suspension call
-                        insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
-                            load(continuationIndex, AsmTypes.OBJECT_TYPE)
-                            load(index, type)
-                            StackValue.coerce(type, normalizedType, this)
-                            putfield(classBuilderForCoroutineState.thisName, fieldName, normalizedType.descriptor)
-                        })
-
-                        // restore variable after suspension call
-                        insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                            load(continuationIndex, AsmTypes.OBJECT_TYPE)
-                            getfield(classBuilderForCoroutineState.thisName, fieldName, normalizedType.descriptor)
-                            StackValue.coerce(normalizedType, type, this)
-                            store(index, type)
-                        })
-                    }
+                if (normalizedType == AsmTypes.OBJECT_TYPE) {
+                    referencesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
+                } else {
+                    primitivesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
                 }
             }
 
-            spilledToVariableMapping.add(spilledToVariable)
+            referencesToSpillBySuspensionPointIndex += referencesToSpill
+            primitivesToSpillBySuspensionPointIndex += primitivesToSpill
 
-            varsCountByType.forEach {
-                maxVarsCountByType[it.key] = max(maxVarsCountByType[it.key] ?: 0, it.value)
+            for ((type, index) in varsCountByType) {
+                maxVarsCountByType[type] = max(maxVarsCountByType[type] ?: 0, index)
             }
         }
 
-        postponedActions.forEach(Function0<Unit>::invoke)
+        // Calculate variables to cleanup
 
-        maxVarsCountByType.forEach { entry ->
+        // Use CFG to calculate amount of spilled variables in previous suspension point (P) and current one (C).
+        // All fields from L$C to L$P should be cleaned. I.e. we should spill ACONST_NULL to them.
+        val cfg = ControlFlowGraph.build(methodNode)
+
+        // Collect all immediately preceding suspension points. I.e. suspension points, from which there is a path
+        // into current one, that does not cross other suspension points.
+        val suspensionPointEnds = suspensionPoints.associateBy { it.suspensionCallEnd }
+        fun findSuspensionPointPredecessors(suspension: SuspensionPoint): List<SuspensionPoint> {
+            val visited = mutableSetOf<AbstractInsnNode>()
+            fun dfs(current: AbstractInsnNode): List<SuspensionPoint> {
+                if (!visited.add(current)) return emptyList()
+                suspensionPointEnds[current]?.let { return listOf(it) }
+                return cfg.getPredecessorsIndices(current).flatMap { dfs(instructions[it]) }
+            }
+            return dfs(suspension.suspensionCallBegin)
+        }
+
+        val predSuspensionPoints = suspensionPoints.associateWith { findSuspensionPointPredecessors(it) }
+
+        // Calculate all pairs SuspensionPoint -> C and P, where P is minimum of all preds' Cs
+        fun countVariablesToSpill(index: Int): Int =
+            referencesToSpillBySuspensionPointIndex[index].count { (_, variable) -> variable != null }
+
+        val referencesToCleanBySuspensionPointIndex = arrayListOf<Pair<Int, Int>>() // current to pred
+        for (suspensionPointIndex in suspensionPoints.indices) {
+            val suspensionPoint = suspensionPoints[suspensionPointIndex]
+            val currentSpilledReferencesCount = countVariablesToSpill(suspensionPointIndex)
+            val preds = predSuspensionPoints[suspensionPoint]
+            val predSpilledReferencesCount =
+                if (preds.isNullOrEmpty()) initialSpilledVariablesCount
+                else preds.maxOf { countVariablesToSpill(suspensionPoints.indexOf(it)) }
+            referencesToCleanBySuspensionPointIndex += currentSpilledReferencesCount to predSpilledReferencesCount
+        }
+
+        // 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)
+                    })
+                }
+                return
+            }
+
+            with(instructions) {
+                // store variable before suspension call
+                insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
+                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                    load(slot, spillableVariable.type)
+                    StackValue.coerce(spillableVariable.type, spillableVariable.normalizedType, this)
+                    putfield(
+                        classBuilderForCoroutineState.thisName,
+                        spillableVariable.fieldName,
+                        spillableVariable.normalizedType.descriptor
+                    )
+                })
+
+                // restore variable after suspension call
+                insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                    getfield(
+                        classBuilderForCoroutineState.thisName,
+                        spillableVariable.fieldName,
+                        spillableVariable.normalizedType.descriptor
+                    )
+                    StackValue.coerce(spillableVariable.normalizedType, spillableVariable.type, this)
+                    store(slot, spillableVariable.type)
+                })
+            }
+        }
+
+        fun cleanUpField(suspension: SuspensionPoint, fieldIndex: Int) {
+            with(instructions) {
+                insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
+                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                    aconst(null)
+                    putfield(
+                        classBuilderForCoroutineState.thisName,
+                        "L\$$fieldIndex",
+                        AsmTypes.OBJECT_TYPE.descriptor
+                    )
+                })
+            }
+        }
+
+        for (suspensionPointIndex in suspensionPoints.indices) {
+            val suspension = suspensionPoints[suspensionPointIndex]
+            for ((slot, referenceToSpill) in referencesToSpillBySuspensionPointIndex[suspensionPointIndex]) {
+                generateSpillAndUnspill(suspension, slot, referenceToSpill)
+            }
+            val (currentSpilledCount, predSpilledCount) = referencesToCleanBySuspensionPointIndex[suspensionPointIndex]
+            if (predSpilledCount > currentSpilledCount) {
+                for (fieldIndex in currentSpilledCount until predSpilledCount) {
+                    cleanUpField(suspension, fieldIndex)
+                }
+            }
+            for ((slot, primitiveToSpill) in primitivesToSpillBySuspensionPointIndex[suspensionPointIndex]) {
+                generateSpillAndUnspill(suspension, slot, primitiveToSpill)
+            }
+        }
+
+        for (entry in maxVarsCountByType) {
             val (type, maxIndex) = entry
-            for (index in 0..maxIndex) {
+            for (index in (initialVarsCountByType[type]?.plus(1) ?: 0)..maxIndex) {
                 classBuilderForCoroutineState.newField(
                     JvmDeclarationOrigin.NO_ORIGIN, AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
                     type.fieldNameForVar(index), type.descriptor, null, null
                 )
             }
         }
+
+        // Calculate debug metadata mapping
+
+        fun calculateSpilledVariableAndField(
+            suspension: SuspensionPoint,
+            slot: Int,
+            spillableVariable: SpillableVariable?
+        ): SpilledVariableAndField? {
+            if (spillableVariable == null) return null
+            val name = localVariableName(methodNode, slot, suspension.suspensionCallEnd.next.index()) ?: return null
+            return SpilledVariableAndField(spillableVariable.fieldName, name)
+        }
+
+        val spilledToVariableMapping = arrayListOf<List<SpilledVariableAndField>>()
+        for (suspensionPointIndex in suspensionPoints.indices) {
+            val suspension = suspensionPoints[suspensionPointIndex]
+
+            val spilledToVariable = arrayListOf<SpilledVariableAndField>()
+
+            referencesToSpillBySuspensionPointIndex[suspensionPointIndex].mapNotNullTo(spilledToVariable) { (slot, spillableVariable) ->
+                calculateSpilledVariableAndField(suspension, slot, spillableVariable)
+            }
+            primitivesToSpillBySuspensionPointIndex[suspensionPointIndex].mapNotNullTo(spilledToVariable) { (slot, spillableVariable) ->
+                calculateSpilledVariableAndField(suspension, slot, spillableVariable)
+            }
+
+            spilledToVariableMapping += spilledToVariable
+        }
         return spilledToVariableMapping
     }
 
@@ -729,21 +869,21 @@ class CoroutineTransformerMethodVisitor(
     private val SuspensionPoint.tryCatchBlockEndLabelAfterSuspensionCall: LabelNode
         get() {
             assert(suspensionCallEnd.next is LabelNode) {
-                "Next instruction after ${this} should be a label, but " +
+                "Next instruction after $this should be a label, but " +
                         "${suspensionCallEnd.next::class.java}/${suspensionCallEnd.next.opcode} was found"
             }
 
             return suspensionCallEnd.next as LabelNode
         }
 
-    private fun transformCallAndReturnContinuationLabel(
+    private fun transformCallAndReturnStateLabel(
         id: Int,
         suspension: SuspensionPoint,
         methodNode: MethodNode,
         suspendMarkerVarIndex: Int,
         suspendPointLineNumber: LineNumberNode?
     ): LabelNode {
-        val continuationLabel = LabelNode().linkWithLabel()
+        val stateLabel = LabelNode().linkWithLabel()
         val continuationLabelAfterLoadedResult = LabelNode()
         val suspendElementLineNumber = lineNumber
         var nextLineNumberNode = nextDefinitelyHitLineNumber(suspension)
@@ -771,7 +911,7 @@ class CoroutineTransformerMethodVisitor(
                 load(suspendMarkerVarIndex, AsmTypes.OBJECT_TYPE)
                 areturn(AsmTypes.OBJECT_TYPE)
                 // Mark place for continuation
-                visitLabel(continuationLabel.label)
+                visitLabel(stateLabel.label)
             })
 
             // After suspension point there is always three nodes: L1, NOP, L2
@@ -792,6 +932,11 @@ class CoroutineTransformerMethodVisitor(
 
                 // Load continuation argument just like suspending function returns it
                 load(dataIndex, AsmTypes.OBJECT_TYPE)
+                // Unbox inline class, since this is the resume path and unlike the direct path
+                // the class is boxed.
+                for (insn in suspension.unboxInlineClassInstructions) {
+                    insn.accept(this)
+                }
 
                 visitLabel(continuationLabelAfterLoadedResult.label)
 
@@ -822,7 +967,7 @@ class CoroutineTransformerMethodVisitor(
             }
         }
 
-        return continuationLabel
+        return stateLabel
     }
 
     // Find the next line number instruction that is defintely hit. That is, a line number
@@ -830,9 +975,11 @@ class CoroutineTransformerMethodVisitor(
     private fun nextDefinitelyHitLineNumber(suspension: SuspensionPoint): LineNumberNode? {
         var next = suspension.suspensionCallEnd.next
         while (next != null) {
-            if (next.isBranchOrCall) return null
-            else if (next is LineNumberNode) return next
-            else next = next.next
+            when {
+                next.isBranchOrCall -> return null
+                next is LineNumberNode -> return next
+                else -> next = next.next
+            }
         }
         return next
     }
@@ -888,9 +1035,19 @@ class CoroutineTransformerMethodVisitor(
         return
     }
 
-    private data class SpilledVariableDescriptor(val fieldName: String, val variableName: String)
+    private data class SpilledVariableAndField(val fieldName: String, val variableName: String)
 }
 
+private class SpillableVariable(
+    val value: BasicValue,
+    val type: Type,
+    val normalizedType: Type,
+    val fieldName: String
+)
+
+private typealias ReferenceToSpill = Pair<Int, SpillableVariable?>
+private typealias PrimitiveToSpill = Pair<Int, SpillableVariable>
+
 internal fun InstructionAdapter.generateContinuationConstructorCall(
     objectTypeForState: Type?,
     methodNode: MethodNode,
@@ -956,7 +1113,7 @@ inline fun withInstructionAdapter(block: InstructionAdapter.() -> Unit): InsnLis
     return tmpMethodNode.instructions
 }
 
-private fun Type.normalize() =
+internal fun Type.normalize() =
     when (sort) {
         Type.ARRAY, Type.OBJECT -> AsmTypes.OBJECT_TYPE
         else -> this
@@ -979,6 +1136,16 @@ internal class SuspensionPoint(
 ) {
     lateinit var tryCatchBlocksContinuationLabel: LabelNode
 
+    val unboxInlineClassInstructions: List<AbstractInsnNode> = findUnboxInlineClassInstructions()
+
+    private fun findUnboxInlineClassInstructions(): List<AbstractInsnNode> {
+        val beforeMarker = suspensionCallEnd.next?.next ?: return emptyList()
+        if (!isBeforeUnboxInlineClassMarker(beforeMarker)) return emptyList()
+        val afterMarker = beforeMarker.findNextOrNull { isAfterUnboxInlineClassMarker(it) }
+            ?: error("Before unbox inline class marker without after unbox inline class marker")
+        return InsnSequence(beforeMarker.next, afterMarker.previous.previous).toList()
+    }
+
     operator fun contains(insn: AbstractInsnNode): Boolean {
         for (i in InsnSequence(suspensionCallBegin, suspensionCallEnd.next)) {
             if (i == insn) return true
@@ -1027,3 +1194,87 @@ internal fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, contin
         methodNode.instructions.set(fakeContinuation, VarInsnNode(Opcodes.ALOAD, continuationIndex))
     }
 }
+
+/* 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.
+ *
+ * This means, that function parameters do not longer span the whole function, including `this`.
+ * This might and will break some bytecode processors, including old versions of R8. See KT-24510.
+ */
+private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction: Boolean) {
+    val liveness = analyzeLiveness(method)
+
+    fun List<LocalVariableNode>.findRecord(insnIndex: Int, variableIndex: Int): LocalVariableNode? {
+        for (variable in this) {
+            if (variable.index == variableIndex &&
+                method.instructions.indexOf(variable.start) <= insnIndex &&
+                insnIndex < method.instructions.indexOf(variable.end)
+            ) return variable
+        }
+        return null
+    }
+
+    fun isAlive(insnIndex: Int, variableIndex: Int): Boolean =
+        liveness[insnIndex].isAlive(variableIndex)
+
+    val oldLvt = arrayListOf<LocalVariableNode>()
+    for (record in method.localVariables) {
+        oldLvt += record
+    }
+    method.localVariables.clear()
+    // Skip `this` for suspend lamdba
+    val start = if (isForNamedFunction) 0 else 1
+    for (variableIndex in start until method.maxLocals) {
+        if (oldLvt.none { it.index == variableIndex }) continue
+        var startLabel: LabelNode? = null
+        for (insnIndex in 0 until (method.instructions.size() - 1)) {
+            val insn = method.instructions[insnIndex]
+            if (!isAlive(insnIndex, variableIndex) && isAlive(insnIndex + 1, variableIndex)) {
+                startLabel = insn as? LabelNode ?: insn.findNextOrNull { it is LabelNode } as? LabelNode
+            }
+            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
+                val endLabel = insn as? LabelNode ?: insn.findNextOrNull { it is LabelNode } as? LabelNode ?: continue
+                // startLabel can be null in case of parameters
+                @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
+                var recordToExtend: LocalVariableNode? = null
+                for (record in method.localVariables) {
+                    if (record.name == lvtRecord.name &&
+                        record.desc == lvtRecord.desc &&
+                        record.signature == lvtRecord.signature &&
+                        record.index == lvtRecord.index
+                    ) {
+                        if (InsnSequence(record.end, startLabel).none { isBeforeSuspendMarker(it) }) {
+                            recordToExtend = record
+                            break
+                        }
+                    }
+                }
+                if (recordToExtend != null) {
+                    recordToExtend.end = endLabel
+                } else {
+                    method.localVariables.add(
+                        LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
+                    )
+                }
+            }
+        }
+    }
+
+    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
+        if (variable.name == CONTINUATION_VARIABLE_NAME ||
+            variable.name == SUSPEND_CALL_RESULT_NAME ||
+            isFakeLocalVariableForInline(variable.name)
+        ) {
+            method.localVariables.add(variable)
+        }
+        // this acts like $continuation for lambdas. For example, it is used by debugger to create async stack trace. Keep it.
+        if (variable.name == "this" && !isForNamedFunction) {
+            method.localVariables.add(variable)
+        }
+    }
+}

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

@@ -136,7 +136,11 @@ private class UnitSourceInterpreter(private val localVariables: Set<Int>) : Basi
 
     override fun merge(value1: BasicValue?, value2: BasicValue?): BasicValue? =
         if (value1 is UnitValue && value2 is UnitValue) {
-            UnitValue(value1.insns.union(value2.insns))
+            val newValue = UnitValue(value1.insns.union(value2.insns))
+            if (newValue.insns.any { it in unspillableUnitValues }) {
+                markUnspillable(newValue)
+            }
+            newValue
         } else {
             // Mark unit values as unspillable if we merge them with non-unit values here.
             // This is conservative since the value could turn out to be unused.

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

@@ -1,11 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.coroutines
-
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
-
-typealias SourceFrames = Array<Frame<SourceValue>?>

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/SourceFrames.kt.202

@@ -1,11 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.coroutines
-
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
-
-typealias SourceFrames = Array<Frame<SourceValue>>

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

@@ -26,7 +26,6 @@ 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
 
-// TODO Use this in variable liveness analysis
 internal class MethodNodeExaminer(
     val languageVersionSettings: LanguageVersionSettings,
     containingClassInternalName: String,

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

@@ -8,12 +8,13 @@ package org.jetbrains.kotlin.codegen.coroutines
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.COROUTINE_SUSPENDED_NAME
 import org.jetbrains.kotlin.backend.common.isBuiltInSuspendCoroutineUninterceptedOrReturn
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.isBuiltinFunctionalClassDescriptor
-import org.jetbrains.kotlin.builtins.isBuiltinFunctionalType
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.inline.addFakeContinuationMarker
 import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.coroutines.isSuspendLambda
 import org.jetbrains.kotlin.descriptors.*
@@ -41,6 +42,7 @@ import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.KotlinTypeFactory
 import org.jetbrains.kotlin.types.TypeConstructorSubstitution
 import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.org.objectweb.asm.Label
@@ -111,8 +113,8 @@ fun computeLabelOwner(languageVersionSettings: LanguageVersionSettings, thisName
     else
         languageVersionSettings.coroutinesJvmInternalPackageFqName().child(Name.identifier("CoroutineImpl")).topLevelClassAsmType()
 
-private val NORMALIZE_CONTINUATION_METHOD_NAME = "normalizeContinuation"
-private val GET_CONTEXT_METHOD_NAME = "getContext"
+private const val NORMALIZE_CONTINUATION_METHOD_NAME = "normalizeContinuation"
+private const val GET_CONTEXT_METHOD_NAME = "getContext"
 
 data class ResolvedCallWithRealDescriptor(val resolvedCall: ResolvedCall<*>, val fakeContinuationExpression: KtExpression)
 
@@ -140,11 +142,11 @@ fun ResolvedCall<*>.replaceSuspensionFunctionWithRealDescriptor(
     if (this is VariableAsFunctionResolvedCall) {
         val replacedFunctionCall =
             functionCall.replaceSuspensionFunctionWithRealDescriptor(project, bindingContext, isReleaseCoroutines)
-                    ?: return null
+                ?: return null
 
         @Suppress("UNCHECKED_CAST")
         return replacedFunctionCall.copy(
-            VariableAsFunctionResolvedCallImpl(
+            resolvedCall = VariableAsFunctionResolvedCallImpl(
                 replacedFunctionCall.resolvedCall as MutableResolvedCall<FunctionDescriptor>,
                 variableCall.asMutableResolvedCall(bindingContext)
             )
@@ -312,7 +314,7 @@ private fun FunctionDescriptor.getContinuationParameterTypeOfSuspendFunction(isR
 
 fun ModuleDescriptor.getResult(kotlinType: KotlinType) =
     module.resolveTopLevelClass(
-        DescriptorUtils.RESULT_FQ_NAME,
+        StandardNames.RESULT_FQ_NAME,
         NoLookupLocation.FROM_BACKEND
     )?.defaultType?.let {
         KotlinTypeFactory.simpleType(
@@ -413,7 +415,8 @@ fun createMethodNodeForSuspendCoroutineUninterceptedOrReturn(languageVersionSett
             load(1, OBJECT_TYPE) // continuation
             checkcast(languageVersionSettings.continuationAsmType())
             invokestatic(
-                languageVersionSettings.coroutinesJvmInternalPackageFqName().child(Name.identifier("DebugProbesKt")).topLevelClassAsmType().internalName,
+                languageVersionSettings.coroutinesJvmInternalPackageFqName().child(Name.identifier("DebugProbesKt"))
+                    .topLevelClassAsmType().internalName,
                 "probeCoroutineSuspended",
                 "(${languageVersionSettings.continuationAsmType()})V",
                 false
@@ -453,6 +456,32 @@ fun FunctionDescriptor.getOriginalSuspendFunctionView(bindingContext: BindingCon
 fun FunctionDescriptor.getOriginalSuspendFunctionView(bindingContext: BindingContext, state: GenerationState) =
     getOriginalSuspendFunctionView(bindingContext, state.languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines))
 
+// For each suspend function, we have a corresponding JVM view function that has an extra continuation parameter,
+// and, more importantly, returns 'kotlin.Any' (so that it can return as a reference value or a special COROUTINE_SUSPENDED object).
+// This also causes boxing of primitives and inline class values.
+// If we have a function returning an inline class value that is mapped to a reference type, we want to avoid boxing.
+// However, we have to do that consistently both on declaration site and on call site.
+fun FunctionDescriptor.originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(typeMapper: KotlinTypeMapper): KotlinType? {
+    if (!isSuspend) return null
+    // Suspend lambdas cannot return unboxed inline class
+    if (this is AnonymousFunctionDescriptor) return null
+    val originalDescriptor = unwrapInitialDescriptorForSuspendFunction().original
+    val originalReturnType = originalDescriptor.returnType ?: return null
+    if (!originalReturnType.isInlineClassType()) return null
+    // Force boxing for primitives
+    if (AsmUtil.isPrimitive(typeMapper.mapType(originalReturnType.makeNotNullable()))) return null
+    // Force boxing for nullable inline class types with nullable underlying type
+    if (originalReturnType.isMarkedNullable && originalReturnType.isNullableUnderlyingType()) return null
+    // Force boxing if the function overrides function with different type modulo nullability
+    if (originalDescriptor.overriddenDescriptors.any {
+            (it.original.returnType?.isMarkedNullable == true && it.original.returnType?.isNullableUnderlyingType() == true) ||
+                    // We do not care about type parameters, just main class type
+                    it.original.returnType?.constructor?.declarationDescriptor != originalReturnType.constructor.declarationDescriptor
+        }) return null
+    // Don't box other inline classes
+    return originalReturnType
+}
+
 fun InstructionAdapter.loadCoroutineSuspendedMarker(languageVersionSettings: LanguageVersionSettings) {
     invokestatic(
         languageVersionSettings.coroutinesIntrinsicsFileFacadeInternalName().internalName,
@@ -462,6 +491,15 @@ fun InstructionAdapter.loadCoroutineSuspendedMarker(languageVersionSettings: Lan
     )
 }
 
+fun InstructionAdapter.generateCoroutineSuspendedCheck(languageVersionSettings: LanguageVersionSettings) {
+    dup()
+    loadCoroutineSuspendedMarker(languageVersionSettings)
+    val elseLabel = Label()
+    ifacmpne(elseLabel)
+    areturn(OBJECT_TYPE)
+    mark(elseLabel)
+}
+
 fun InstructionAdapter.invokeDoResumeWithUnit(thisName: String) {
     // .doResume(Unit, null)
     StackValue.putUnitInstance(this)
@@ -494,14 +532,14 @@ fun Method.getImplForOpenMethod(ownerInternalName: String) =
 
 fun FunctionDescriptor.isSuspendLambdaOrLocalFunction() = this.isSuspend && when (this) {
     is AnonymousFunctionDescriptor -> this.isSuspendLambda
-    is SimpleFunctionDescriptor -> this.visibility == Visibilities.LOCAL
+    is SimpleFunctionDescriptor -> this.visibility == DescriptorVisibilities.LOCAL
     else -> false
 }
 
 fun FunctionDescriptor.isLocalSuspendFunctionNotSuspendLambda() = isSuspendLambdaOrLocalFunction() && this !is AnonymousFunctionDescriptor
 
 @JvmField
-val EXPERIMENTAL_CONTINUATION_ASM_TYPE = DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_EXPERIMENTAL.topLevelClassAsmType()
+val EXPERIMENTAL_CONTINUATION_ASM_TYPE = StandardNames.CONTINUATION_INTERFACE_FQ_NAME_EXPERIMENTAL.topLevelClassAsmType()
 
 @JvmField
-val RELEASE_CONTINUATION_ASM_TYPE = DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_RELEASE.topLevelClassAsmType()
+val RELEASE_CONTINUATION_ASM_TYPE = StandardNames.CONTINUATION_INTERFACE_FQ_NAME_RELEASE.topLevelClassAsmType()