No ResolveModulePerSourceSet

.bunch

@@ -1,8 +1,7 @@
-201
-202
-203_202
 193
-192_193
-as36_192_193
-as40_193
-as41
+201
+192
+191_192
+as35_191_192
+as36_192
+as40

.gitattributes

@@ -3,6 +3,5 @@
 * text=auto
 * eol=lf
 *.png binary
-*.jar binary
 compiler/cli/bin/* eol=lf
 compiler/cli/bin/*.bat eol=crlf

.gitignore

@@ -58,4 +58,5 @@ kotlin-ultimate/
 node_modules/
 .rpt2_cache/
 libraries/tools/kotlin-test-js-runner/lib/
+libraries/tools/kotlin-source-map-loader/lib/
 local.properties

.idea/dictionaries/4u7.xml

@@ -11,7 +11,6 @@
       <w>protobuf</w>
       <w>redirector</w>
       <w>remapper</w>
-      <w>sonatype</w>
       <w>unpresent</w>
     </words>
   </dictionary>

.idea/dictionaries/dmitriy_dolovov.xml

@@ -1,19 +1,12 @@
 <component name="ProjectDictionaryState">
   <dictionary name="dmitriy.dolovov">
     <words>
-      <w>cinterop</w>
-      <w>commonizable</w>
       <w>commonization</w>
       <w>commonize</w>
       <w>commonized</w>
       <w>commonizer</w>
       <w>commonizers</w>
-      <w>commonizes</w>
-      <w>commonizing</w>
-      <w>jetbrains</w>
       <w>konan</w>
-      <w>kotlinx</w>
-      <w>macos</w>
     </words>
   </dictionary>
 </component>

.idea/misc.xml

@@ -66,7 +66,7 @@
   <component name="ProjectResources">
     <default-html-doctype>http://www.w3.org/1999/xhtml</default-html-doctype>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
   <component name="PsiViewerSettings">

.idea/runConfigurations/Test__KMM.xml

@@ -1,20 +0,0 @@
-<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/runConfigurations/Test__stdlib_js_public_kotlin_api_test__overwrite_results.xml

@@ -1,22 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test: stdlib-js public kotlin api test, overwrite results" type="GradleRunConfiguration" factoryName="Gradle">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.js.test.ApiTest&quot; -Poverwrite.output=true --parallel" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value=":js:js.tests:cleanTest" />
-          <option value=":js:js.tests:test" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <GradleScriptDebugEnabled>false</GradleScriptDebugEnabled>
-    <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[group: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" />
 </component>

ReadMe.md

@@ -41,12 +41,7 @@ For local development, if you're not working on bytecode generation or the stand
 
 You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) to setup `JDK_*` variables.
 
-Note: The JDK 6 for MacOS is not available on Oracle's site. You can install it by
-
-```bash
-$ brew tap caskroom/versions
-$ brew cask install java6
-```
+> Note: The JDK 6 for MacOS is not available on Oracle's site. You can [download it here](https://support.apple.com/kb/DL1572).
 
 On Windows you might need to add long paths setting to the repo:
 
@@ -86,8 +81,6 @@ 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

@@ -40,7 +40,6 @@ repositories {
 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") }
@@ -74,7 +73,6 @@ benchmark {
             param("size", 1000)
 
             include("CommonCallsBenchmark")
-            include("ControlFlowAnalysisBenchmark")
             //include("InferenceBaselineCallsBenchmark")
         }
 
@@ -97,52 +95,3 @@ 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

@@ -13,6 +13,7 @@ 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
@@ -25,15 +26,21 @@ 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.createSession
-import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
+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.resolve.firProvider
-import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
 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
@@ -59,10 +66,10 @@ private val JDK_PATH = File("${System.getProperty("java.home")!!}/lib/rt.jar")
 private val RUNTIME_JAR = File(System.getProperty("kotlin.runtime.path") ?: "dist/kotlinc/lib/kotlin-runtime.jar")
 
 private val LANGUAGE_FEATURE_SETTINGS =
-    LanguageVersionSettingsImpl(
-        LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
-        specificFeatures = mapOf(LanguageFeature.NewInference to LanguageFeature.State.ENABLED)
-    )
+        LanguageVersionSettingsImpl(
+                LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
+                specificFeatures = mapOf(LanguageFeature.NewInference to LanguageFeature.State.ENABLED)
+        )
 
 private fun newConfiguration(useNewInference: Boolean): CompilerConfiguration {
     val configuration = CompilerConfiguration()
@@ -74,10 +81,10 @@ private fun newConfiguration(useNewInference: Boolean): CompilerConfiguration {
 
     val newInferenceState = if (useNewInference) LanguageFeature.State.ENABLED else LanguageFeature.State.DISABLED
     configuration.languageVersionSettings = LanguageVersionSettingsImpl(
-        LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
-        specificFeatures = mapOf(
-            LanguageFeature.NewInference to newInferenceState
-        )
+            LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
+            specificFeatures = mapOf(
+                    LanguageFeature.NewInference to newInferenceState
+            )
     )
     return configuration
 }
@@ -98,21 +105,21 @@ abstract class AbstractSimpleFileBenchmark {
     fun setUp() {
         if (isIR && !useNewInference) error("Invalid configuration")
         env = KotlinCoreEnvironment.createForTests(
-            myDisposable,
-            newConfiguration(useNewInference),
-            EnvironmentConfigFiles.JVM_CONFIG_FILES
+                myDisposable, 
+                newConfiguration(useNewInference),
+                EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
 
         if (isIR) {
             Extensions.getArea(env.project)
-                .getExtensionPoint(PsiElementFinder.EP_NAME)
-                .unregisterExtension(JavaElementFinder::class.java)
+                    .getExtensionPoint(PsiElementFinder.EP_NAME)
+                    .unregisterExtension(JavaElementFinder::class.java)
         }
 
         file = createFile(
-            "test.kt",
-            buildText(),
-            env.project
+                "test.kt",
+                buildText(),
+                env.project
         )
     }
 
@@ -127,22 +134,22 @@ abstract class AbstractSimpleFileBenchmark {
     private fun analyzeGreenFileFrontend(bh: Blackhole) {
         val tracker = ExceptionTracker()
         val storageManager: StorageManager =
-            LockBasedStorageManager.createWithExceptionHandling("benchmarks", tracker)
+                LockBasedStorageManager.createWithExceptionHandling("benchmarks", tracker)
 
         val context = SimpleGlobalContext(storageManager, tracker)
         val module =
-            ModuleDescriptorImpl(
-                Name.special("<benchmark>"), storageManager,
-                JvmBuiltIns(storageManager, JvmBuiltIns.Kind.FROM_DEPENDENCIES)
-            )
+                ModuleDescriptorImpl(
+                        Name.special("<benchmark>"), storageManager,
+                        JvmBuiltIns(storageManager, JvmBuiltIns.Kind.FROM_DEPENDENCIES)
+                )
         val moduleContext = context.withProject(env.project).withModule(module)
 
         val result = TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-            moduleContext.project,
-            listOf(file),
-            NoScopeRecordCliBindingTrace(),
-            env.configuration,
-            { scope -> JvmPackagePartProvider(LANGUAGE_FEATURE_SETTINGS, scope) }
+                moduleContext.project,
+                listOf(file),
+                NoScopeRecordCliBindingTrace(),
+                env.configuration,
+                { scope -> JvmPackagePartProvider(LANGUAGE_FEATURE_SETTINGS, scope) }
         )
 
         assert(result.bindingContext.diagnostics.none { it.severity == Severity.ERROR })
@@ -152,21 +159,56 @@ abstract class AbstractSimpleFileBenchmark {
 
     private fun analyzeGreenFileIr(bh: Blackhole) {
         val scope = GlobalSearchScope.filesScope(env.project, listOf(file.virtualFile))
-            .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
+                .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = createSession(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
-        val totalTransformer = FirTotalResolveProcessor(session)
+        val totalTransformer = FirTotalResolveTransformer()
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)
 
-        totalTransformer.process(listOf(firFile))
+        for (transformer in totalTransformer.transformers) {
+            transformer.transformFile(firFile, null)
+        }
 
         bh.consume(firFile.hashCode())
-        Extensions.getArea(env.project)
-            .getExtensionPoint(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(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

@@ -1,35 +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.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("}")
-        }
-}

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

@@ -23,28 +23,28 @@ open class ManyImplicitReceiversBenchmark : AbstractSimpleFileBenchmark() {
 
     override fun buildText(): String {
         return buildString {
-            appendLine("inline fun <T, R> with(receiver: T, block: T.() -> R): R = block()")
+            appendln("inline fun <T, R> with(receiver: T, block: T.() -> R): R = block()")
 
             for (i in 1..size) {
-                appendLine("interface A$i {")
-                appendLine("    fun foo$i()")
-                appendLine("}")
-                appendLine()
+                appendln("interface A$i {")
+                appendln("    fun foo$i()")
+                appendln("}")
+                appendln()
             }
-            appendLine()
+            appendln()
             append("fun test(")
             append((1..size).joinToString(", ") { "a$it: A$it" })
-            appendLine(" {")
+            appendln(" {")
             for (i in 1..size) {
-                appendLine("with(a$i) {")
+                appendln("with(a$i) {")
             }
             for (i in 1..size) {
-                appendLine("foo$i()")
+                appendln("foo$i()")
             }
             for (i in 1..size) {
-                appendLine("}")
+                appendln("}")
             }
-            appendLine("}")
+            appendln("}")
         }
     }
 }

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

@@ -22,7 +22,7 @@ open class PlusAssignOperatorDesugaringBenchmark : AbstractInferenceBenchmark()
     }
 
     override fun buildText(): String = buildString {
-        appendLine(
+        appendln(
             """
             class A {
                 operator fun <T : Number> plus(other: (Int) -> T): A = this
@@ -30,20 +30,19 @@ open class PlusAssignOperatorDesugaringBenchmark : AbstractInferenceBenchmark()
             }
         """.trimIndent()
         )
-        appendLine("fun test() {")
-        appendLine("var a = A()")
+        appendln("fun test() {")
+        appendln("var a = A()")
         for (i in 1..size) {
-            appendLine("a += {")
+            appendln("a += {")
         }
         for (i in 1..size) {
-            appendLine(
+            appendln(
                 """
                 it.inc()
                 1
                 }
-            """.trimIndent()
-            )
+            """.trimIndent())
         }
-        appendLine()
+        appendln()
     }
 }

build-common/src/org/jetbrains/kotlin/compilerRunner/MessageCollectorToOutputItemsCollectorAdapter.kt

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.compilerRunner
 
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
@@ -25,7 +25,7 @@ class MessageCollectorToOutputItemsCollectorAdapter(
         private val delegate: MessageCollector,
         private val outputCollector: OutputItemsCollector
 ) : MessageCollector by delegate {
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
         // TODO: consider adding some other way of passing input -> output mapping from compiler, e.g. dedicated service
         OutputMessageUtil.parseOutputMessage(message)?.let {
             outputCollector.add(it.sourceFiles, it.outputFile)

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

@@ -1,6 +1,17 @@
 /*
- * 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.
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 package org.jetbrains.kotlin.incremental

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.EnumeratorStringDescriptor
+import com.intellij.util.io.KeyDescriptor
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.utils.Printer
+import java.io.File
+
+abstract class BasicMap<K : Comparable<K>, V>(
+        internal val storageFile: File,
+        keyDescriptor: KeyDescriptor<K>,
+        valueExternalizer: DataExternalizer<V>
+) {
+    protected val storage = LazyStorage(storageFile, keyDescriptor, valueExternalizer)
+
+    fun clean() {
+        storage.clean()
+    }
+
+    fun flush(memoryCachesOnly: Boolean) {
+        storage.flush(memoryCachesOnly)
+    }
+
+    fun close() {
+        storage.close()
+    }
+
+    @TestOnly
+    fun dump(): String {
+        return with(StringBuilder()) {
+            with(Printer(this)) {
+                println(this@BasicMap::class.java.simpleName)
+                pushIndent()
+
+                for (key in storage.keys.sorted()) {
+                    println("${dumpKey(key)} -> ${dumpValue(storage[key]!!)}")
+                }
+
+                popIndent()
+            }
+
+            this
+        }.toString()
+    }
+
+    @TestOnly
+    protected abstract fun dumpKey(key: K): String
+
+    @TestOnly
+    protected abstract fun dumpValue(value: V): String
+}
+
+abstract class BasicStringMap<V>(
+        storageFile: File,
+        keyDescriptor: KeyDescriptor<String>,
+        valueExternalizer: DataExternalizer<V>
+) : BasicMap<String, V>(storageFile, keyDescriptor, valueExternalizer) {
+    constructor(
+            storageFile: File,
+            valueExternalizer: DataExternalizer<V>
+    ) : this(storageFile, EnumeratorStringDescriptor.INSTANCE, valueExternalizer)
+
+    override fun dumpKey(key: String): String = key
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import org.jetbrains.kotlin.incremental.dumpCollection
+import org.jetbrains.kotlin.name.FqName
+import java.io.File
+
+internal open class ClassOneToManyMap(
+        storageFile: File
+) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
+    override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
+
+    fun add(key: FqName, value: FqName) {
+        storage.append(key.asString(), value.asString())
+    }
+
+    operator fun get(key: FqName): Collection<FqName> =
+            storage[key.asString()]?.map(::FqName) ?: setOf()
+
+    operator fun set(key: FqName, values: Collection<FqName>) {
+        if (values.isEmpty()) {
+            remove(key)
+            return
+        }
+
+        storage[key.asString()] = values.map(FqName::asString)
+    }
+
+    fun remove(key: FqName) {
+        storage.remove(key.asString())
+    }
+
+    fun removeValues(key: FqName, removed: Set<FqName>) {
+        val notRemoved = this[key].filter { it !in removed }
+        this[key] = notRemoved
+    }
+}
+
+internal class SubtypesMap(storageFile: File) : ClassOneToManyMap(storageFile)
+internal class SupertypesMap(storageFile: File) : ClassOneToManyMap(storageFile)

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.IOUtil
+import com.intellij.util.io.KeyDescriptor
+import com.intellij.util.io.PersistentHashMap
+import java.io.DataOutput
+import java.io.File
+import java.io.IOException
+
+
+/**
+ * It's lazy in a sense that PersistentHashMap is created only on write
+ */
+class LazyStorage<K, V>(
+        private val storageFile: File,
+        private val keyDescriptor: KeyDescriptor<K>,
+        private val valueExternalizer: DataExternalizer<V>
+) {
+    @Volatile
+    private var storage: PersistentHashMap<K, V>? = null
+
+    @Synchronized
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+        if (storage != null) return storage
+
+        if (storageFile.exists()) {
+            storage = createMap()
+            return storage
+        }
+
+        return null
+    }
+
+    @Synchronized
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+        if (storage == null) {
+            storage = createMap()
+        }
+
+        return storage!!
+    }
+
+    val keys: Collection<K>
+        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
+
+    operator fun contains(key: K): Boolean =
+            getStorageIfExists()?.containsMapping(key) ?: false
+
+    operator fun get(key: K): V? =
+            getStorageIfExists()?.get(key)
+
+    operator fun set(key: K, value: V) {
+        getStorageOrCreateNew().put(key, value)
+    }
+
+    fun remove(key: K) {
+        getStorageIfExists()?.remove(key)
+    }
+
+    fun append(key: K, value: String) {
+        append(key) { out -> IOUtil.writeUTF(out, value) }
+    }
+
+    fun append(key: K, value: Int) {
+        append(key) { out -> out.writeInt(value) }
+    }
+
+    @Synchronized
+    fun clean() {
+        try {
+            storage?.close()
+        }
+        catch (ignored: Throwable) {
+        }
+
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        storage = null
+    }
+
+    @Synchronized
+    fun flush(memoryCachesOnly: Boolean) {
+        val existingStorage = storage ?: return
+
+        if (memoryCachesOnly) {
+            if (existingStorage.isDirty) {
+                existingStorage.dropMemoryCaches()
+            }
+        }
+        else {
+            existingStorage.force()
+        }
+    }
+
+    @Synchronized
+    fun close() {
+        storage?.close()
+    }
+
+    private fun createMap(): PersistentHashMap<K, V> =
+            PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+
+    private fun append(key: K, append: (DataOutput)->Unit) {
+        getStorageOrCreateNew().appendData(key, append)
+    }
+}

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import java.io.File
+
+internal class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<Int>>(storage, LookupSymbolKeyDescriptor, IntCollectionExternalizer) {
+    override fun dumpKey(key: LookupSymbolKey): String = key.toString()
+
+    override fun dumpValue(value: Collection<Int>): String = value.toString()
+
+    fun add(name: String, scope: String, fileId: Int) {
+        storage.append(LookupSymbolKey(name, scope), fileId)
+    }
+
+    operator fun get(key: LookupSymbolKey): Collection<Int>? = storage[key]
+
+    operator fun set(key: LookupSymbolKey, fileIds: Set<Int>) {
+        storage[key] = fileIds
+    }
+
+    fun remove(key: LookupSymbolKey) {
+        storage.remove(key)
+    }
+
+    val keys: Collection<LookupSymbolKey>
+        get() = storage.keys
+}

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.PersistentHashMap
+import com.intellij.util.io.JpsPersistentHashMap
 import java.io.File
 
 
@@ -28,10 +28,10 @@ class NonCachingLazyStorage<K, V>(
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
     @Volatile
-    private var storage: PersistentHashMap<K, V>? = null
+    private var storage: JpsPersistentHashMap<K, V>? = null
 
     @Synchronized
-    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+    private fun getStorageIfExists(): JpsPersistentHashMap<K, V>? {
         if (storage != null) return storage
 
         if (storageFile.exists()) {
@@ -43,7 +43,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     @Synchronized
-    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+    private fun getStorageOrCreateNew(): JpsPersistentHashMap<K, V> {
         if (storage == null) {
             storage = createMap()
         }
@@ -69,7 +69,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     override fun append(key: K, value: V) {
-        getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
+        getStorageOrCreateNew().appendDataWithoutCache(key, value)
     }
 
     @Synchronized
@@ -79,7 +79,7 @@ class NonCachingLazyStorage<K, V>(
         } catch (ignored: Throwable) {
         }
 
-        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        JpsPersistentHashMap.deleteFilesStartingWith(storageFile)
         storage = null
     }
 
@@ -101,6 +101,6 @@ class NonCachingLazyStorage<K, V>(
         storage?.close()
     }
 
-    private fun createMap(): PersistentHashMap<K, V> =
-        PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+    private fun createMap(): JpsPersistentHashMap<K, V> =
+        JpsPersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
 }

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

@@ -1,106 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.incremental.storage
-
-import com.intellij.util.io.DataExternalizer
-import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.JpsPersistentHashMap
-import java.io.File
-
-
-class NonCachingLazyStorage<K, V>(
-    private val storageFile: File,
-    private val keyDescriptor: KeyDescriptor<K>,
-    private val valueExternalizer: DataExternalizer<V>
-) : LazyStorage<K, V> {
-    @Volatile
-    private var storage: JpsPersistentHashMap<K, V>? = null
-
-    @Synchronized
-    private fun getStorageIfExists(): JpsPersistentHashMap<K, V>? {
-        if (storage != null) return storage
-
-        if (storageFile.exists()) {
-            storage = createMap()
-            return storage
-        }
-
-        return null
-    }
-
-    @Synchronized
-    private fun getStorageOrCreateNew(): JpsPersistentHashMap<K, V> {
-        if (storage == null) {
-            storage = createMap()
-        }
-
-        return storage!!
-    }
-
-    override val keys: Collection<K>
-        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
-
-    override operator fun contains(key: K): Boolean =
-        getStorageIfExists()?.containsMapping(key) ?: false
-
-    override operator fun get(key: K): V? =
-        getStorageIfExists()?.get(key)
-
-    override operator fun set(key: K, value: V) {
-        getStorageOrCreateNew().put(key, value)
-    }
-
-    override fun remove(key: K) {
-        getStorageIfExists()?.remove(key)
-    }
-
-    override fun append(key: K, value: V) {
-        getStorageOrCreateNew().appendDataWithoutCache(key, value)
-    }
-
-    @Synchronized
-    override fun clean() {
-        try {
-            storage?.close()
-        } catch (ignored: Throwable) {
-        }
-
-        JpsPersistentHashMap.deleteFilesStartingWith(storageFile)
-        storage = null
-    }
-
-    @Synchronized
-    override fun flush(memoryCachesOnly: Boolean) {
-        val existingStorage = storage ?: return
-
-        if (memoryCachesOnly) {
-            if (existingStorage.isDirty) {
-                existingStorage.dropMemoryCaches()
-            }
-        } else {
-            existingStorage.force()
-        }
-    }
-
-    @Synchronized
-    override fun close() {
-        storage?.close()
-    }
-
-    private fun createMap(): JpsPersistentHashMap<K, V> =
-        JpsPersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
-}

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.KeyDescriptor
+import com.intellij.util.io.PersistentHashMap
+import java.io.File
+
+
+class NonCachingLazyStorage<K, V>(
+    private val storageFile: File,
+    private val keyDescriptor: KeyDescriptor<K>,
+    private val valueExternalizer: DataExternalizer<V>
+) : LazyStorage<K, V> {
+    @Volatile
+    private var storage: PersistentHashMap<K, V>? = null
+
+    @Synchronized
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+        if (storage != null) return storage
+
+        if (storageFile.exists()) {
+            storage = createMap()
+            return storage
+        }
+
+        return null
+    }
+
+    @Synchronized
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+        if (storage == null) {
+            storage = createMap()
+        }
+
+        return storage!!
+    }
+
+    override val keys: Collection<K>
+        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
+
+    override operator fun contains(key: K): Boolean =
+        getStorageIfExists()?.containsMapping(key) ?: false
+
+    override operator fun get(key: K): V? =
+        getStorageIfExists()?.get(key)
+
+    override operator fun set(key: K, value: V) {
+        getStorageOrCreateNew().put(key, value)
+    }
+
+    override fun remove(key: K) {
+        getStorageIfExists()?.remove(key)
+    }
+
+    override fun append(key: K, value: V) {
+        getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
+    }
+
+    @Synchronized
+    override fun clean() {
+        try {
+            storage?.close()
+        } catch (ignored: Throwable) {
+        }
+
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        storage = null
+    }
+
+    @Synchronized
+    override fun flush(memoryCachesOnly: Boolean) {
+        val existingStorage = storage ?: return
+
+        if (memoryCachesOnly) {
+            if (existingStorage.isDirty) {
+                existingStorage.dropMemoryCaches()
+            }
+        } else {
+            existingStorage.force()
+        }
+    }
+
+    @Synchronized
+    override fun close() {
+        storage?.close()
+    }
+
+    private fun createMap(): PersistentHashMap<K, V> =
+        PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+}

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import org.jetbrains.kotlin.incremental.dumpCollection
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import java.io.File
+
+internal class SourceToJvmNameMap(
+    storageFile: File,
+    pathConverter: FileToPathConverter
+) : AbstractSourceToOutputMap<JvmClassName>(JvmClassNameTransformer, storageFile, pathConverter)
+
+internal class SourceToFqNameMap(
+    storageFile: File,
+    pathConverter: FileToPathConverter
+) : AbstractSourceToOutputMap<FqName>(FqNameTransformer, storageFile, pathConverter)
+
+internal abstract class AbstractSourceToOutputMap<Name>(
+    private val nameTransformer: NameTransformer<Name>,
+    storageFile: File,
+    private val pathConverter: FileToPathConverter
+) : BasicStringMap<Collection<String>>(storageFile, PathStringDescriptor, StringCollectionExternalizer) {
+    fun clearOutputsForSource(sourceFile: File) {
+        remove(pathConverter.toPath(sourceFile))
+    }
+
+    fun add(sourceFile: File, className: Name) {
+        storage.append(pathConverter.toPath(sourceFile), nameTransformer.asString(className))
+    }
+
+    fun contains(sourceFile: File): Boolean =
+        pathConverter.toPath(sourceFile) in storage
+
+    operator fun get(sourceFile: File): Collection<Name> =
+        storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asName)
+
+    fun getFqNames(sourceFile: File): Collection<FqName> =
+        storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asFqName)
+
+    override fun dumpValue(value: Collection<String>) =
+        value.dumpCollection()
+
+    private fun remove(path: String) {
+        storage.remove(path)
+    }
+}

build.gradle.kts

@@ -1,5 +1,4 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import org.gradle.crypto.checksum.Checksum
 import org.gradle.plugins.ide.idea.model.IdeaModel
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import proguard.gradle.ProGuardTask
@@ -27,7 +26,8 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
+        classpath("com.gradle.publish:plugin-publish-plugin:0.11.0")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
     }
@@ -42,8 +42,6 @@ plugins {
     idea
     id("jps-compatible")
     id("org.jetbrains.gradle.plugin.idea-ext")
-    id("org.gradle.crypto.checksum") version "1.2.0"
-    signing
 }
 
 pill {
@@ -152,7 +150,6 @@ rootProject.apply {
     from(rootProject.file("gradle/jps.gradle.kts"))
     from(rootProject.file("gradle/checkArtifacts.gradle.kts"))
     from(rootProject.file("gradle/checkCacheability.gradle.kts"))
-    from(rootProject.file("gradle/retryPublishing.gradle.kts"))
 }
 
 IdeVersionConfigurator.setCurrentIde(project)
@@ -166,7 +163,7 @@ extra["versions.junit"] = "4.12"
 extra["versions.javaslang"] = "2.0.6"
 extra["versions.ant"] = "1.8.2"
 extra["versions.android"] = "2.3.1"
-val coroutinesVersion = if (Platform[192].orHigher()) "1.3.7" else "1.1.1"
+val coroutinesVersion = if (Platform[192].orHigher()) "1.2.1" else "1.1.1"
 extra["versions.kotlinx-coroutines-core"] = coroutinesVersion
 extra["versions.kotlinx-coroutines-jdk8"] = coroutinesVersion
 extra["versions.json"] = "20160807"
@@ -178,7 +175,7 @@ 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"] = "2.0.88"
+extra["versions.r8"] = "1.5.70"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -187,13 +184,12 @@ 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-M3-dev-15453"
 }
 
 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
 
@@ -201,10 +197,7 @@ extra["intellijSeparateSdks"] = intellijSeparateSdks
 
 extra["IntellijCoreDependencies"] =
     listOf(
-        when {
-            Platform[202].orHigher() -> "asm-all-8.0.1"
-            else -> "asm-all-7.0.1"
-        },
+        if (Platform[191].orHigher()) "asm-all-7.0.1" else "asm-all",
         "guava",
         "jdom",
         "jna",
@@ -229,8 +222,6 @@ 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",
@@ -239,7 +230,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:ir.serialization.common",
     ":compiler:ir.serialization.js",
     ":compiler:ir.serialization.jvm",
-    ":compiler:ir.interpreter",
     ":kotlin-util-io",
     ":kotlin-util-klib",
     ":kotlin-util-klib-metadata",
@@ -286,32 +276,11 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:analysis-tests"
 )
 
-extra["compilerModulesForJps"] = listOf(
-    ":core:type-system",
-    ":kotlin-build-common",
-    ":kotlin-util-io",
-    ":kotlin-util-klib",
-    ":kotlin-util-klib-metadata",
-    ":compiler:cli-common",
-    ":kotlin-compiler-runner",
-    ":daemon-common",
-    ":daemon-common-new",
-    ":core:descriptors",
-    ":core:descriptors.jvm",
-    ":idea:idea-jps-common",
-    ":kotlin-preloader",
-    ":compiler:util",
-    ":compiler:config",
-    ":compiler:config.jvm",
-    ":js:js.config",
-    ":core:util.runtime",
-    ":compiler:compiler.version"
-)
-
 val coreLibProjects = listOfNotNull(
     ":kotlin-stdlib",
     ":kotlin-stdlib-common",
     ":kotlin-stdlib-js",
+    ":kotlin-stdlib-js-ir",
     ":kotlin-stdlib-jdk7",
     ":kotlin-stdlib-jdk8",
     ":kotlin-test:kotlin-test-annotations-common",
@@ -321,16 +290,21 @@ val coreLibProjects = listOfNotNull(
     ":kotlin-test:kotlin-test-junit5",
     ":kotlin-test:kotlin-test-testng",
     ":kotlin-test:kotlin-test-js".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
+    ":kotlin-test:kotlin-test-js-ir".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
     ":kotlin-reflect",
     ":kotlin-coroutines-experimental-compat"
 )
 
 val gradlePluginProjects = listOf(
     ":kotlin-gradle-plugin",
+    ":kotlin-gradle-plugin:plugin-marker",
     ":kotlin-gradle-plugin-api",
+//        ":kotlin-gradle-plugin-integration-tests",  // TODO: build fails
     ":kotlin-allopen",
+    ":kotlin-allopen:plugin-marker",
     ":kotlin-annotation-processing-gradle",
     ":kotlin-noarg",
+    ":kotlin-noarg:plugin-marker",
     ":kotlin-sam-with-receiver"
 )
 
@@ -360,23 +334,7 @@ val ignoreTestFailures by extra(project.kotlinBuildProperties.ignoreTestFailures
 
 allprojects {
 
-    configurations.maybeCreate("embedded").apply {
-        isCanBeConsumed = false
-        isCanBeResolved = true
-        attributes {
-            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
-            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
-        }
-    }
-
-    configurations.maybeCreate("embeddedElements").apply {
-        extendsFrom(configurations["embedded"])
-        isCanBeConsumed = true
-        isCanBeResolved = false
-        attributes {
-            attribute(Usage.USAGE_ATTRIBUTE, objects.named("embedded-java-runtime"))
-        }
-    }
+    configurations.maybeCreate("embedded")
 
     jvmTarget = defaultJvmTarget
     javaHome = defaultJavaHome
@@ -408,6 +366,9 @@ 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,20 +380,9 @@ 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 + jvmCompilerArgs
-
-            if (useJvmIrBackend) {
-                useIR = true
-            }
+            freeCompilerArgs = commonCompilerArgs + listOf("-Xnormalize-constructor-calls=enable")
         }
     }
 
@@ -457,22 +407,11 @@ allprojects {
         outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KT-37089") { true }
     }
 
-    tasks.withType<SourceTask>().configureEach {
-        doFirst {
-            source.visit {
-                if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
-                    logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
-                }
-            }
-        }
-    }
-
     normalization {
         runtimeClasspath {
             ignore("META-INF/MANIFEST.MF")
             ignore("META-INF/compiler.version")
             ignore("META-INF/plugin.xml")
-            ignore("kotlin/KotlinVersionCurrentValue.class")
         }
     }
 
@@ -529,12 +468,9 @@ gradle.taskGraph.whenReady {
     fun Boolean.toOnOff(): String = if (this) "on" else "off"
     val profile = if (isTeamcityBuild) "CI" else "Local"
 
-    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")
+    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")
 
     allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
         task.entryCompression = if (kotlinBuildProperties.jarCompression)
@@ -548,10 +484,6 @@ val dist = tasks.register("dist") {
     dependsOn(":kotlin-compiler:dist")
 }
 
-val syncMutedTests = tasks.register("syncMutedTests") {
-    dependsOn(":compiler:tests-mutes:run")
-}
-
 val copyCompilerToIdeaPlugin by task<Copy> {
     dependsOn(dist)
     into(ideaPluginDir)
@@ -577,7 +509,7 @@ tasks {
         }
     }
 
-    listOf("clean", "assemble", "install").forEach { taskName ->
+    listOf("clean", "assemble", "install", "dist").forEach { taskName ->
         register("coreLibs${taskName.capitalize()}") {
             coreLibProjects.forEach { projectName -> dependsOn("$projectName:$taskName") }
         }
@@ -586,8 +518,6 @@ tasks {
     register("coreLibsTest") {
         (coreLibProjects + listOf(
             ":kotlin-stdlib:samples",
-            ":kotlin-stdlib-js-ir",
-            ":kotlin-test:kotlin-test-js-ir".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlin-test:kotlin-test-js:kotlin-test-js-it".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlinx-metadata-jvm",
             ":tools:binary-compatibility-validator"
@@ -653,6 +583,7 @@ tasks {
             ":compiler:fir:raw-fir:light-tree2fir:test",
             ":compiler:fir:analysis-tests:test",
             ":compiler:fir:fir2ir:test",
+            ":idea:idea-fir:test",
             ":plugins:fir:fir-plugin-prototype:test"
         )
     }
@@ -664,7 +595,7 @@ tasks {
     register("scriptingTest") {
         dependsOn("dist")
         dependsOn(":kotlin-script-util:test")
-        dependsOn(":kotlin-scripting-compiler-embeddable:test")
+        dependsOn(":kotlin-scripting-compiler:test")
         dependsOn(":kotlin-scripting-common:test")
         dependsOn(":kotlin-scripting-jvm:test")
         dependsOn(":kotlin-scripting-jvm-host-test:test")
@@ -676,17 +607,12 @@ tasks {
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
         dependsOn(":kotlin-scripting-ide-services-test:test")
-        dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
         dependsOn(":kotlin-scripting-js-test:test")
     }
 
     register("compilerTest") {
         dependsOn("jvmCompilerTest")
         dependsOn("jsCompilerTest")
-        dependsOn("miscCompilerTest")
-    }
-
-    register("miscCompilerTest") {
         dependsOn("wasmCompilerTest")
         dependsOn("nativeCompilerTest")
         dependsOn("firCompilerTest")
@@ -733,9 +659,16 @@ 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",
@@ -743,7 +676,8 @@ tasks {
             ":idea:jvm-debugger:jvm-debugger-evaluation:test",
             ":idea:jvm-debugger:jvm-debugger-sequence:test",
             ":idea:jvm-debugger:eval4j:test",
-            ":idea:scripting-support:test"
+            ":idea:scripting-support:test",
+            ":idea:idea-fir:test"
         )
     }
 
@@ -758,6 +692,17 @@ 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(
@@ -774,21 +719,10 @@ tasks {
         )
     }
 
-    register("ideaPluginTest") {
-        dependsOn(
-            "mainIdeTests",
-            "gradleIdeTest",
-            "kaptIdeTest",
-            "miscIdeTests"
-        )
-    }
-
-    register("mainIdeTests") {
-        dependsOn(":idea:test")
-    }
-
-    register("miscIdeTests") {
+    register("plugins-tests") {
+        dependsOn("dist")
         dependsOn(
+            ":kotlin-annotation-processing:test",
             ":kotlin-allopen-compiler-plugin:test",
             ":kotlin-noarg-compiler-plugin:test",
             ":kotlin-sam-with-receiver-compiler-plugin:test",
@@ -796,41 +730,21 @@ tasks {
             ":kotlin-annotation-processing-gradle:test",
             ":kotlinx-serialization-compiler-plugin:test",
             ":kotlinx-serialization-ide-plugin:test",
-            ":idea:jvm-debugger:jvm-debugger-test:test",
-            "idea-plugin-additional-tests",
+            ":idea:jvm-debugger:jvm-debugger-test:test"
+        )
+    }
+
+
+    register("ideaPluginTest") {
+        dependsOn(
+            "idea-plugin-tests",
             "jps-tests",
+            "plugins-tests",
+            "android-ide-tests",
             ":generators:test"
         )
-        if (Ide.IJ()) {
-            dependsOn("idea-new-project-wizard-tests")
-        }
     }
 
-    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") {
         doLast {
@@ -849,40 +763,6 @@ 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",
-                ":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() {
@@ -892,15 +772,15 @@ fun CopySpec.setExecutablePermissions() {
 
 val zipCompiler by task<Zip> {
     dependsOn(dist)
-    destinationDirectory.set(file(distDir))
-    archiveFileName.set("kotlin-compiler-$kotlinVersion.zip")
+    destinationDir = file(distDir)
+    archiveName = "kotlin-compiler-$kotlinVersion.zip"
 
     from(distKotlinHomeDir)
     into("kotlinc")
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Compiler artifacts packed to ${archiveFile.get().asFile.absolutePath}")
+        logger.lifecycle("Compiler artifacts packed to $archivePath")
     }
 }
 
@@ -950,33 +830,6 @@ val zipPlugin by task<Zip> {
     }
 }
 
-fun Project.secureZipTask(zipTask: TaskProvider<Zip>): RegisteringDomainObjectDelegateProviderWithAction<out TaskContainer, Task> {
-    val checkSumTask = tasks.register("${zipTask.name}Checksum", Checksum::class) {
-        dependsOn(zipTask)
-        val compilerFile = zipTask.get().outputs.files.singleFile
-        files = files(compilerFile)
-        outputDir = compilerFile.parentFile
-        algorithm = Checksum.Algorithm.SHA256
-    }
-
-    val signTask = tasks.register("${zipTask.name}Sign", Sign::class) {
-        description = "Signs the archive produced by the '" + zipTask.name + "' task."
-        sign(zipTask.get())
-    }
-
-    return tasks.registering {
-        dependsOn(checkSumTask)
-        dependsOn(signTask)
-    }
-}
-
-signing {
-    useGpgCmd()
-}
-
-val zipCompilerWithSignature by secureZipTask(zipCompiler)
-val zipPluginWithSignature by secureZipTask(zipPlugin)
-
 configure<IdeaModel> {
     module {
         excludeDirs = files(
@@ -1104,15 +957,3 @@ val Jar.outputFile: File
 
 val Project.sourceSetsOrNull: SourceSetContainer?
     get() = convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets
-
-val disableVerificationTasks = System.getProperty("disable.verification.tasks") == "true"
-if (disableVerificationTasks) {
-    gradle.taskGraph.whenReady {
-        allTasks.forEach {
-            if (it is VerificationTask) {
-                logger.info("DISABLED: '$it'")
-                it.enabled = false
-            }
-        }
-    }
-}

buildSrc/build.gradle.kts

@@ -5,7 +5,8 @@ buildscript {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
     extra["defaultSnapshotVersion"] = kotlinBuildProperties.defaultSnapshotVersion
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
+    BootstrapOption.BintrayBootstrap("1.4.0-dev-1818", cacheRedirectorEnabled).applyToProject(project)
+//    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         if (cacheRedirectorEnabled) {
@@ -22,7 +23,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -72,6 +73,7 @@ rootProject.apply {
 val isTeamcityBuild = kotlinBuildProperties.isTeamcityBuild
 val intellijUltimateEnabled by extra(kotlinBuildProperties.intellijUltimateEnabled)
 val intellijSeparateSdks by extra(project.getBooleanProperty("intellijSeparateSdks") ?: false)
+val verifyDependencyOutput by extra( getBooleanProperty("kotlin.build.dependency.output.verification") ?: isTeamcityBuild)
 
 extra["intellijReleaseType"] = when {
     extra["versions.intellijSdk"]?.toString()?.contains("-EAP-") == true -> "snapshots"
@@ -96,9 +98,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.19")
-    implementation("com.gradle.publish:plugin-publish-plugin:0.11.0")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
     implementation("net.rubygrapefruit:native-platform-windows-amd64:${property("versions.native-platform")}")
@@ -107,7 +107,7 @@ dependencies {
 
     implementation("com.github.jengelman.gradle.plugins:shadow:${rootProject.extra["versions.shadow"]}")
     implementation("net.sf.proguard:proguard-gradle:6.2.2")
-    implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
+    implementation("org.jetbrains.intellij.deps:asm-all:7.0.1")
 
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 }

buildSrc/gradle.properties.as35

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

buildSrc/gradle.properties.as36

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

buildSrc/gradle.properties.as40

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

buildSrc/prepare-deps/build.gradle.kts

@@ -1,20 +1,22 @@
 @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.FileWriter
 import java.io.OutputStreamWriter
 import java.net.URI
 import java.text.SimpleDateFormat
-import java.time.Duration
-import java.time.Instant
 import java.util.*
 import javax.xml.stream.XMLOutputFactory
 
+import org.jetbrains.kotlin.gradle.tasks.internal.CleanableStore
+import org.jetbrains.kotlin.gradle.tasks.CleanDataTask
+
 plugins {
     base
 }
 
+val verifyDependencyOutput: Boolean by rootProject.extra
 val intellijUltimateEnabled: Boolean by rootProject.extra
 val intellijReleaseType: String by rootProject.extra
 val intellijVersion = rootProject.extra["versions.intellijSdk"] as String
@@ -23,7 +25,7 @@ val androidStudioRelease = rootProject.findProperty("versions.androidStudioRelea
 val androidStudioBuild = rootProject.findProperty("versions.androidStudioBuild") as String?
 val intellijSeparateSdks: Boolean by rootProject.extra
 val installIntellijCommunity = !intellijUltimateEnabled || intellijSeparateSdks
-val installIntellijUltimate = intellijUltimateEnabled && androidStudioRelease == null
+val installIntellijUltimate = intellijUltimateEnabled
 
 val intellijVersionDelimiterIndex = intellijVersion.indexOfAny(charArrayOf('.', '-'))
 if (intellijVersionDelimiterIndex == -1) {
@@ -32,6 +34,7 @@ if (intellijVersionDelimiterIndex == -1) {
 
 val platformBaseVersion = intellijVersion.substring(0, intellijVersionDelimiterIndex)
 
+logger.info("verifyDependencyOutput: $verifyDependencyOutput")
 logger.info("intellijUltimateEnabled: $intellijUltimateEnabled")
 logger.info("intellijVersion: $intellijVersion")
 logger.info("androidStudioRelease: $androidStudioRelease")
@@ -142,7 +145,21 @@ dependencies {
     }
 }
 
-val makeIntellijCore = buildIvyRepositoryTask(intellijCore, customDepsOrg, customDepsRepoDir)
+
+val cleanupIntellijCore = tasks.register<CleanDataTask>("cleanupIntellijCore") {
+    cleanableStoreProvider = provider { CleanableStore[repoDir.resolve("intellij-core").absolutePath] }
+}
+
+val cleanupIntellijAnnotation = tasks.register<CleanDataTask>("cleanupIntellijAnnotation") {
+    cleanableStoreProvider = provider { CleanableStore[repoDir.resolve(intellijRuntimeAnnotations).absolutePath] }
+}
+
+val cleanupDependencies = tasks.register("cleanupDependencies") {
+    dependsOn(cleanupIntellijCore)
+    dependsOn(cleanupIntellijAnnotation)
+}
+
+val makeIntellijCore = buildIvyRepositoryTaskAndRegisterCleanupTask(intellijCore, customDepsOrg, customDepsRepoDir)
 
 val makeIntellijAnnotations by tasks.registering(Copy::class) {
     dependsOn(makeIntellijCore)
@@ -150,17 +167,12 @@ val makeIntellijAnnotations by tasks.registering(Copy::class) {
     val intellijCoreRepo = CleanableStore[repoDir.resolve("intellij-core").absolutePath][intellijVersion].use()
     from(intellijCoreRepo.resolve("artifacts/annotations.jar"))
 
-    val annotationsStore = CleanableStore[repoDir.resolve(intellijRuntimeAnnotations).absolutePath]
-    val targetDir = annotationsStore[intellijVersion].use()
+    val targetDir = CleanableStore[repoDir.resolve(intellijRuntimeAnnotations).absolutePath][intellijVersion].use()
     into(targetDir)
 
     val ivyFile = File(targetDir, "$intellijRuntimeAnnotations.ivy.xml")
     outputs.files(ivyFile)
 
-    doFirst {
-        annotationsStore.cleanStore()
-    }
-
     doLast {
         writeIvyXml(
             customDepsOrg,
@@ -179,10 +191,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) })
-    }
+    from(provider { sources.map(::zipTree) })
     destinationDirectory.set(File(repoDir, sources.name))
     archiveBaseName.set("intellij")
     archiveClassifier.set("sources")
@@ -192,7 +201,7 @@ val mergeSources by tasks.creating(Jar::class.java) {
 val sourcesFile = mergeSources.outputs.files.singleFile
 
 val makeIde = if (androidStudioBuild != null) {
-    buildIvyRepositoryTask(
+    buildIvyRepositoryTaskAndRegisterCleanupTask(
         androidStudio,
         customDepsOrg,
         customDepsRepoDir,
@@ -203,9 +212,9 @@ val makeIde = if (androidStudioBuild != null) {
     )
 } else {
     val task = if (installIntellijUltimate) {
-        buildIvyRepositoryTask(intellijUltimate, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+        buildIvyRepositoryTaskAndRegisterCleanupTask(intellijUltimate, customDepsOrg, customDepsRepoDir, null, sourcesFile)
     } else {
-        buildIvyRepositoryTask(intellij, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+        buildIvyRepositoryTaskAndRegisterCleanupTask(intellij, customDepsOrg, customDepsRepoDir, null, sourcesFile)
     }
 
     task.configure {
@@ -215,7 +224,7 @@ val makeIde = if (androidStudioBuild != null) {
     task
 }
 
-val buildJpsStandalone = buildIvyRepositoryTask(jpsStandalone, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+val buildJpsStandalone = buildIvyRepositoryTaskAndRegisterCleanupTask(jpsStandalone, customDepsOrg, customDepsRepoDir, null, sourcesFile)
 
 tasks.named("build") {
     dependsOn(
@@ -229,15 +238,24 @@ tasks.named("build") {
 
 if (installIntellijUltimate) {
     val buildNodeJsPlugin =
-        buildIvyRepositoryTask(nodeJSPlugin, customDepsOrg, customDepsRepoDir, ::skipToplevelDirectory, sourcesFile)
+        buildIvyRepositoryTaskAndRegisterCleanupTask(nodeJSPlugin, customDepsOrg, customDepsRepoDir, ::skipToplevelDirectory, sourcesFile)
     tasks.named("build") { dependsOn(buildNodeJsPlugin) }
 }
 
+tasks.named("build") { dependsOn(cleanupDependencies) }
+
+// Task to delete legacy repo locations
+tasks.register<Delete>("cleanLegacy") {
+    delete("$projectDir/android-dx")
+    delete("$projectDir/intellij-sdk")
+}
+
 tasks.named<Delete>("clean") {
+    //TODO specify repos to clean? Use CleanDataTask
     delete(customDepsRepoDir)
 }
 
-fun buildIvyRepositoryTask(
+fun buildIvyRepositoryTaskAndRegisterCleanupTask(
     configuration: Configuration,
     organization: String,
     repoDirectory: File,
@@ -250,29 +268,29 @@ fun buildIvyRepositoryTask(
     fun ResolvedArtifact.moduleDirectory(): File =
         storeDirectory()[moduleVersion.id.version].use()
 
-    return tasks.register("buildIvyRepositoryFor${configuration.name.capitalize()}") {
+    val buildIvyRepositoryTask = tasks.register("buildIvyRepositoryFor${configuration.name.capitalize()}") {
         dependsOn(configuration)
         inputs.files(configuration)
 
-        outputs.upToDateWhen {
-            configuration.resolvedConfiguration.resolvedArtifacts.single()
-                .moduleDirectory()
-                .exists()
+        if (verifyDependencyOutput) {
+            outputs.dir(
+                provider {
+                    configuration.resolvedConfiguration.resolvedArtifacts.single().moduleDirectory()
+                }
+            )
+        } else {
+            outputs.upToDateWhen {
+                configuration.resolvedConfiguration.resolvedArtifacts.single()
+                    .moduleDirectory()
+                    .exists()
+            }
         }
 
         doFirst {
-            val artifact = configuration.resolvedConfiguration.resolvedArtifacts.single()
-            val moduleDirectory = artifact.moduleDirectory()
+            configuration.resolvedConfiguration.resolvedArtifacts.single().run {
+                val moduleDirectory = moduleDirectory()
+                val artifactsDirectory = File(moduleDirectory(), "artifacts")
 
-            artifact.storeDirectory().cleanStore()
-
-            if (moduleDirectory.exists()) {
-                logger.info("Path ${moduleDirectory.absolutePath} already exists, skipping unpacking.")
-                return@doFirst
-            }
-
-            with(artifact) {
-                val artifactsDirectory = File(moduleDirectory, "artifacts")
                 logger.info("Unpacking ${file.name} into ${artifactsDirectory.absolutePath}")
                 copy {
                     val fileTree = when (extension) {
@@ -329,9 +347,19 @@ fun buildIvyRepositoryTask(
             }
         }
     }
-}
 
-fun CleanableStore.cleanStore() = cleanDir(Instant.now().minus(Duration.ofDays(30)))
+    val cleanupIvyRepositoryTask = tasks.register<CleanDataTask>("cleanupIvyRepositoryFor${configuration.name.capitalize()}") {
+        cleanableStoreProvider = provider {
+            configuration.resolvedConfiguration.resolvedArtifacts.single().storeDirectory()
+        }
+    }
+
+    cleanupDependencies {
+        dependsOn(cleanupIvyRepositoryTask)
+    }
+
+    return buildIvyRepositoryTask
+}
 
 fun writeIvyXml(
     organization: String,

buildSrc/settings.gradle

@@ -20,13 +20,15 @@ buildscript {
         }
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
     }
 }
 
 def buildProperties = BuildPropertiesKt.getKotlinBuildPropertiesForSettings(settings)
 def projectVersions = file("../gradle/versions.properties").text
 
+BuildCacheKt.setupBuildCache(settings)
+
 include "prepare-deps"
 
 def target_AppCode_Clion = buildProperties.includeCidrPlugins && !projectVersions.contains("versions.androidStudioRelease")

buildSrc/src/main/kotlin/AggregateTest.kt

@@ -1,72 +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.
- */
-
-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
-    mainClass.set(fqName)
+    main = 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, P203;
+    P183, P191, P192, P193, P201;
 
     val version: Int = name.drop(1).toInt()
 
@@ -47,13 +47,10 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     IJ192(Platform.P192),
     IJ193(Platform.P193),
     IJ201(Platform.P201),
-    IJ202(Platform.P202),
-    IJ203(Platform.P203),
 
     AS35(Platform.P183),
     AS36(Platform.P192),
-    AS40(Platform.P193),
-    AS41(Platform.P201);
+    AS40(Platform.P193);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

buildSrc/src/main/kotlin/SmartJavaExec.kt

@@ -23,10 +23,6 @@ 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 {
@@ -38,11 +34,16 @@ fun JavaExec.passClasspathInJar() {
                 )
             }
         }
+        archiveName = "$main.${this@passClasspathInJar.name}.classpath.container.$extension"
+        destinationDir = temporaryDir
     }
 
     dependsOn(jarTask)
 
-    main = "-jar"
-    classpath = project.files()
-    args = listOf(jarTask.outputs.files.singleFile.path) + args.orEmpty()
+    doFirst {
+        main = "-jar"
+
+        classpath = project.files()
+        args = listOf(jarTask.outputs.files.singleFile.path) + args.orEmpty()
+    }
 }

buildSrc/src/main/kotlin/artifacts.kt

@@ -6,29 +6,14 @@ import org.gradle.api.Task
 import org.gradle.api.artifacts.ConfigurablePublishArtifact
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ConfigurationContainer
-import org.gradle.api.artifacts.PublishArtifact
 import org.gradle.api.artifacts.component.ProjectComponentIdentifier
-import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Category
-import org.gradle.api.attributes.LibraryElements
-import org.gradle.api.attributes.Usage
-import org.gradle.api.component.AdhocComponentWithVariants
 import org.gradle.api.file.DuplicatesStrategy
 import org.gradle.api.plugins.BasePluginConvention
-import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.plugins.JavaPlugin.*
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.tasks.GenerateModuleMetadata
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.Upload
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
-import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
-import plugins.KotlinBuildPublishingPlugin
 
 
 private const val MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME = "testJar"
@@ -41,7 +26,7 @@ fun Project.testsJar(body: Jar.() -> Unit = {}): Jar {
         pluginManager.withPlugin("java") {
             from(testSourceSet.output)
         }
-        archiveClassifier.set("tests")
+        classifier = "tests"
         body()
         project.addArtifact(testsJarCfg, this, this)
     }
@@ -71,26 +56,20 @@ fun Project.noDefaultJar() {
     }
 }
 
-fun <T : Task> Project.runtimeJarArtifactBy(
-    task: TaskProvider<T>,
-    artifactRef: Any,
-    body: ConfigurablePublishArtifact.() -> Unit = {}
-) {
+fun Project.runtimeJarArtifactBy(task: Task, artifactRef: Any, body: ConfigurablePublishArtifact.() -> Unit = {}) {
     addArtifact("archives", task, artifactRef, body)
     addArtifact("runtimeJar", task, artifactRef, body)
     configurations.findByName("runtime")?.let {
-        addArtifact(it.name, task, artifactRef, body)
+        addArtifact(it, task, artifactRef, body)
     }
 }
 
-fun Project.runtimeJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> = runtimeJar(getOrCreateTask("jar", body)) { }
+fun Project.runtimeJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> = runtimeJar(getOrCreateTask("jar", body), { })
 
 fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {}): TaskProvider<T> {
-
     tasks.named<Jar>("jar").configure {
         removeArtifacts(configurations.getOrCreate("archives"), this)
     }
-
     task.configure {
         configurations.findByName("embedded")?.let { embedded ->
             dependsOn(embedded)
@@ -99,47 +78,19 @@ fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {})
             }
         }
         setupPublicJar(project.the<BasePluginConvention>().archivesBaseName)
-        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+        setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE)
         body()
+        project.runtimeJarArtifactBy(this, this)
     }
-
-    project.runtimeJarArtifactBy(task, task)
-
-    val runtimeJar = configurations.maybeCreate("runtimeJar").apply {
-        isCanBeConsumed = true
-        isCanBeResolved = false
-        attributes {
-            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
-            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
-            attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
-            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
-        }
-    }
-
-    configurePublishedComponent {
-        withVariantsFromConfiguration(configurations[RUNTIME_ELEMENTS_CONFIGURATION_NAME]) { skip() }
-        addVariantsFromConfiguration(runtimeJar) { }
-    }
-
     return task
 }
 
 fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
-    configure<JavaPluginExtension> {
-        withSourcesJar()
-    }
-
-    val sourcesJar = getOrCreateTask<Jar>("sourcesJar") {
-        fun Project.mainJavaPluginSourceSet() = findJavaPluginConvention()?.sourceSets?.findByName("main")
-        fun Project.mainKotlinSourceSet() =
-            (extensions.findByName("kotlin") as? KotlinSourceSetContainer)?.sourceSets?.findByName("main")
-
-        fun Project.sources() = mainJavaPluginSourceSet()?.allSource ?: mainKotlinSourceSet()?.kotlin
-
+    val task = tasks.register<Jar>("sourcesJar") {
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         archiveClassifier.set("sources")
 
-        from(project.sources())
+        from(project.mainSourceSet.allSource)
 
         project.configurations.findByName("embedded")?.let { embedded ->
             from(provider {
@@ -148,7 +99,10 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
                     .map { it.id.componentIdentifier }
                     .filterIsInstance<ProjectComponentIdentifier>()
                     .mapNotNull {
-                        project(it.projectPath).sources()
+                        project(it.projectPath)
+                            .findJavaPluginConvention()
+                            ?.mainSourceSet
+                            ?.allSource
                     }
             })
         }
@@ -156,21 +110,13 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
         body()
     }
 
-    addArtifact("archives", sourcesJar)
-    addArtifact("sources", sourcesJar)
+    addArtifact("archives", task)
+    addArtifact("sources", task)
 
-    configurePublishedComponent {
-        addVariantsFromConfiguration(configurations[SOURCES_ELEMENTS_CONFIGURATION_NAME]) { }
-    }
-
-    return sourcesJar
+    return task
 }
 
 fun Project.javadocJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
-    configure<JavaPluginExtension> {
-        withJavadocJar()
-    }
-
     val javadocTask = getOrCreateTask<Jar>("javadocJar") {
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         archiveClassifier.set("javadoc")
@@ -182,40 +128,9 @@ fun Project.javadocJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     }
 
     addArtifact("archives", javadocTask)
-
-    configurePublishedComponent {
-        addVariantsFromConfiguration(configurations[JAVADOC_ELEMENTS_CONFIGURATION_NAME]) { }
-    }
-
     return javadocTask
 }
 
-fun Project.modularJar(body: Jar.() -> Unit): TaskProvider<Jar> {
-    val modularJar = configurations.maybeCreate("modularJar").apply {
-        isCanBeConsumed = true
-        isCanBeResolved = false
-        attributes {
-            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
-            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named("modular-jar"))
-        }
-    }
-
-    val modularJarTask = getOrCreateTask<Jar>("modularJar") {
-        archiveClassifier.set("modular")
-
-        body()
-    }
-
-    addArtifact("modularJar", modularJarTask)
-    addArtifact("archives", modularJarTask)
-
-    configurePublishedComponent {
-        addVariantsFromConfiguration(modularJar) { mapToMavenScope("runtime") }
-    }
-
-    return modularJarTask
-}
-
 
 fun Project.standardPublicJars() {
     runtimeJar()
@@ -223,22 +138,7 @@ fun Project.standardPublicJars() {
     javadocJar()
 }
 
-fun Project.publish(moduleMetadata: Boolean = false, configure: MavenPublication.() -> Unit = { }) {
-    apply<KotlinBuildPublishingPlugin>()
-
-    if (!moduleMetadata) {
-        tasks.withType<GenerateModuleMetadata> {
-            enabled = false
-        }
-    }
-
-    val publication = extensions.findByType<PublishingExtension>()
-        ?.publications
-        ?.findByName(KotlinBuildPublishingPlugin.PUBLICATION_NAME) as MavenPublication
-    publication.configure()
-}
-
-fun Project.publishWithLegacyMavenPlugin(body: Upload.() -> Unit = {}): Upload {
+fun Project.publish(body: Upload.() -> Unit = {}): Upload {
     apply<plugins.PublishedKotlinModule>()
 
     if (artifactsRemovedDiagnosticFlag) {
@@ -255,87 +155,12 @@ fun Project.publishWithLegacyMavenPlugin(body: Upload.() -> Unit = {}): Upload {
     }
 }
 
-fun Project.idePluginDependency(block: () -> Unit) {
-    val shouldActivate = rootProject.findProperty("publish.ide.plugin.dependencies")?.toString()?.toBoolean() == true
-    if (shouldActivate) {
-        block()
-    }
-}
-
-fun Project.publishProjectJars(projects: List<String>, libraryDependencies: List<String> = emptyList()) {
-    apply<JavaPlugin>()
-
-    val fatJarContents by configurations.creating
-
-    dependencies {
-        for (projectName in projects) {
-            fatJarContents(project(projectName)) { isTransitive = false }
-        }
-
-        for (libraryDependency in libraryDependencies) {
-            fatJarContents(libraryDependency)
-        }
-    }
-
-    publish()
-
-    val jar: Jar by tasks
-
-    jar.apply {
-        dependsOn(fatJarContents)
-
-        from {
-            fatJarContents.map(::zipTree)
-        }
-    }
-
-    sourcesJar {
-        from {
-            projects.map {
-                project(it).mainSourceSet.allSource
-            }
-        }
-    }
-
-    javadocJar()
-}
-
-fun Project.publishTestJar(projectName: String) {
-    apply<JavaPlugin>()
-
-    val fatJarContents by configurations.creating
-
-    dependencies {
-        fatJarContents(project(projectName, configuration = "tests-jar")) { isTransitive = false }
-    }
-
-    publish()
-
-    val jar: Jar by tasks
-
-    jar.apply {
-        dependsOn(fatJarContents)
-
-        from {
-            fatJarContents.map(::zipTree)
-        }
-    }
-
-    sourcesJar {
-        from {
-            project(projectName).testSourceSet.allSource
-        }
-    }
-
-    javadocJar()
-}
-
 fun ConfigurationContainer.getOrCreate(name: String): Configuration = findByName(name) ?: create(name)
 
 fun Jar.setupPublicJar(baseName: String, classifier: String = "") {
     val buildNumber = project.rootProject.extra["buildNumber"] as String
-    this.archiveBaseName.set(baseName)
-    this.archiveClassifier.set(classifier)
+    this.baseName = baseName
+    this.classifier = classifier
     manifest.attributes.apply {
         put("Implementation-Vendor", "JetBrains")
         put("Implementation-Title", baseName)
@@ -354,26 +179,9 @@ fun Project.addArtifact(configuration: Configuration, task: Task, artifactRef: A
 fun Project.addArtifact(configurationName: String, task: Task, artifactRef: Any, body: ConfigurablePublishArtifact.() -> Unit = {}) =
     addArtifact(configurations.getOrCreate(configurationName), task, artifactRef, body)
 
-fun <T : Task> Project.addArtifact(
-    configurationName: String,
-    task: TaskProvider<T>,
-    body: ConfigurablePublishArtifact.() -> Unit = {}
-): PublishArtifact {
+fun <T : Task> Project.addArtifact(configurationName: String, task: TaskProvider<T>, body: ConfigurablePublishArtifact.() -> Unit = {}) {
     configurations.maybeCreate(configurationName)
-    return artifacts.add(configurationName, task, body)
-}
-
-fun <T : Task> Project.addArtifact(
-    configurationName: String,
-    task: TaskProvider<T>,
-    artifactRef: Any,
-    body: ConfigurablePublishArtifact.() -> Unit = {}
-): PublishArtifact {
-    configurations.maybeCreate(configurationName)
-    return artifacts.add(configurationName, artifactRef) {
-        builtBy(task)
-        body()
-    }
+    artifacts.add(configurationName, task, body)
 }
 
 fun Project.cleanArtifacts() {
@@ -383,6 +191,3 @@ fun Project.cleanArtifacts() {
         }
     }
 }
-
-fun Project.configurePublishedComponent(configure: AdhocComponentWithVariants.() -> Unit) =
-    (components.findByName(KotlinBuildPublishingPlugin.ADHOC_COMPONENT_NAME) as AdhocComponentWithVariants?)?.apply(configure)

buildSrc/src/main/kotlin/dependencies.kt

@@ -1,8 +1,3 @@
-/*
- * 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
@@ -102,11 +97,9 @@ fun Project.kotlinStdlib(suffix: String? = null, classifier: String? = null): An
         dependencies.project(listOfNotNull(":kotlin-stdlib", suffix).joinToString("-"), classifier)
 }
 
-fun Project.kotlinBuiltins(): Any = kotlinBuiltins(forJvm = false)
-
-fun Project.kotlinBuiltins(forJvm: Boolean): Any =
+fun Project.kotlinBuiltins(): Any =
     if (kotlinBuildProperties.useBootstrapStdlib) "org.jetbrains.kotlin:builtins:$bootstrapKotlinVersion"
-    else dependencies.project(":core:builtins", configuration = "runtimeElementsJvm".takeIf { forJvm })
+    else dependencies.project(":core:builtins")
 
 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/embeddable.kt

@@ -20,6 +20,7 @@ val packagesToRelocate =
         "org.picocontainer",
         "org.jline",
         "org.fusesource",
+        "kotlinx.coroutines",
         "net.jpountz",
         "one.util.streamex",
         "kotlinx.collections.immutable"

buildSrc/src/main/kotlin/localDependencies.kt

@@ -165,7 +165,7 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
 
         classpath = mainSourceSet.runtimeClasspath
 
-        mainClass.set("com.intellij.idea.Main")
+        main = "com.intellij.idea.Main"
 
         workingDir = File(intellijRootDir(), "bin")
 
@@ -184,7 +184,7 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
             "-Dplugin.path=${ideaPluginDir.absolutePath}"
         )
 
-        if (Platform[201].orHigher() && !isIntellijUltimateSdkAvailable()) {
+        if (Platform[201].orHigher()) {
             jvmArgs("-Didea.platform.prefix=Idea")
         }
 

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -1,76 +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.
- */
-
-import com.gradle.publish.PluginBundleExtension
-import com.gradle.publish.PluginConfig
-import org.gradle.api.Project
-import org.gradle.api.publish.PublicationContainer
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.kotlin.dsl.*
-import plugins.KotlinBuildPublishingPlugin
-import plugins.configureRepository
-import java.util.*
-
-internal const val PLUGIN_MARKER_SUFFIX = ".gradle.plugin"
-
-@UseExperimental(ExperimentalStdlibApi::class)
-fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
-    val pluginDevelopment = extensions.getByType<PluginBundleExtension>()
-    val publishingExtension = extensions.getByType<PublishingExtension>()
-    val mainPublication = publishingExtension.publications[KotlinBuildPublishingPlugin.PUBLICATION_NAME] as MavenPublication
-
-    pluginDevelopment.plugins.forEach { declaration ->
-        val markerPublication = createMavenMarkerPublication(declaration, mainPublication, publishingExtension.publications)
-        if (withEmptyJars) {
-            addEmptyJarArtifacts(markerPublication)
-        }
-
-        tasks.named<PublishToMavenRepository>(
-            "publish${markerPublication.name.capitalize(Locale.ROOT)}PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository"
-        ).configureRepository()
-    }
-}
-
-fun Project.addEmptyJarArtifacts(publication: MavenPublication) {
-    val emptyJar = getOrCreateTask<Jar>("emptyJar") {
-        archiveBaseName.set("empty")
-    }
-
-    publication.artifact(emptyJar.get()) { }
-    publication.artifact(emptyJar.get()) { classifier = "sources" }
-    publication.artifact(emptyJar.get()) { classifier = "javadoc" }
-}
-
-// Based on code from `java-gradle-plugin`
-// https://github.com/gradle/gradle/blob/v6.4.0/subprojects/plugin-development/src/main/java/org/gradle/plugin/devel/plugins/MavenPluginPublishPlugin.java#L84
-private fun createMavenMarkerPublication(
-    declaration: PluginConfig,
-    coordinates: MavenPublication,
-    publications: PublicationContainer
-): MavenPublication {
-    return publications.create<MavenPublication>(declaration.name.toString() + "PluginMarkerMaven") {
-        val pluginId: String = declaration.id
-        artifactId = pluginId + PLUGIN_MARKER_SUFFIX
-        groupId = pluginId
-        pom.withXml {
-            val root = asElement()
-            val document = root.ownerDocument
-            val dependencies = root.appendChild(document.createElement("dependencies"))
-            val dependency = dependencies.appendChild(document.createElement("dependency"))
-            val groupId = dependency.appendChild(document.createElement("groupId"))
-            groupId.textContent = coordinates.groupId
-            val artifactId = dependency.appendChild(document.createElement("artifactId"))
-            artifactId.textContent = coordinates.artifactId
-            val version = dependency.appendChild(document.createElement("version"))
-            version.textContent = coordinates.version
-        }
-
-        pom.name.set(declaration.displayName)
-        pom.description.set(declaration.description)
-    }
-}

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

@@ -1,160 +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 plugins
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.attributes.Usage
-import org.gradle.api.component.AdhocComponentWithVariants
-import org.gradle.api.component.SoftwareComponentFactory
-import org.gradle.api.plugins.JavaBasePlugin
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.maven.plugins.MavenPublishPlugin
-import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
-import org.gradle.api.tasks.TaskProvider
-import org.gradle.kotlin.dsl.*
-import org.gradle.plugins.signing.SigningExtension
-import org.gradle.plugins.signing.SigningPlugin
-import java.net.URI
-import java.util.*
-import javax.inject.Inject
-
-
-class KotlinBuildPublishingPlugin @Inject constructor(
-    private val componentFactory: SoftwareComponentFactory
-) : Plugin<Project> {
-    override fun apply(target: Project): Unit = with(target) {
-        apply<MavenPublishPlugin>()
-        apply<SigningPlugin>()
-
-        val publishedRuntime = configurations.maybeCreate(RUNTIME_CONFIGURATION).apply {
-            isCanBeConsumed = false
-            isCanBeResolved = false
-            attributes {
-                attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
-            }
-        }
-
-        val publishedCompile = configurations.maybeCreate(COMPILE_CONFIGURATION).apply {
-            isCanBeConsumed = false
-            isCanBeResolved = false
-            attributes {
-                attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_API))
-            }
-        }
-
-        val kotlinLibraryComponent = componentFactory.adhoc(ADHOC_COMPONENT_NAME) as AdhocComponentWithVariants
-        components.add(kotlinLibraryComponent)
-        kotlinLibraryComponent.addVariantsFromConfiguration(publishedCompile) { mapToMavenScope("compile") }
-        kotlinLibraryComponent.addVariantsFromConfiguration(publishedRuntime) { mapToMavenScope("runtime") }
-
-        pluginManager.withPlugin("java-base") {
-            val runtimeElements by configurations
-            val apiElements by configurations
-
-            publishedRuntime.extendsFrom(runtimeElements)
-            publishedCompile.extendsFrom(apiElements)
-
-            kotlinLibraryComponent.addVariantsFromConfiguration(runtimeElements) {
-                mapToMavenScope("runtime")
-
-                if (configurationVariant.artifacts.any { JavaBasePlugin.UNPUBLISHABLE_VARIANT_ARTIFACTS.contains(it.type) }) {
-                    skip()
-                }
-            }
-        }
-
-        configure<PublishingExtension> {
-            publications {
-                create<MavenPublication>(PUBLICATION_NAME) {
-                    from(kotlinLibraryComponent)
-
-                    pom {
-                        packaging = "jar"
-                        name.set(humanReadableName(project))
-                        description.set(project.description ?: humanReadableName(project))
-                        url.set("https://kotlinlang.org/")
-                        licenses {
-                            license {
-                                name.set("The Apache License, Version 2.0")
-                                url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                            }
-                        }
-                        scm {
-                            url.set("https://github.com/JetBrains/kotlin")
-                            connection.set("scm:git:https://github.com/JetBrains/kotlin.git")
-                            developerConnection.set("scm:git:https://github.com/JetBrains/kotlin.git")
-                        }
-                        developers {
-                            developer {
-                                name.set("Kotlin Team")
-                                organization.set("JetBrains")
-                                organizationUrl.set("https://www.jetbrains.com")
-                            }
-                        }
-                    }
-                }
-            }
-
-            repositories {
-                maven {
-                    name = REPOSITORY_NAME
-                    url = file("${project.rootDir}/build/repo").toURI()
-                }
-            }
-        }
-
-        configure<SigningExtension> {
-            setRequired(provider {
-                project.findProperty("signingRequired")?.toString()?.toBoolean()
-                    ?: project.property("isSonatypeRelease") as Boolean
-            })
-
-            sign(extensions.getByType<PublishingExtension>().publications[PUBLICATION_NAME])
-        }
-
-        tasks.register("install") {
-            dependsOn(tasks.named("publishToMavenLocal"))
-        }
-
-        tasks.named<PublishToMavenRepository>("publish${PUBLICATION_NAME}PublicationTo${REPOSITORY_NAME}Repository")
-            .configureRepository()
-    }
-
-    companion object {
-        const val PUBLICATION_NAME = "Main"
-        const val REPOSITORY_NAME = "Maven"
-        const val ADHOC_COMPONENT_NAME = "kotlinLibrary"
-
-        const val COMPILE_CONFIGURATION = "publishedCompile"
-        const val RUNTIME_CONFIGURATION = "publishedRuntime"
-
-        @UseExperimental(ExperimentalStdlibApi::class)
-        fun humanReadableName(project: Project) =
-            project.name.split("-").joinToString(separator = " ") { it.capitalize(Locale.ROOT) }
-    }
-}
-
-fun TaskProvider<PublishToMavenRepository>.configureRepository() = configure {
-    dependsOn(project.rootProject.tasks.named("preparePublication"))
-    doFirst {
-        val preparePublication = project.rootProject.tasks.named("preparePublication").get()
-        val username: String? by preparePublication.extra
-        val password: String? by preparePublication.extra
-        val repoUrl: String by preparePublication.extra
-
-        repository.apply {
-            url = project.uri(repoUrl)
-            if (url.scheme != "file" && username != null && password != null) {
-                credentials {
-                    this.username = username
-                    this.password = password
-                }
-            }
-        }
-    }
-}

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

@@ -31,18 +31,12 @@ open class PublishedKotlinModule : Plugin<Project> {
 
             plugins.apply("maven")
 
-            configurations.maybeCreate("publishedRuntime").apply {
+            val publishedRuntime by configurations.creating {
                 the<MavenPluginConvention>()
                     .conf2ScopeMappings
                     .addMapping(0, this, Conf2ScopeMappingContainer.RUNTIME)
             }
 
-            configurations.maybeCreate("publishedCompile").apply {
-                the<MavenPluginConvention>()
-                    .conf2ScopeMappings
-                    .addMapping(0, this, Conf2ScopeMappingContainer.COMPILE)
-            }
-
             if (!project.hasProperty("prebuiltJar")) {
                 plugins.apply("signing")
 

buildSrc/src/main/kotlin/publish.kt

@@ -23,15 +23,3 @@ fun DependencyHandler.publishedRuntime(
 ): ExternalModuleDependency =
     addDependencyTo(this, "publishedRuntime", dependencyNotation, dependencyConfiguration)
 
-
-val NamedDomainObjectContainer<Configuration>.publishedCompile: NamedDomainObjectProvider<Configuration> get() = named("publishedCompile")
-
-fun DependencyHandler.publishedCompile(dependencyNotation: Any): Dependency? =
-    add("publishedCompile", dependencyNotation)
-
-fun DependencyHandler.publishedCompile(
-    dependencyNotation: String,
-    dependencyConfiguration: Action<ExternalModuleDependency>
-): ExternalModuleDependency =
-    addDependencyTo(this, "publishedCompile", dependencyNotation, dependencyConfiguration)
-

buildSrc/src/main/kotlin/tasks.kt

@@ -31,46 +31,6 @@ 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-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,
@@ -119,20 +79,21 @@ fun Project.projectTest(
         }
     }
 
-    if (project.findProperty("kotlin.test.instrumentation.disable")?.toString()?.toBoolean() != true) {
-        doFirst {
-            val agent = tasks.findByPath(":test-instrumenter:jar")!!.outputs.files.singleFile
-            val args = project.findProperty("kotlin.test.instrumentation.args")?.let { "=$it" }.orEmpty()
-            jvmArgs("-javaagent:$agent$args")
-        }
-        dependsOn(":test-instrumenter:jar")
+    doFirst {
+        val agent = tasks.findByPath(":test-instrumenter:jar")!!.outputs.files.singleFile
+
+        val args = project.findProperty("kotlin.test.instrumentation.args")?.let { "=$it" }.orEmpty()
+
+        jvmArgs("-javaagent:$agent$args")
     }
 
+    dependsOn(":test-instrumenter:jar")
+
     jvmArgs(
         "-ea",
         "-XX:+HeapDumpOnOutOfMemoryError",
         "-XX:+UseCodeCacheFlushing",
-        "-XX:ReservedCodeCacheSize=256m",
+        "-XX:ReservedCodeCacheSize=128m",
         "-Djna.nosys=true"
     )
 
@@ -145,11 +106,6 @@ fun Project.projectTest(
     environment("PROJECT_BUILD_DIR", buildDir)
     systemProperty("jps.kotlin.home", rootProject.extra["distKotlinHomeDir"]!!)
     systemProperty("kotlin.ni", if (rootProject.hasProperty("newInferenceTests")) "true" else "false")
-    systemProperty("org.jetbrains.kotlin.skip.muted.tests", if (rootProject.hasProperty("skipMutedTests")) "true" else "false")
-
-    if (Platform[202].orHigher()) {
-        systemProperty("idea.ignore.disabled.plugins", "true")
-    }
 
     var subProjectTempRoot: Path? = null
     doFirst {

compiler/android-tests/build.gradle.kts

@@ -29,12 +29,9 @@ dependencies {
         testCompile(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
     }
 
-    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", rootProject = rootProject) }
-    Platform[202].orHigher {
-        testCompile(intellijDep()) { includeJars("groovy", rootProject = rootProject) }
-    }
-    Platform[201].orLower {
-        testCompile(intellijDep()) { includeJars("groovy-all", rootProject = rootProject) }
+    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", "groovy-all", rootProject = rootProject) }
+    Platform[191].orLower {
+        testCompile(intellijDep()) { includeJars("jps-builders") }
     }
     Platform[192].orHigher {
         testCompile(intellijPluginDep("java")) { includeJars("jps-builders") }

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

@@ -100,11 +100,9 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         File("./gradlew.bat").copyTo(File(projectRoot, "gradlew.bat"));
         val file = File(target, "gradle-wrapper.properties")
         file.readLines().map {
-            when {
-                it.startsWith("distributionUrl") -> "distributionUrl=https\\://services.gradle.org/distributions/gradle-$GRADLE_VERSION-bin.zip"
-                it.startsWith("distributionSha256Sum") -> "distributionSha256Sum=$GRADLE_SHA_256"
-                else -> it
-            }
+            if (it.startsWith("distributionUrl"))
+                "distributionUrl=https\\://services.gradle.org/distributions/gradle-$GRADLE_VERSION-bin.zip"
+            else it
         }.let { lines ->
             FileWriter(file).use { fw ->
                 lines.forEach { line ->
@@ -294,7 +292,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val kind = KotlinBaseTest.extractConfigurationKind(testFiles)
                     val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles)
                     val keyConfiguration = CompilerConfiguration()
-                    KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+                    CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
 
                     val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString())
                     val compiler = if (isJvm8Target) {
@@ -303,7 +301,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val filesHolder = holders.getOrPut(key) {
                         FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
                             println("Creating new configuration by $key")
-                            KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
+                            CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
                     }
 
@@ -317,8 +315,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         CodegenTestCase.createTestFilesFromFile(file, expectedText, "kotlin.coroutines", false, TargetBackend.JVM)
 
     companion object {
-        const val GRADLE_VERSION = "5.6.4" // update GRADLE_SHA_256 on change
-        const val GRADLE_SHA_256 = "1f3067073041bc44554d0efe5d402a33bc3d3c93cc39ab684f308586d732a80d"
+        const val GRADLE_VERSION = "5.6.4"
         const val testClassPackage = "org.jetbrains.kotlin.android.tests"
         const val testClassName = "CodegenTestCaseOnAndroid"
         const val baseTestClassPackage = "org.jetbrains.kotlin.android.tests"

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.backend.common
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.backend.common.bridges.findInterfaceImplementation
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.util.getExceptionMessage
-import org.jetbrains.kotlin.util.getNonPrivateTraitMembersForDelegation
 import org.jetbrains.kotlin.utils.DFS
 import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
 
@@ -55,8 +55,14 @@ object CodegenUtil {
     @JvmOverloads
     fun getNonPrivateTraitMethods(descriptor: ClassDescriptor, copy: Boolean = true): Map<FunctionDescriptor, FunctionDescriptor> {
         val result = linkedMapOf<FunctionDescriptor, FunctionDescriptor>()
+        for (declaration in DescriptorUtils.getAllDescriptors(descriptor.defaultType.memberScope)) {
+            if (declaration !is CallableMemberDescriptor) continue
+
+            val traitMember = findInterfaceImplementation(declaration)
+            if (traitMember == null ||
+                    Visibilities.isPrivate(traitMember.visibility) ||
+                    traitMember.visibility == Visibilities.INVISIBLE_FAKE) continue
 
-        for ((declaration, traitMember) in getNonPrivateTraitMembersForDelegation(descriptor)) {
             assert(traitMember.modality !== Modality.ABSTRACT) { "Cannot delegate to abstract trait method: $declaration" }
 
             // inheritedMember can be abstract here. In order for FunctionCodegen to generate the method body, we're creating a copy here
@@ -87,18 +93,20 @@ object CodegenUtil {
     private fun mapMembers(
         inherited: CallableMemberDescriptor,
         traitMember: CallableMemberDescriptor
-    ): Map<FunctionDescriptor, FunctionDescriptor> = when (traitMember) {
-        is SimpleFunctionDescriptor -> mapOf(traitMember to inherited as FunctionDescriptor)
-        is PropertyDescriptor -> linkedMapOf<FunctionDescriptor, FunctionDescriptor>().also { result ->
+    ): LinkedHashMap<FunctionDescriptor, FunctionDescriptor> {
+        val result = linkedMapOf<FunctionDescriptor, FunctionDescriptor>()
+        if (traitMember is SimpleFunctionDescriptor) {
+            result[traitMember] = inherited as FunctionDescriptor
+        } else if (traitMember is PropertyDescriptor) {
             for (traitAccessor in traitMember.accessors) {
                 for (inheritedAccessor in (inherited as PropertyDescriptor).accessors) {
-                    if ((inheritedAccessor is PropertyGetterDescriptor) == (traitAccessor is PropertyGetterDescriptor)) {
-                        result[traitAccessor] = inheritedAccessor
+                    if (inheritedAccessor::class.java == traitAccessor::class.java) { // same accessor kind
+                        result.put(traitAccessor, inheritedAccessor)
                     }
                 }
             }
         }
-        else -> error("Unexpected member: $inherited")
+        return result
     }
 
     @JvmStatic

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

@@ -24,8 +24,6 @@ import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized
 import org.jetbrains.kotlin.resolve.descriptorUtil.isTypeRefinementEnabled
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.util.findImplementationFromInterface
-import org.jetbrains.kotlin.util.findInterfaceImplementation
 
 fun <Signature> generateBridgesForFunctionDescriptor(
     descriptor: FunctionDescriptor,
@@ -83,4 +81,60 @@ open class DescriptorBasedFunctionHandle(val descriptor: FunctionDescriptor) : F
     override fun toString(): String {
         return descriptor.toString()
     }
-}
+}
+
+
+/**
+ * Given a fake override in a class, returns an overridden declaration with implementation in trait, such that a method delegating to that
+ * trait implementation should be generated into the class containing the fake override; or null if the given function is not a fake
+ * override of any trait implementation or such method was already generated into the superclass or is a method from Any.
+ */
+fun findInterfaceImplementation(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
+    if (descriptor.kind.isReal) return null
+    if (isOrOverridesSynthesized(descriptor)) return null
+
+    val implementation = findImplementationFromInterface(descriptor) ?: return null
+    val immediateConcreteSuper = firstSuperMethodFromKotlin(descriptor, implementation) ?: return null
+
+    if (!DescriptorUtils.isInterface(immediateConcreteSuper.containingDeclaration)) {
+        // If this implementation is already generated into the superclass, we need not generate it again, it'll be inherited
+        return null
+    }
+
+    return immediateConcreteSuper
+}
+
+/**
+ * Given a fake override, returns an overridden non-abstract function from an interface which is the actual implementation of this function
+ * that should be called when the given fake override is called.
+ */
+fun findImplementationFromInterface(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
+    val overridden = OverridingUtil.getOverriddenDeclarations(descriptor)
+    val filtered = OverridingUtil.filterOutOverridden(overridden)
+
+    val result = filtered.firstOrNull { it.modality != Modality.ABSTRACT } ?: return null
+
+    if (DescriptorUtils.isClassOrEnumClass(result.containingDeclaration)) return null
+
+    return result
+}
+
+/**
+ * Given a fake override and its implementation (non-abstract declaration) somewhere in supertypes,
+ * returns the first immediate super function of the given fake override which overrides that implementation.
+ * The returned function should be called from TImpl-bridges generated for the given fake override.
+ */
+fun firstSuperMethodFromKotlin(
+    descriptor: CallableMemberDescriptor,
+    implementation: CallableMemberDescriptor
+): CallableMemberDescriptor? {
+    return descriptor.overriddenDescriptors.firstOrNull { overridden ->
+        overridden.modality != Modality.ABSTRACT &&
+                (overridden == implementation || OverridingUtil.overrides(
+                    overridden,
+                    implementation,
+                    overridden.module.isTypeRefinementEnabled(),
+                    true
+                ))
+    }
+}

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

@@ -90,18 +90,12 @@ public abstract class AnnotationCodegen {
     private final KotlinTypeMapper typeMapper;
     private final ModuleDescriptor module;
     private final GenerationState state;
-    private final boolean skipNullabilityAnnotations;
 
     private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state) {
-        this(innerClassConsumer, state, false);
-    }
-
-    private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state, boolean skipNullabilityAnnotations) {
         this.innerClassConsumer = innerClassConsumer;
         this.typeMapper = state.getTypeMapper();
         this.module = state.getModule();
         this.state = state;
-        this.skipNullabilityAnnotations = skipNullabilityAnnotations;
     }
 
     /**
@@ -111,16 +105,6 @@ public abstract class AnnotationCodegen {
             @Nullable Annotated annotated,
             @Nullable Type returnType,
             @Nullable KotlinType typeForTypeAnnotations
-    ) {
-        genAnnotations(annotated, returnType, typeForTypeAnnotations, null, Collections.emptyList());
-    }
-
-    public void genAnnotations(
-            @Nullable Annotated annotated,
-            @Nullable Type returnType,
-            @Nullable KotlinType typeForTypeAnnotations,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer,
-            @NotNull List<String> additionalVisibleAnnotations
     ) {
         if (annotated == null) return;
 
@@ -155,28 +139,22 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        for (String annotation : additionalVisibleAnnotations) {
-            generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation, true);
-            annotationDescriptorsAlreadyPresent.add(annotation);
-        }
-
-        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
+        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent);
         generateTypeAnnotations(annotated, typeForTypeAnnotations);
     }
 
     private void generateAdditionalAnnotations(
             @NotNull Annotated annotated,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent
     ) {
         if (annotated instanceof CallableDescriptor) {
-            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
+            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent);
         }
         else if (annotated instanceof FieldDescriptor) {
             generateAdditionalCallableAnnotations(
-                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent,
-                    parameterContainer);
+                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent
+            );
         }
         else if (annotated instanceof ClassDescriptor) {
             generateAdditionalClassAnnotations(annotationDescriptorsAlreadyPresent, (ClassDescriptor) annotated);
@@ -186,15 +164,11 @@ public abstract class AnnotationCodegen {
     private void generateAdditionalCallableAnnotations(
             @NotNull CallableDescriptor descriptor,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent
     ) {
         // No need to annotate privates, synthetic accessors and their parameters
         if (isInvisibleFromTheOutside(descriptor)) return;
-        if (descriptor instanceof ParameterDescriptor &&
-            isInvisibleFromTheOutside(parameterContainer != null ? parameterContainer : descriptor.getContainingDeclaration())) {
-            return;
-        }
+        if (descriptor instanceof ValueParameterDescriptor && isInvisibleFromTheOutside(descriptor.getContainingDeclaration())) return;
 
         // No need to annotate annotation methods since they're always non-null
         if (descriptor instanceof PropertyGetterDescriptor &&
@@ -202,7 +176,7 @@ public abstract class AnnotationCodegen {
             return;
         }
 
-        if (returnType != null && !AsmUtil.isPrimitive(returnType) && !skipNullabilityAnnotations) {
+        if (returnType != null && !AsmUtil.isPrimitive(returnType)) {
             generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent);
         }
     }
@@ -248,17 +222,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, Type.getType(NotNull.class).getDescriptor(), false);
+                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, NotNull.class);
                 }
                 return;
             }
         }
 
-        generateAnnotationIfNotPresent(
-                annotationDescriptorsAlreadyPresent,
-                TypeUtils.isNullableType(type) ? Type.getType(Nullable.class).getDescriptor() : Type.getType(NotNull.class).getDescriptor(),
-                false
-        );
+        boolean isNullableType = TypeUtils.isNullableType(type);
+
+        Class<?> annotationClass = isNullableType ? Nullable.class : NotNull.class;
+
+        generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
     }
 
     private static final Map<JvmTarget, Map<KotlinTarget, ElementType>> annotationTargetMaps = new EnumMap<>(JvmTarget.class);
@@ -338,13 +312,10 @@ public abstract class AnnotationCodegen {
         visitor.visitEnd();
     }
 
-    private void generateAnnotationIfNotPresent(
-            Set<String> annotationDescriptorsAlreadyPresent,
-            String annotationDescriptor,
-            boolean visible
-    ) {
-        if (!annotationDescriptorsAlreadyPresent.contains(annotationDescriptor)) {
-            visitAnnotation(annotationDescriptor, visible).visitEnd();
+    private void generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
+        String descriptor = Type.getType(annotationClass).getDescriptor();
+        if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) {
+            visitAnnotation(descriptor, false).visitEnd();
         }
     }
 
@@ -629,16 +600,7 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return forMethod(mv, innerClassConsumer, state, false);
-    }
-
-    public static AnnotationCodegen forMethod(
-            @NotNull MethodVisitor mv,
-            @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
-    ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -658,16 +620,7 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return forField(fv, innerClassConsumer, state, false);
-    }
-
-    public static AnnotationCodegen forField(
-            @NotNull FieldVisitor fv,
-            @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
-    ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -686,10 +639,9 @@ public abstract class AnnotationCodegen {
             int parameter,
             @NotNull MethodVisitor mv,
             @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
+            @NotNull GenerationState state
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {

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

@@ -17,13 +17,11 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
-import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue
-import org.jetbrains.kotlin.resolve.calls.model.*
-import org.jetbrains.kotlin.resolve.descriptorUtil.overriddenTreeUniqueAsSequence
+import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
+import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
+import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
 import org.jetbrains.kotlin.utils.DFS
 import org.jetbrains.kotlin.utils.mapToIndex
 
@@ -37,10 +35,10 @@ abstract class ArgumentGenerator {
      * @see kotlin.reflect.jvm.internal.KCallableImpl.callBy
      */
     open fun generate(
-        valueArgumentsByIndex: List<ResolvedValueArgument>,
-        actualArgs: List<ResolvedValueArgument>,
-        // may be null for a constructor of an object literal
-        calleeDescriptor: CallableDescriptor?
+            valueArgumentsByIndex: List<ResolvedValueArgument>,
+            actualArgs: List<ResolvedValueArgument>,
+            // may be null for a constructor of an object literal
+            calleeDescriptor: CallableDescriptor?
     ): DefaultCallArgs {
         assert(valueArgumentsByIndex.size == actualArgs.size) {
             "Value arguments collection should have same size, but ${valueArgumentsByIndex.size} != ${actualArgs.size}"
@@ -52,9 +50,9 @@ abstract class ArgumentGenerator {
             ArgumentAndDeclIndex(it, arg2Index[it]!!)
         }.toMutableList()
 
-        for ((index, value) in valueArgumentsByIndex.withIndex()) {
-            if (value is DefaultValueArgument) {
-                actualArgsWithDeclIndex.add(index, ArgumentAndDeclIndex(value, index))
+        valueArgumentsByIndex.withIndex().forEach {
+            if (it.value is DefaultValueArgument) {
+                actualArgsWithDeclIndex.add(it.index, ArgumentAndDeclIndex(it.value, it.index))
             }
         }
 
@@ -72,7 +70,8 @@ abstract class ArgumentGenerator {
                 is DefaultValueArgument -> {
                     if (calleeDescriptor?.defaultValueFromJava(declIndex) == true) {
                         generateDefaultJava(declIndex, argument)
-                    } else {
+                    }
+                    else {
                         defaultArgs.mark(declIndex)
                         generateDefault(declIndex, argument)
                     }
@@ -117,42 +116,11 @@ abstract class ArgumentGenerator {
 }
 
 private fun CallableDescriptor.defaultValueFromJava(index: Int): Boolean = DFS.ifAny(
-    listOf(this),
-    { current -> current.original.overriddenDescriptors.map { it.original } },
-    { descriptor ->
-        descriptor.original.overriddenDescriptors.isEmpty() &&
-                descriptor is JavaCallableMemberDescriptor &&
-                descriptor.valueParameters[index].declaresDefaultValue()
-    }
+        listOf(this),
+        { current -> current.original.overriddenDescriptors.map { it.original } },
+        { descriptor ->
+            descriptor.original.overriddenDescriptors.isEmpty() &&
+            descriptor is JavaCallableMemberDescriptor &&
+            descriptor.valueParameters[index].declaresDefaultValue()
+        }
 )
-
-fun shouldInvokeDefaultArgumentsStub(resolvedCall: ResolvedCall<*>): Boolean {
-    val descriptor = resolvedCall.resultingDescriptor
-    val valueArgumentsByIndex = resolvedCall.valueArgumentsByIndex ?: return false
-    for (index in valueArgumentsByIndex.indices) {
-        val resolvedValueArgument = valueArgumentsByIndex[index]
-        if (resolvedValueArgument is DefaultValueArgument && !descriptor.defaultValueFromJava(index)) {
-            return true
-        }
-    }
-    return false
-}
-
-fun getFunctionWithDefaultArguments(functionDescriptor: FunctionDescriptor): FunctionDescriptor {
-    if (functionDescriptor.containingDeclaration !is ClassDescriptor) return functionDescriptor
-    if (functionDescriptor.overriddenDescriptors.isEmpty()) return functionDescriptor
-
-    // We are calling a function with some arguments mapped as defaults.
-    // Multiple override-equivalent functions from different supertypes with (potentially different) default values
-    // can't be overridden by any function in a subtype.
-    // Also, a function overriding some other function can't introduce default parameter values.
-    // Thus, among all overridden functions should be one (and only one) function
-    // that doesn't override anything and has parameters with default values.
-    return functionDescriptor.overriddenTreeUniqueAsSequence(true)
-        .firstOrNull { function ->
-            function.kind == CallableMemberDescriptor.Kind.DECLARATION &&
-                    function.overriddenDescriptors.isEmpty() &&
-                    function.valueParameters.any { valueParameter -> valueParameter.hasDefaultValue() }
-        }
-        ?: functionDescriptor
-}

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.codegen
 
+import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
@@ -19,7 +20,7 @@ import org.jetbrains.org.objectweb.asm.util.Printer
 class CallableMethod(
     override val owner: Type,
     private val defaultImplOwner: Type?,
-    computeDefaultMethod: () -> Method,
+    computeDefaultMethodDesc: () -> String,
     private val signature: JvmMethodSignature,
     val invokeOpcode: Int,
     override val dispatchReceiverType: Type?,
@@ -31,10 +32,7 @@ class CallableMethod(
     val isInterfaceMethod: Boolean,
     private val isDefaultMethodInInterface: Boolean
 ) : Callable {
-    private val defaultImplMethod: Method by lazy(LazyThreadSafetyMode.PUBLICATION, computeDefaultMethod)
-
-    private val defaultImplMethodName: String get() = defaultImplMethod.name
-    private val defaultMethodDesc: String get() = defaultImplMethod.descriptor
+    private val defaultMethodDesc: String by lazy(LazyThreadSafetyMode.PUBLICATION, computeDefaultMethodDesc)
 
     fun getValueParameters(): List<JvmMethodParameterSignature> =
         signature.valueParameters
@@ -70,14 +68,10 @@ class CallableMethod(
         } else {
             v.visitMethodInsn(
                 INVOKESTATIC, defaultImplOwner.internalName,
-                defaultImplMethodName, defaultMethodDesc, isDefaultMethodInInterface
+                method.name + JvmAbi.DEFAULT_PARAMS_IMPL_SUFFIX, defaultMethodDesc, isDefaultMethodInInterface
             )
 
-            StackValue.coerce(
-                Type.getReturnType(defaultMethodDesc),
-                Type.getReturnType(signature.asmMethod.descriptor),
-                v
-            )
+            StackValue.coerce(Type.getReturnType(defaultMethodDesc), Type.getReturnType(signature.asmMethod.descriptor), v)
         }
     }
 

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

@@ -10,10 +10,10 @@ import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
+import org.jetbrains.kotlin.backend.common.bridges.ImplKt;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptor;
@@ -38,8 +38,6 @@ 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> {
     @NotNull
@@ -126,7 +124,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
         for (DeclarationDescriptor memberDescriptor : DescriptorUtils.getAllDescriptors(descriptor.getDefaultType().getMemberScope())) {
             if (memberDescriptor instanceof CallableMemberDescriptor) {
                 CallableMemberDescriptor member = (CallableMemberDescriptor) memberDescriptor;
-                if (!member.getKind().isReal() && findInterfaceImplementation(member) == null) {
+                if (!member.getKind().isReal() && ImplKt.findInterfaceImplementation(member) == null) {
                     if (member instanceof FunctionDescriptor) {
                         functionCodegen.generateBridges((FunctionDescriptor) member);
                     }
@@ -221,32 +219,21 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
     protected void generateDelegatesToDefaultImpl() {
         if (isJvmInterface(descriptor)) return;
 
-        boolean isErasedInlineClass = InlineClassesUtilsKt.isInlineClass(descriptor) && kind == OwnerKind.ERASED_INLINE_CLASS;
-        JvmKotlinType receiverType = new JvmKotlinType(typeMapper.mapType(descriptor), descriptor.getDefaultType());
-
         for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) {
-            generateDelegationToDefaultImpl(entry.getKey(), entry.getValue(), receiverType, functionCodegen, state, isErasedInlineClass);
+            FunctionDescriptor interfaceFun = entry.getKey();
+            //skip java 8 default methods
+            if (!CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) &&
+                !JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(
+                        DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(interfaceFun), state.getJvmDefaultMode()
+                )
+            ) {
+                generateDelegationToDefaultImpl(interfaceFun, entry.getValue());
+            }
         }
     }
 
-    public static void generateDelegationToDefaultImpl(
-            @NotNull FunctionDescriptor interfaceFun,
-            @NotNull FunctionDescriptor inheritedFun,
-            @NotNull JvmKotlinType receiverType,
-            @NotNull FunctionCodegen functionCodegen,
-            @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(actualImplementation) ||
-            JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(actualImplementation, state.getJvmDefaultMode())) {
-            return;
-        }
+    private void generateDelegationToDefaultImpl(@NotNull FunctionDescriptor interfaceFun, @NotNull FunctionDescriptor inheritedFun) {
 
-        KotlinTypeMapper typeMapper = state.getTypeMapper();
         functionCodegen.generateMethod(
                 new JvmDeclarationOrigin(
                         CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL, descriptorToDeclaration(interfaceFun), interfaceFun, null
@@ -261,7 +248,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
                         DeclarationDescriptor declarationInheritedFun = inheritedFun.getContainingDeclaration();
                         PsiElement classForInheritedFun = descriptorToDeclaration(declarationInheritedFun);
                         if (classForInheritedFun instanceof KtDeclaration) {
-                            codegen.markLineNumber(classForInheritedFun, false);
+                            codegen.markLineNumber((KtElement) classForInheritedFun, false);
                         }
 
                         ClassDescriptor containingTrait = (ClassDescriptor) containingDeclaration;
@@ -295,15 +282,18 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
                         InstructionAdapter iv = codegen.v;
                         Type[] myArgTypes = signature.getAsmMethod().getArgumentTypes();
                         Type[] toArgTypes = defaultImplsMethod.getArgumentTypes();
+                        boolean isErasedInlineClass =
+                                InlineClassesUtilsKt.isInlineClass(descriptor) && kind == OwnerKind.ERASED_INLINE_CLASS;
 
                         int myArgI = 0;
                         int argVar = 0;
 
+                        Type receiverType = typeMapper.mapType(descriptor);
                         KotlinType interfaceKotlinType = ((ClassDescriptor) inheritedFun.getContainingDeclaration()).getDefaultType();
-                        StackValue.local(argVar, receiverType.getType(), receiverType.getKotlinType())
+                        StackValue.local(argVar, receiverType, descriptor.getDefaultType())
                                 .put(OBJECT_TYPE, interfaceKotlinType, iv);
                         if (isErasedInlineClass) myArgI++;
-                        argVar += receiverType.getType().getSize();
+                        argVar += receiverType.getSize();
 
                         int toArgI = 1;
 

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

@@ -54,6 +54,7 @@ import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CallableReferenceUtilKt.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConst;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE;
+import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.initDefaultSourceMappingIfNeeded;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
@@ -169,7 +170,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
                 superInterfaceAsmTypes
         );
 
-        initDefaultSourceMappingIfNeeded();
+        initDefaultSourceMappingIfNeeded(context, this, state);
 
         v.visitSource(element.getContainingFile().getName(), null);
     }
@@ -185,12 +186,6 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         generateBridges();
         generateClosureBody();
 
-        if (samType != null) {
-            SamWrapperCodegen.generateDelegatesToDefaultImpl(
-                    asmType, classDescriptor, samType.getClassDescriptor(), functionCodegen, state
-            );
-        }
-
         this.constructor = generateConstructor();
 
         if (isConst(closure)) {
@@ -265,9 +260,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         Method method = v.getSerializationBindings().get(METHOD_FOR_FUNCTION, frontendFunDescriptor);
         assert method != null : "No method for " + frontendFunDescriptor;
 
-        FunctionDescriptor freeLambdaDescriptor = FakeDescriptorsForReferencesKt.createFreeFakeLambdaDescriptor(
-                frontendFunDescriptor, state.getTypeApproximator()
-        );
+        FunctionDescriptor freeLambdaDescriptor = FakeDescriptorsForReferencesKt.createFreeFakeLambdaDescriptor(frontendFunDescriptor);
         v.getSerializationBindings().put(METHOD_FOR_FUNCTION, freeLambdaDescriptor, method);
 
         DescriptorSerializer serializer =
@@ -414,7 +407,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
             if (generateBody) {
                 mv.visitCode();
                 InstructionAdapter iv = new InstructionAdapter(mv);
-                CallableReferenceUtilKt.generateFunctionReferenceSignature(iv, descriptor, state);
+                CallableReferenceUtilKt.generateCallableReferenceSignature(iv, descriptor, state);
                 iv.areturn(JAVA_STRING_TYPE);
                 FunctionCodegen.endVisit(iv, "function reference getSignature", element);
             }
@@ -472,7 +465,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
                     assert functionReferenceTarget != null : "No function reference target: " + funDescriptor;
                     generateCallableReferenceDeclarationContainerClass(iv, functionReferenceTarget, state);
                     iv.aconst(functionReferenceTarget.getName().asString());
-                    CallableReferenceUtilKt.generateFunctionReferenceSignature(iv, functionReferenceTarget, state);
+                    CallableReferenceUtilKt.generateCallableReferenceSignature(iv, functionReferenceTarget, state);
                     int flags =
                             getCallableReferenceTopLevelFlag(functionReferenceTarget) +
                             (calculateFunctionReferenceFlags(functionReferenceCall, funDescriptor) << 1);

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

@@ -153,18 +153,18 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
             signature.genericsSignature,
             FunctionCodegen.getThrownExceptions(functionDescriptor, typeMapper)
         )
-        val skipNullabilityAnnotations = flags and Opcodes.ACC_PRIVATE != 0 || flags and Opcodes.ACC_SYNTHETIC != 0
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
-            .genAnnotations(functionDescriptor, signature.returnType, functionDescriptor.returnType)
+        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(
+            functionDescriptor,
+            signature.returnType,
+            functionDescriptor.returnType
+        )
 
         if (state.classBuilderMode == ClassBuilderMode.KAPT3) {
             mv.visitAnnotation(ANNOTATION_TYPE_DESCRIPTOR_FOR_JVM_OVERLOADS_GENERATED_METHODS, false)
         }
 
-        FunctionCodegen.generateParameterAnnotations(
-            functionDescriptor, mv, signature, remainingParameters, memberCodegen, state, skipNullabilityAnnotations
-        )
+        FunctionCodegen.generateParameterAnnotations(functionDescriptor, mv, signature, remainingParameters, memberCodegen, state)
 
         if (!state.classBuilderMode.generateBodies) {
             FunctionCodegen.generateLocalVariablesForParameters(

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

@@ -52,6 +52,7 @@ 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.resolve.sam.SamConstructorDescriptor;
 import org.jetbrains.kotlin.load.kotlin.MethodSignatureMappingKt;
 import org.jetbrains.kotlin.load.kotlin.TypeSignatureMappingKt;
 import org.jetbrains.kotlin.name.Name;
@@ -76,7 +77,6 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
-import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor;
 import org.jetbrains.kotlin.resolve.scopes.receivers.*;
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
 import org.jetbrains.kotlin.types.*;
@@ -219,11 +219,6 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return parentCodegen;
     }
 
-    @NotNull
-    public KotlinTypeMapper getTypeMapper() {
-        return typeMapper;
-    }
-
     @NotNull
     public ObjectLiteralResult generateObjectLiteral(@NotNull KtObjectLiteralExpression literal) {
         KtObjectDeclaration objectDeclaration = literal.getObjectDeclaration();
@@ -1585,7 +1580,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             assert topOfStack == tryWithFinallyBlockStackElement : "Top element of stack doesn't equals processing finally block";
 
             KtTryExpression jetTryExpression = tryWithFinallyBlockStackElement.expression;
-            Label finallyStart = linkedLabel();
+            Label finallyStart = new Label();
             v.mark(finallyStart);
             tryWithFinallyBlockStackElement.addGapLabel(finallyStart);
             addGapLabelsForNestedTryCatchWithoutFinally(state, nestedTryBlocksWithoutFinally, finallyStart);
@@ -2566,19 +2561,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             return intrinsic.toCallable(fd, superCall, resolvedCall, this);
         }
 
-        fd = SamCodegenUtil.resolveSamAdapter(fd);
-
-        if (ArgumentGeneratorKt.shouldInvokeDefaultArgumentsStub(resolvedCall)) {
-            // When we invoke a function with some arguments mapped as defaults,
-            // we later reroute this call to an overridden function in a base class that processes the default arguments.
-            // If the base class is generic, this overridden function can have a different Kotlin signature
-            // (see KT-38681 and related issues).
-            // Here we replace a function with a corresponding overridden function,
-            // and the rest is figured out by argument generation and type mapper.
-            fd = ArgumentGeneratorKt.getFunctionWithDefaultArguments(fd);
-        }
-
-        return typeMapper.mapToCallableMethod(fd, superCall, null, resolvedCall);
+        return typeMapper.mapToCallableMethod(SamCodegenUtil.resolveSamAdapter(fd), superCall, null, resolvedCall);
     }
 
     public void invokeMethodWithArguments(
@@ -2835,7 +2818,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             TypeApproximator approximator = new TypeApproximator(state.getModule().getBuiltIns());
 
             KotlinType approximatedType =
-                    TypeUtils.contains(type, (containedType) -> CapturedTypeConstructorKt.isCaptured(containedType)) ?
+                    CapturedTypeConstructorKt.isCaptured(type) ?
                     (KotlinType) approximator.approximateToSuperType(
                             type, TypeApproximatorConfiguration.InternalTypesApproximation.INSTANCE
                     ) : null;

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

@@ -33,7 +33,10 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.SpecialBuiltinMembers;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
+import org.jetbrains.kotlin.resolve.DescriptorUtils;
+import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.calls.util.UnderscoreUtilKt;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
@@ -67,6 +70,7 @@ import java.io.StringWriter;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isNullableAny;
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.generateBridgeForMainFunctionIfNecessary;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
@@ -83,8 +87,6 @@ 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;
@@ -192,10 +194,6 @@ public class FunctionCodegen {
         if (origin.getOriginKind() == JvmDeclarationOriginKind.SAM_DELEGATION) {
             flags |= ACC_SYNTHETIC;
         }
-        boolean isCompatibilityStubInDefaultImpls = isCompatibilityStubInDefaultImpls(functionDescriptor, methodContext, state.getJvmDefaultMode());
-        if (isCompatibilityStubInDefaultImpls) {
-            flags |= ACC_DEPRECATED;
-        }
 
         if (functionDescriptor.isExternal() && owner instanceof MultifileClassFacadeContext) {
             // Native methods are only defined in facades and do not need package part implementations
@@ -204,13 +202,12 @@ public class FunctionCodegen {
 
         MethodVisitor mv =
                 strategy.wrapMethodVisitor(
-                        newMethod(
-                                origin,
-                                flags,
-                                asmMethod.getName(),
-                                asmMethod.getDescriptor(),
-                                strategy.skipGenericSignature() ? null : jvmSignature.getGenericsSignature(),
-                                getThrownExceptions(functionDescriptor, typeMapper)
+                        newMethod(origin,
+                                  flags,
+                                  asmMethod.getName(),
+                                  asmMethod.getDescriptor(),
+                                  strategy.skipGenericSignature() ? null : jvmSignature.getGenericsSignature(),
+                                  getThrownExceptions(functionDescriptor, typeMapper)
                         ),
                         flags, asmMethod.getName(),
                         asmMethod.getDescriptor()
@@ -218,14 +215,8 @@ public class FunctionCodegen {
 
         recordMethodForFunctionIfAppropriate(functionDescriptor, asmMethod);
 
-        boolean skipNullabilityAnnotations =
-                (flags & ACC_PRIVATE) != 0 || (flags & ACC_SYNTHETIC) != 0 ||
-                InlineClassDescriptorResolver.isSpecializedEqualsMethod(functionDescriptor);
-        generateMethodAnnotationsIfRequired(
-                functionDescriptor, asmMethod, jvmSignature, mv,
-                isCompatibilityStubInDefaultImpls ? Collections.singletonList(JAVA_LANG_DEPRECATED) : Collections.emptyList(),
-                skipNullabilityAnnotations
-        );
+        generateMethodAnnotationsIfRequired(functionDescriptor, asmMethod, jvmSignature, mv);
+
         GenerateJava8ParameterNamesKt.generateParameterNames(functionDescriptor, mv, jvmSignature, state, (flags & ACC_SYNTHETIC) != 0);
 
         if (contextKind != OwnerKind.ERASED_INLINE_CLASS) {
@@ -286,9 +277,7 @@ public class FunctionCodegen {
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull Method asmMethod,
             @NotNull JvmMethodGenericSignature jvmSignature,
-            @NotNull MethodVisitor mv,
-            @NotNull List<String> additionalVisibleAnnotations,
-            boolean skipNullabilityAnnotations
+            @NotNull MethodVisitor mv
     ) {
         FunctionDescriptor annotationsOwner;
         if (shouldHideConstructorDueToInlineClassTypeValueParameters(functionDescriptor)) {
@@ -303,14 +292,10 @@ public class FunctionCodegen {
             annotationsOwner = functionDescriptor;
         }
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
-                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType(), null, additionalVisibleAnnotations);
+        AnnotationCodegen.forMethod(mv, memberCodegen, state)
+                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType());
 
-        generateParameterAnnotations(
-                annotationsOwner, mv, jvmSignature,
-                annotationsOwner.getValueParameters(),
-                memberCodegen, state, skipNullabilityAnnotations
-        );
+        generateParameterAnnotations(annotationsOwner, mv, jvmSignature, memberCodegen, state);
     }
 
     @NotNull
@@ -504,14 +489,25 @@ public class FunctionCodegen {
         return descriptor != null && !InlineUtil.isInlineOrContainingInline(descriptor);
     }
 
+    public static void generateParameterAnnotations(
+            @NotNull FunctionDescriptor functionDescriptor,
+            @NotNull MethodVisitor mv,
+            @NotNull JvmMethodSignature jvmSignature,
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state
+    ) {
+        generateParameterAnnotations(
+                functionDescriptor, mv, jvmSignature, functionDescriptor.getValueParameters(), innerClassConsumer, state
+        );
+    }
+
     public static void generateParameterAnnotations(
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull MethodVisitor mv,
             @NotNull JvmMethodSignature jvmSignature,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @NotNull MemberCodegen<?> memberCodegen,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state
     ) {
         if (isAccessor(functionDescriptor)) return;
 
@@ -521,7 +517,6 @@ public class FunctionCodegen {
 
         Asm7UtilKt.visitAnnotableParameterCount(mv, kotlinParameterTypes.size() - syntheticParameterCount);
 
-        boolean isDefaultImpl = OwnerKind.DEFAULT_IMPLS == memberCodegen.context.getContextKind();
         for (int i = 0; i < kotlinParameterTypes.size(); i++) {
             JvmMethodParameterSignature parameterSignature = kotlinParameterTypes.get(i);
             JvmMethodParameterKind kind = parameterSignature.getKind();
@@ -534,18 +529,13 @@ public class FunctionCodegen {
                     ? iterator.next()
                     : kind == JvmMethodParameterKind.RECEIVER
                       ? JvmCodegenUtil.getDirectMember(functionDescriptor).getExtensionReceiverParameter()
-                      : kind == JvmMethodParameterKind.THIS && isDefaultImpl
-                        ? JvmCodegenUtil.getDirectMember(functionDescriptor).getDispatchReceiverParameter()
-                        : null;
+                      : null;
 
             if (annotated != null) {
+                //noinspection ConstantConditions
                 int parameterIndex = i - syntheticParameterCount;
-                AnnotationCodegen
-                        .forParameter(parameterIndex, mv, memberCodegen, state, skipNullabilityAnnotations)
-                        .genAnnotations(
-                                annotated, parameterSignature.getAsmType(), annotated.getReturnType(), functionDescriptor,
-                                Collections.emptyList()
-                        );
+                AnnotationCodegen.forParameter(parameterIndex, mv, innerClassConsumer, state)
+                        .genAnnotations(annotated, parameterSignature.getAsmType(), annotated.getReturnType());
             }
         }
     }
@@ -617,7 +607,7 @@ public class FunctionCodegen {
                     true, mv,
                     method.getAsmMethod(),
                     method.getOwner().getInternalName(),
-                    true, signature.getReturnType());
+                    true);
             methodEnd = new Label();
         }
         else {
@@ -721,8 +711,10 @@ public class FunctionCodegen {
             @NotNull JvmDefaultMode jvmDefaultMode
     ) {
         return OwnerKind.DEFAULT_IMPLS == context.getContextKind() &&
-            jvmDefaultMode.isCompatibility() &&
-            JvmAnnotationUtilKt.checkIsImplementationCompiledToJvmDefault(functionDescriptor, jvmDefaultMode);
+               JvmAnnotationUtilKt
+                       .isCompiledToJvmDefault(DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(functionDescriptor),
+                                               jvmDefaultMode) &&
+               jvmDefaultMode.isCompatibility();
     }
 
     private static void generateLocalVariableTable(
@@ -858,8 +850,7 @@ public class FunctionCodegen {
             @NotNull Method asmMethod,
             @NotNull String classToDelegateTo,
             int opcode,
-            boolean isInterface,
-            @NotNull Type returnType
+            boolean isInterface
     ) {
         InstructionAdapter iv = new InstructionAdapter(mv);
         Type[] argTypes = asmMethod.getArgumentTypes();
@@ -881,8 +872,7 @@ public class FunctionCodegen {
             paramIndex += argType.getSize();
         }
         iv.visitMethodInsn(opcode, classToDelegateTo, asmMethod.getName(), asmMethod.getDescriptor(), isInterface);
-        StackValue.onStack(asmMethod.getReturnType()).coerceTo(returnType, null, iv);
-        iv.areturn(returnType);
+        iv.areturn(asmMethod.getReturnType());
     }
 
     private static void generateDelegateToStaticErasedVersion(
@@ -921,19 +911,7 @@ public class FunctionCodegen {
             @NotNull String classToDelegateTo,
             boolean isInterfaceMethodCall
     ) {
-        generateDelegateToStaticMethodBody(isStatic, mv, asmMethod, classToDelegateTo, isInterfaceMethodCall, asmMethod.getReturnType());
-    }
-
-
-    private static void generateDelegateToStaticMethodBody(
-            boolean isStatic,
-            @NotNull MethodVisitor mv,
-            @NotNull Method asmMethod,
-            @NotNull String classToDelegateTo,
-            boolean isInterfaceMethodCall,
-            @NotNull Type returnType
-    ) {
-        generateDelegateToMethodBody(isStatic ? 0 : 1, mv, asmMethod, classToDelegateTo, Opcodes.INVOKESTATIC, isInterfaceMethodCall, returnType);
+        generateDelegateToMethodBody(isStatic ? 0 : 1, mv, asmMethod, classToDelegateTo, Opcodes.INVOKESTATIC, isInterfaceMethodCall);
     }
 
     private static boolean needIndexForVar(JvmMethodParameterKind kind) {
@@ -1060,7 +1038,10 @@ 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());
+            KotlinType returnType = handle.getDescriptor().getReturnType();
+            if (returnType != null) {
+                return returnType;
+            }
         }
 
         if (state.getClassBuilderMode().mightBeIncorrectCode) {
@@ -1086,6 +1067,18 @@ public class FunctionCodegen {
         );
     }
 
+    public static boolean isMethodOfAny(@NotNull FunctionDescriptor descriptor) {
+        String name = descriptor.getName().asString();
+        List<ValueParameterDescriptor> parameters = descriptor.getValueParameters();
+        if (parameters.isEmpty()) {
+            return name.equals("hashCode") || name.equals("toString");
+        }
+        else if (parameters.size() == 1 && name.equals("equals")) {
+            return isNullableAny(parameters.get(0).getType());
+        }
+        return false;
+    }
+
     @NotNull
     public static String[] getThrownExceptions(@NotNull FunctionDescriptor function, @NotNull KotlinTypeMapper typeMapper) {
         return ArrayUtil.toStringArray(CollectionsKt.map(
@@ -1457,8 +1450,8 @@ public class FunctionCodegen {
             }
         }
 
-        KotlinType returnValueType = state.getTypeMapper().getReturnValueType(descriptor);
-        StackValue.coerce(delegateTo.getReturnType(), returnValueType, bridge.getReturnType(), bridgeReturnType, iv);
+        KotlinType returnType = descriptor.getReturnType();
+        StackValue.coerce(delegateTo.getReturnType(), returnType, bridge.getReturnType(), bridgeReturnType, iv);
         iv.areturn(bridge.getReturnType());
 
         endVisit(mv, "bridge method", origin);
@@ -1626,7 +1619,7 @@ public class FunctionCodegen {
                                 )
                         );
 
-                        stackValue.put(delegateMethod.getReturnType(), delegateFunction.getReturnType(), iv);
+                        stackValue.put(delegateMethod.getReturnType(), delegatedTo.getReturnType(), iv);
 
                         iv.areturn(delegateMethod.getReturnType());
                     }
@@ -1679,9 +1672,7 @@ public class FunctionCodegen {
 
         if (JvmAnnotationUtilKt.isCompiledToJvmDefault(memberDescriptor, mode)) {
             return (kind != OwnerKind.DEFAULT_IMPLS && !isSynthetic) ||
-                   (kind == OwnerKind.DEFAULT_IMPLS &&
-                    (isSynthetic || //TODO: move synthetic method generation into interface
-                     (mode.isCompatibility() && !JvmAnnotationUtilKt.hasJvmDefaultNoCompatibilityAnnotation(containingDeclaration))));
+                   (kind == OwnerKind.DEFAULT_IMPLS && (isSynthetic || mode.isCompatibility()));
         } else {
             switch (kind) {
                 case DEFAULT_IMPLS: return true;

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

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.KtClassOrObject;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
@@ -45,7 +46,6 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
     private final GenerationState generationState;
     private final KotlinTypeMapper typeMapper;
     private final JvmKotlinType underlyingType;
-    private final boolean isInErasedInlineClass;
 
     public FunctionsFromAnyGeneratorImpl(
             @NotNull KtClassOrObject declaration,
@@ -67,27 +67,23 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
                 typeMapper.mapType(descriptor),
                 InlineClassesUtilsKt.substitutedUnderlyingType(descriptor.getDefaultType())
         );
-        this.isInErasedInlineClass = fieldOwnerContext.getContextKind() == OwnerKind.ERASED_INLINE_CLASS;
     }
 
     @Override
     protected void generateToStringMethod(
-            @NotNull FunctionDescriptor function,
-            @NotNull List<? extends PropertyDescriptor> properties
+            @NotNull FunctionDescriptor function, @NotNull List<? extends PropertyDescriptor> properties
     ) {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String toStringMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), toStringMethodName, getToStringDesc(), null, null);
 
-        if (!isInErasedInlineClass && classDescriptor.isInline()) {
+        if (fieldOwnerContext.getContextKind() != OwnerKind.ERASED_INLINE_CLASS && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
 
-        if (!isInErasedInlineClass) {
-            visitEndForAnnotationVisitor(mv.visitAnnotation(Type.getDescriptor(NotNull.class), false));
-        }
+        visitEndForAnnotationVisitor(mv.visitAnnotation(Type.getDescriptor(NotNull.class), false));
 
         if (!generationState.getClassBuilderMode().generateBodies) {
             FunctionCodegen.endVisit(mv, toStringMethodName, getDeclaration());
@@ -148,7 +144,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         String hashCodeMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), hashCodeMethodName, getHashCodeDesc(), null, null);
 
-        if (!isInErasedInlineClass && classDescriptor.isInline()) {
+        if (fieldOwnerContext.getContextKind() != OwnerKind.ERASED_INLINE_CLASS && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
@@ -217,14 +213,15 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         String equalsMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), equalsMethodName, getEqualsDesc(), null, null);
 
-        if (!isInErasedInlineClass && classDescriptor.isInline()) {
+        boolean isErasedInlineClassKind = fieldOwnerContext.getContextKind() == OwnerKind.ERASED_INLINE_CLASS;
+        if (!isErasedInlineClassKind && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
 
-        if (!isInErasedInlineClass) {
-            visitEndForAnnotationVisitor(mv.visitParameterAnnotation(0, Type.getDescriptor(Nullable.class), false));
-        }
+        visitEndForAnnotationVisitor(
+                mv.visitParameterAnnotation(isErasedInlineClassKind ? 1 : 0, Type.getDescriptor(Nullable.class), false)
+        );
 
         if (!generationState.getClassBuilderMode().generateBodies) {
             FunctionCodegen.endVisit(mv, equalsMethodName, getDeclaration());

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2000-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.
  */
 
@@ -68,6 +68,7 @@ import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isNonGenericToArray;
 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.codegen.inline.InlineCodegenUtilsKt.initDefaultSourceMappingIfNeeded;
 import static org.jetbrains.kotlin.load.java.JvmAbi.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_GET;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_SET;
@@ -227,7 +228,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         v.visitSource(myClass.getContainingKtFile().getName(), null);
 
-        initDefaultSourceMappingIfNeeded();
+        initDefaultSourceMappingIfNeeded(context, this, state);
 
         writeEnclosingMethod();
 
@@ -771,12 +772,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         if (isNonCompanionObject(descriptor)) {
             StackValue.Field field = StackValue.createSingletonViaInstance(descriptor, typeMapper, INSTANCE_FIELD);
-            FieldVisitor fv = v.newField(
-                    JvmDeclarationOriginKt.OtherOriginFromPure(myClass),
-                    ACC_PUBLIC | ACC_STATIC | ACC_FINAL,
-                    field.name, field.type.getDescriptor(), null, null
-            );
-            AnnotationCodegen.forField(fv, this, state).visitAnnotation(Type.getDescriptor(NotNull.class), false).visitEnd();
+            v.newField(JvmDeclarationOriginKt.OtherOriginFromPure(myClass),
+                       ACC_PUBLIC | ACC_STATIC | ACC_FINAL,
+                       field.name, field.type.getDescriptor(), null, null);
+
             return;
         }
 
@@ -818,13 +817,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             fieldAccessFlags |= ACC_SYNTHETIC;
         }
         StackValue.Field field = StackValue.singleton(companionObjectDescriptor, typeMapper);
-        FieldVisitor fv = v.newField(
-                JvmDeclarationOriginKt.OtherOrigin(companionObject == null ? myClass.getPsiOrParent() : companionObject),
-                fieldAccessFlags, field.name, field.type.getDescriptor(), null, null
-        );
-        AnnotationCodegen.forField(fv, this, state).visitAnnotation(Type.getDescriptor(NotNull.class), false).visitEnd();
+        FieldVisitor fv = v.newField(JvmDeclarationOriginKt.OtherOrigin(companionObject == null ? myClass.getPsiOrParent() : companionObject),
+                                     fieldAccessFlags, field.name, field.type.getDescriptor(), null, null);
         if (fieldShouldBeDeprecated) {
-            AnnotationCodegen.forField(fv, this, state).visitAnnotation(Type.getDescriptor(Deprecated.class), true).visitEnd();
+            AnnotationCodegen.forField(fv, this, state).visitAnnotation("Ljava/lang/Deprecated;", true).visitEnd();
         }
     }
 

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

@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.util.ArrayUtil
-import org.jetbrains.kotlin.util.findImplementationFromInterface
+import org.jetbrains.kotlin.backend.common.bridges.findImplementationFromInterface
+import org.jetbrains.kotlin.backend.common.bridges.firstSuperMethodFromKotlin
 import org.jetbrains.kotlin.codegen.context.ClassContext
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.codegen.state.JvmMethodExceptionTypes
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
 import org.jetbrains.kotlin.psi.KtPureClassOrObject
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.util.firstSuperMethodFromKotlin
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes.*
 
@@ -168,7 +167,7 @@ class InterfaceImplBodyCodegen(
                 name: String,
                 desc: String,
                 signature: String?,
-                exceptions: JvmMethodExceptionTypes
+                exceptions: Array<out String>?
         ): MethodVisitor {
             if (shouldCount) {
                 isAnythingGenerated = true

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

@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyD
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefault
 import org.jetbrains.kotlin.resolve.jvm.annotations.hasPlatformDependentAnnotation
-import org.jetbrains.kotlin.util.findImplementationFromInterface
-import org.jetbrains.kotlin.util.findInterfaceImplementation
 
 class DescriptorBasedFunctionHandleForJvm(
     descriptor: FunctionDescriptor,

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

@@ -24,8 +24,6 @@ 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,
@@ -98,14 +96,6 @@ 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,

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

@@ -13,9 +13,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
 import org.jetbrains.kotlin.codegen.context.*;
+import org.jetbrains.kotlin.codegen.inline.DefaultSourceMapper;
 import org.jetbrains.kotlin.codegen.inline.NameGenerator;
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeParametersUsages;
-import org.jetbrains.kotlin.codegen.inline.SourceMapper;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.codegen.state.TypeMapperUtilsKt;
@@ -88,8 +88,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     private NameGenerator inlineNameGenerator;
     private boolean jvmAssertFieldGenerated;
 
-    private boolean alwaysWriteSourceMap;
-    private SourceMapper sourceMapper;
+    private DefaultSourceMapper sourceMapper;
 
     public MemberCodegen(
             @NotNull GenerationState state,
@@ -183,8 +182,8 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
 
         writeInnerClasses();
 
-        if (alwaysWriteSourceMap || (sourceMapper != null && !sourceMapper.isTrivial())) {
-            v.visitSMAP(getOrCreateSourceMapper(), !state.getLanguageVersionSettings().supportsFeature(LanguageFeature.CorrectSourceMappingSyntax));
+        if (sourceMapper != null) {
+            v.visitSMAP(sourceMapper, !state.getLanguageVersionSettings().supportsFeature(LanguageFeature.CorrectSourceMappingSyntax));
         }
 
         v.done();
@@ -468,7 +467,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);
+                          null, Visibilities.PRIVATE);
         return clInit;
     }
 
@@ -680,7 +679,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         }
 
         iv.aconst(property.getName().asString());
-        CallableReferenceUtilKt.generatePropertyReferenceSignature(iv, property, state);
+        CallableReferenceUtilKt.generateCallableReferenceSignature(iv, property, state);
         superCtorArgTypes.add(JAVA_STRING_TYPE);
         superCtorArgTypes.add(JAVA_STRING_TYPE);
 
@@ -723,27 +722,14 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     }
 
     @NotNull
-    public SourceMapper getOrCreateSourceMapper() {
+    public DefaultSourceMapper getOrCreateSourceMapper() {
         if (sourceMapper == null) {
             // note: this is used in InlineCodegen and the element is always physical (KtElement) there
-            sourceMapper = new SourceMapper(SourceInfo.Companion.createFromPsi((KtElement)element, getClassName()));
+            sourceMapper = new DefaultSourceMapper(SourceInfo.Companion.createInfo((KtElement)element, getClassName()));
         }
         return sourceMapper;
     }
 
-    protected void initDefaultSourceMappingIfNeeded() {
-        if (state.isInlineDisabled()) return;
-
-        CodegenContext parentContext = context.getParentContext();
-        while (parentContext != null) {
-            if (parentContext.isInlineMethodContext()) {
-                alwaysWriteSourceMap = true;
-                return;
-            }
-            parentContext = parentContext.getParentContext();
-        }
-    }
-
     protected void generateConstInstance(@NotNull Type thisAsmType, @NotNull Type fieldAsmType) {
         v.newField(
                 JvmDeclarationOriginKt.OtherOriginFromPure(element), ACC_STATIC | ACC_FINAL | ACC_PUBLIC, JvmAbi.INSTANCE_FIELD,

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

@@ -53,8 +53,7 @@ internal class ObjectSuperCallArgumentGenerator(
             valueArgumentsByIndex: List<ResolvedValueArgument>,
             actualArgs: List<ResolvedValueArgument>,
             calleeDescriptor: CallableDescriptor?
-    ): DefaultCallArgs =
-        super.generate(valueArgumentsByIndex, valueArgumentsByIndex, calleeDescriptor)
+    ): DefaultCallArgs = super.generate(valueArgumentsByIndex, valueArgumentsByIndex, calleeDescriptor)
 
     public override fun generateExpression(i: Int, argument: ExpressionValueArgument) {
         generateSuperCallArgument(i)

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.codegen.state.JvmMethodExceptionTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.org.objectweb.asm.*
 import org.jetbrains.org.objectweb.asm.tree.*
@@ -43,7 +42,7 @@ class OriginCollectingClassBuilderFactory(private val builderMode: ClassBuilderM
                 name: String,
                 desc: String,
                 signature: String?,
-                exceptions: JvmMethodExceptionTypes
+                exceptions: Array<out String>?
         ): MethodVisitor {
             val methodNode = super.newMethod(origin, access, name, desc, signature, exceptions) as MethodNode
             origins[methodNode] = origin

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

@@ -13,13 +13,12 @@ enum class OwnerKind {
     PACKAGE,
     IMPLEMENTATION,
     DEFAULT_IMPLS,
-    ERASED_INLINE_CLASS,
-    PROPERTY_REFERENCE_SIGNATURE;
+    ERASED_INLINE_CLASS;
 
     companion object {
         fun getMemberOwnerKind(descriptor: DeclarationDescriptor): OwnerKind = when (descriptor) {
-            is PackageFragmentDescriptor -> PACKAGE
-            is ClassDescriptor -> IMPLEMENTATION
+            is PackageFragmentDescriptor -> OwnerKind.PACKAGE
+            is ClassDescriptor -> OwnerKind.IMPLEMENTATION
             else -> throw AssertionError("Unexpected declaration container: $this")
         }
     }

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.fileClasses.JvmFileClassUtilKt;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -51,7 +52,6 @@ import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.*;
 import static org.jetbrains.kotlin.diagnostics.Errors.EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND;
-import static org.jetbrains.kotlin.fileClasses.JvmFileClassUtilKt.isTopLevelInJvmMultifileClass;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.isInterface;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.K_PROPERTY_TYPE;
@@ -135,10 +135,10 @@ public class PropertyCodegen {
 
         boolean isDefaultGetterAndSetter = isDefaultAccessor(getter) && isDefaultAccessor(setter);
 
-        if (isAccessorNeeded(descriptor, getter, isDefaultGetterAndSetter)) {
+        if (isAccessorNeeded(declaration, descriptor, getter, isDefaultGetterAndSetter)) {
             generateGetter(descriptor, getter);
         }
-        if (isAccessorNeeded(descriptor, setter, isDefaultGetterAndSetter)) {
+        if (isAccessorNeeded(declaration, descriptor, setter, isDefaultGetterAndSetter)) {
             generateSetter(descriptor, setter);
         }
     }
@@ -167,40 +167,17 @@ public class PropertyCodegen {
         generateSyntheticMethodIfNeeded(descriptor, isBackingFieldOwner);
     }
 
-    private boolean isAccessorNeeded(
-            @NotNull PropertyDescriptor descriptor,
-            @Nullable KtPropertyAccessor accessor,
-            boolean isDefaultGetterAndSetter
-    ) {
-        return isAccessorNeeded(descriptor, accessor, isDefaultGetterAndSetter, kind);
-    }
-
-    public static boolean isReferenceablePropertyWithGetter(@NotNull PropertyDescriptor descriptor) {
-        PsiElement psiElement = DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
-        KtDeclaration ktDeclaration = psiElement instanceof KtDeclaration ? (KtDeclaration) psiElement : null;
-        if (ktDeclaration instanceof KtProperty) {
-            KtProperty ktProperty = (KtProperty) ktDeclaration;
-            boolean isDefaultGetterAndSetter =
-                    isDefaultAccessor(ktProperty.getGetter()) && isDefaultAccessor(ktProperty.getSetter());
-            return isAccessorNeeded(descriptor, ktProperty.getGetter(), isDefaultGetterAndSetter, OwnerKind.IMPLEMENTATION);
-        } else if (ktDeclaration instanceof KtParameter) {
-            return isAccessorNeeded(descriptor, null, true, OwnerKind.IMPLEMENTATION);
-        } else {
-            return isAccessorNeeded(descriptor, null, false, OwnerKind.IMPLEMENTATION);
-        }
-    }
-
     /**
      * Determines if it's necessary to generate an accessor to the property, i.e. if this property can be referenced via getter/setter
      * for any reason
      *
      * @see JvmCodegenUtil#couldUseDirectAccessToProperty
      */
-    private static boolean isAccessorNeeded(
+    private boolean isAccessorNeeded(
+            @NotNull KtProperty declaration,
             @NotNull PropertyDescriptor descriptor,
             @Nullable KtPropertyAccessor accessor,
-            boolean isDefaultGetterAndSetter,
-            OwnerKind kind
+            boolean isDefaultGetterAndSetter
     ) {
         if (isConstOrHasJvmFieldAnnotation(descriptor)) return false;
 
@@ -210,7 +187,7 @@ public class PropertyCodegen {
         if (kind == OwnerKind.DEFAULT_IMPLS && isDefaultAccessor) return false;
 
         // Delegated or extension properties can only be referenced via accessors
-        if (descriptor.isDelegated() || descriptor.getExtensionReceiverParameter() != null) return true;
+        if (declaration.hasDelegate() || declaration.getReceiverTypeReference() != null) return true;
 
         // Companion object properties should have accessors for non-private properties because these properties can be referenced
         // via getter/setter. But these accessors getter/setter are not required for private properties that have a default getter
@@ -224,7 +201,7 @@ public class PropertyCodegen {
         }
 
         // Non-const properties from multifile classes have accessors regardless of visibility
-        if (isTopLevelInJvmMultifileClass(descriptor)) return true;
+        if (isTopLevelPropertyInMultifileClass(declaration, descriptor)) return true;
 
         // Private class properties have accessors only in cases when those accessors are non-trivial
         if (Visibilities.isPrivate(descriptor.getVisibility())) {
@@ -238,14 +215,17 @@ public class PropertyCodegen {
             return !isDefaultAccessor;
         }
 
-        // Non-public API (private and internal) primary vals of inline classes don't have getter
-        if (InlineClassesUtilsKt.isUnderlyingPropertyOfInlineClass(descriptor) && !descriptor.getVisibility().isPublicAPI()) {
-            return false;
-        }
-
         return true;
     }
 
+    private static boolean isTopLevelPropertyInMultifileClass(
+            @NotNull KtProperty declaration,
+            @NotNull PropertyDescriptor descriptor
+    ) {
+        return descriptor.getContainingDeclaration() instanceof PackageFragmentDescriptor &&
+               JvmFileClassUtilKt.isInsideJvmMultifileClassFile(declaration);
+    }
+
     private static boolean areAccessorsNeededForPrimaryConstructorProperty(
             @NotNull PropertyDescriptor descriptor,
             @NotNull OwnerKind kind
@@ -336,8 +316,11 @@ public class PropertyCodegen {
             return;
         }
 
+        @SuppressWarnings("deprecation")
+        boolean isDelegate = descriptor.isDelegated();
+
         Object defaultValue;
-        if (descriptor.isDelegated()) {
+        if (isDelegate) {
             defaultValue = null;
         }
         else if (Boolean.TRUE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor))) {
@@ -353,7 +336,7 @@ public class PropertyCodegen {
             return;
         }
 
-        generateBackingField(descriptor, descriptor.isDelegated(), defaultValue, isBackingFieldOwner);
+        generateBackingField(descriptor, isDelegate, defaultValue, isBackingFieldOwner);
     }
 
     // Annotations on properties are stored in bytecode on an empty synthetic method. This way they're still
@@ -434,13 +417,7 @@ public class PropertyCodegen {
             );
 
             if (annotatedField != null) {
-                // Don't emit nullability annotations for backing field if:
-                // - backing field is synthetic;
-                // - property is lateinit (since corresponding field is actually nullable).
-                boolean skipNullabilityAnnotations =
-                        (modifiers & ACC_SYNTHETIC) != 0 ||
-                        propertyDescriptor.isLateInit();
-                AnnotationCodegen.forField(fv, memberCodegen, state, skipNullabilityAnnotations)
+                AnnotationCodegen.forField(fv, memberCodegen, state)
                         .genAnnotations(annotatedField, type, propertyDescriptor.getType());
             }
         }
@@ -518,7 +495,9 @@ public class PropertyCodegen {
 
         FunctionGenerationStrategy strategy;
         if (accessor == null || !accessor.hasBody()) {
-            if (descriptor.getCorrespondingProperty().isDelegated()) {
+            @SuppressWarnings("deprecation")
+            boolean isDelegated = descriptor.getCorrespondingProperty().isDelegated();
+            if (isDelegated) {
                 strategy = new DelegatedPropertyAccessorStrategy(state, descriptor);
             }
             else {

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

@@ -118,7 +118,7 @@ class PropertyReferenceCodegen(
                 aconst(target.name.asString())
             }
             generateMethod("property reference getSignature", ACC_PUBLIC, method("getSignature", JAVA_STRING_TYPE)) {
-                generatePropertyReferenceSignature(this, target, state)
+                generateCallableReferenceSignature(this, target, state)
             }
             generateMethod("property reference getOwner", ACC_PUBLIC, method("getOwner", K_DECLARATION_CONTAINER_TYPE)) {
                 generateCallableReferenceDeclarationContainer(this, target, state)
@@ -148,7 +148,7 @@ class PropertyReferenceCodegen(
             if (isOptimizedPropertyReferenceSupertype(superAsmType)) {
                 generateCallableReferenceDeclarationContainerClass(this, target, state)
                 aconst(target.name.asString())
-                generatePropertyReferenceSignature(this, target, state)
+                generateCallableReferenceSignature(this, target, state)
                 aconst(getCallableReferenceTopLevelFlag(target))
                 superCtorArgTypes.add(JAVA_CLASS_TYPE)
                 superCtorArgTypes.add(JAVA_STRING_TYPE)

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

@@ -27,41 +27,22 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils;
 import org.jetbrains.kotlin.resolve.sam.SamConversionResolverImplKt;
 import org.jetbrains.kotlin.types.KotlinType;
-import org.jetbrains.kotlin.types.KotlinTypeKt;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 public class SamType {
     @Nullable
     public static SamType createByValueParameter(@NotNull ValueParameterDescriptor valueParameter) {
-        KotlinType singleArgumentType;
-        KotlinType originalSingleArgumentType;
-        KotlinType varargElementType = valueParameter.getVarargElementType();
-        if (varargElementType != null) {
-            singleArgumentType = varargElementType;
-            originalSingleArgumentType = valueParameter.getOriginal().getVarargElementType();
-            assert originalSingleArgumentType != null :
-                    "Value parameter and original value parameter have inconsistent varargs: " +
-                    valueParameter + "; " + valueParameter.getOriginal();
-        } else {
-            singleArgumentType = valueParameter.getType();
-            originalSingleArgumentType = valueParameter.getOriginal().getType();
-        }
-
-        if (KotlinTypeKt.isError(singleArgumentType) || KotlinTypeKt.isError(originalSingleArgumentType)) {
-            return null;
-        }
-
         KotlinType originalTypeToUse =
                 // This can be true in case when the value parameter is in the method of a generic type with out-projection.
                 // We approximate Inv<Captured#1> to Nothing, while Inv itself can be a SAM interface safe to call here
                 // (see testData genericSamProjectedOut.kt for details)
-                KotlinBuiltIns.isNothing(singleArgumentType)
+                KotlinBuiltIns.isNothing(valueParameter.getType())
                 // In such a case we can't have a proper supertype since wildcards are not allowed there,
                 // so we use Nothing arguments instead that leads to a raw type used for a SAM wrapper.
                 // See org.jetbrains.kotlin.codegen.state.KotlinTypeMapper#writeGenericType to understand how
                 // raw types and Nothing arguments relate.
-                ? TypeUtilsKt.replaceArgumentsWithNothing(originalSingleArgumentType)
-                : singleArgumentType;
+                ? TypeUtilsKt.replaceArgumentsWithNothing(valueParameter.getOriginal().getType())
+                : valueParameter.getType();
 
         return create(TypeMapperUtilsKt.removeExternalProjections(originalTypeToUse));
     }

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

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.codegen;
 import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
-import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
@@ -33,7 +32,6 @@ import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
-import org.jetbrains.kotlin.resolve.scopes.MemberScope;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
@@ -44,7 +42,6 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 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.resolve.jvm.AsmTypes.*;
@@ -90,7 +87,7 @@ public class SamWrapperCodegen {
 
         boolean isKotlinFunInterface = !(samType.getClassDescriptor() instanceof JavaClassDescriptor);
 
-        ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
+        ClassDescriptor classDescriptor = new ClassDescriptorImpl(
                 samType.getClassDescriptor().getContainingDeclaration(),
                 fqName.shortName(),
                 Modality.FINAL,
@@ -100,8 +97,6 @@ public class SamWrapperCodegen {
                 /* isExternal = */ false,
                 LockBasedStorageManager.NO_LOCKS
         );
-        classDescriptor.initialize(MemberScope.Empty.INSTANCE, Collections.emptySet(), null);
-
         // e.g. compare(T, T)
         SimpleFunctionDescriptor erasedInterfaceFunction = samType.getOriginalAbstractMethod().copy(
                 classDescriptor,
@@ -140,17 +135,12 @@ public class SamWrapperCodegen {
                     null);
 
         generateConstructor(asmType, functionAsmType, cv);
-
-        ClassContext context = state.getRootContext().intoClass(classDescriptor, OwnerKind.IMPLEMENTATION, state);
-        FunctionCodegen functionCodegen = new FunctionCodegen(context, cv, state, parentCodegen);
-        generateMethod(asmType, functionAsmType, erasedInterfaceFunction, functionType, functionCodegen);
+        generateMethod(asmType, functionAsmType, cv, erasedInterfaceFunction, functionType);
 
         if (isKotlinFunInterface) {
             generateGetFunctionDelegate(cv, asmType, functionAsmType);
             generateEquals(cv, asmType, functionAsmType, samAsmType);
             generateHashCode(cv, asmType, functionAsmType);
-
-            generateDelegatesToDefaultImpl(asmType, classDescriptor, samType.getClassDescriptor(), functionCodegen, state);
         }
 
         cv.done();
@@ -181,22 +171,25 @@ public class SamWrapperCodegen {
     }
 
     private void generateMethod(
-            @NotNull Type ownerType,
-            @NotNull Type functionType,
-            @NotNull SimpleFunctionDescriptor erasedInterfaceFunction,
-            @NotNull KotlinType functionKotlinType,
-            @NotNull FunctionCodegen functionCodegen
+            Type ownerType,
+            Type functionType,
+            ClassBuilder cv,
+            SimpleFunctionDescriptor erasedInterfaceFunction,
+            KotlinType functionJetType
     ) {
-        FunctionDescriptor invokeFunction = functionKotlinType.getMemberScope().getContributedFunctions(
-                OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND
-        ).iterator().next().getOriginal();
+        // using root context to avoid creating ClassDescriptor and everything else
+        FunctionCodegen codegen = new FunctionCodegen(state.getRootContext().intoClass(
+                (ClassDescriptor) erasedInterfaceFunction.getContainingDeclaration(), OwnerKind.IMPLEMENTATION, state), cv, state, parentCodegen);
+
+        FunctionDescriptor invokeFunction =
+                functionJetType.getMemberScope().getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next().getOriginal();
         StackValue functionField = StackValue.field(functionType, ownerType, FUNCTION_FIELD_NAME, false, StackValue.none());
-        functionCodegen.genSamDelegate(erasedInterfaceFunction, invokeFunction, functionField);
+        codegen.genSamDelegate(erasedInterfaceFunction, invokeFunction, functionField);
 
         // generate sam bridges
         // TODO: erasedInterfaceFunction is actually not an interface function, but function in generated class
         SimpleFunctionDescriptor originalInterfaceErased = samType.getOriginalAbstractMethod();
-        ClosureCodegen.generateBridgesForSAM(originalInterfaceErased, erasedInterfaceFunction, functionCodegen);
+        ClosureCodegen.generateBridgesForSAM(originalInterfaceErased, erasedInterfaceFunction, codegen);
     }
 
     private static void generateEquals(
@@ -255,31 +248,6 @@ public class SamWrapperCodegen {
         FunctionCodegen.endVisit(iv, "getFunctionDelegate of SAM wrapper");
     }
 
-    public static void generateDelegatesToDefaultImpl(
-            @NotNull Type asmType,
-            @NotNull ClassDescriptor classDescriptor,
-            @NotNull ClassDescriptor funInterface,
-            @NotNull FunctionCodegen functionCodegen,
-            @NotNull GenerationState state
-    ) {
-        JvmKotlinType receiverType = new JvmKotlinType(asmType, classDescriptor.getDefaultType());
-
-        for (DeclarationDescriptor descriptor : DescriptorUtils.getAllDescriptors(funInterface.getDefaultType().getMemberScope())) {
-            if (!(descriptor instanceof CallableMemberDescriptor)) continue;
-            CallableMemberDescriptor member = (CallableMemberDescriptor) descriptor;
-            if (member.getModality() == Modality.ABSTRACT ||
-                Visibilities.isPrivate(member.getVisibility()) ||
-                member.getVisibility() == Visibilities.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
-            ).entrySet()) {
-                ClassBodyCodegen.generateDelegationToDefaultImpl(entry.getKey(), entry.getValue(), receiverType, functionCodegen, state, false);
-            }
-        }
-    }
-
     @NotNull
     private FqName getWrapperName(
             @NotNull KtFile containingFile,

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2000-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.
  */
 

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

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.codegen
 import com.intellij.psi.PsiElement
 import com.intellij.util.containers.LinkedMultiMap
 import com.intellij.util.containers.MultiMap
-import org.jetbrains.kotlin.codegen.state.JvmMethodExceptionTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ConflictingJvmDeclarationsData
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.MemberKind
@@ -64,7 +63,7 @@ abstract class SignatureCollectingClassBuilderFactory(
             return super.newField(origin, access, name, desc, signature, value)
         }
 
-        override fun newMethod(origin: JvmDeclarationOrigin, access: Int, name: String, desc: String, signature: String?, exceptions: JvmMethodExceptionTypes): MethodVisitor {
+        override fun newMethod(origin: JvmDeclarationOrigin, access: Int, name: String, desc: String, signature: String?, exceptions: Array<out String>?): MethodVisitor {
             signatures.putValue(RawSignature(name, desc, MemberKind.METHOD), origin)
             if (!shouldGenerate(origin)) {
                 return AbstractClassBuilder.EMPTY_METHOD_VISITOR

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

@@ -21,26 +21,28 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 
-data class SourceInfo(
-    val sourceFileName: String?,
-    val pathOrCleanFQN: String,
-    val linesInFile: Int
-) {
+data class SourceInfo(val source: String, val pathOrCleanFQN: String, val linesInFile: Int) {
 
     companion object {
-        fun createFromPsi(element: KtElement?, internalClassName: String): SourceInfo {
+        fun createInfo(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('$')
 
-            val fileName = element.containingKtFile.name
-            return SourceInfo(fileName, cleanedClassFqName, lineNumbers)
+            return SourceInfo(element.containingKtFile.name, 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/binding/CodegenAnnotatingVisitor.java

@@ -42,7 +42,10 @@ import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
-import org.jetbrains.kotlin.resolve.calls.model.*;
+import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument;
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
+import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.tower.NewResolvedCallImpl;
 import org.jetbrains.kotlin.resolve.calls.tower.NewVariableAsFunctionResolvedCallImpl;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
@@ -796,16 +799,12 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         CallableDescriptor descriptor = call.getResultingDescriptor();
         if (!(descriptor instanceof FunctionDescriptor)) return;
 
-        recordSamValuesForNewInference(call);
+        recordSamValueForNewInference(call);
         recordSamConstructorIfNeeded(expression, call);
-        recordSamValuesForOldInference(call, descriptor);
-    }
 
-    private void recordSamValuesForOldInference(ResolvedCall<?> call, CallableDescriptor descriptor) {
         FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter((FunctionDescriptor) descriptor);
         if (original == null) return;
 
-        // TODO we can just record SAM_VALUE on relevant value arguments as we do in recordSamValuesForNewInference
         List<ValueParameterDescriptor> valueParametersWithSAMConversion = new SmartList<>();
         for (ValueParameterDescriptor valueParameter : original.getValueParameters()) {
             ValueParameterDescriptor adaptedParameter = descriptor.getValueParameters().get(valueParameter.getIndex());
@@ -815,40 +814,30 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         writeSamValueForValueParameters(valueParametersWithSAMConversion, call.getValueArgumentsByIndex());
     }
 
-    private void recordSamValuesForNewInference(@NotNull ResolvedCall<?> call) {
-        NewResolvedCallImpl<?> newResolvedCall = getNewResolvedCallForCallWithPossibleSamConversions(call);
+    private void recordSamValueForNewInference(@NotNull ResolvedCall<?> call) {
+        NewResolvedCallImpl<?> newResolvedCall = null;
+        if (call instanceof NewVariableAsFunctionResolvedCallImpl) {
+            newResolvedCall = ((NewVariableAsFunctionResolvedCallImpl) call).getFunctionCall();
+        }
+        else if(call instanceof NewResolvedCallImpl) {
+            newResolvedCall = (NewResolvedCallImpl<?>) call;
+        }
         if (newResolvedCall == null) return;
 
+        List<ValueParameterDescriptor> valueParametersWithSAMConversion = new SmartList<>();
         Map<ValueParameterDescriptor, ResolvedValueArgument> arguments = newResolvedCall.getValueArguments();
         for (ValueParameterDescriptor valueParameter : arguments.keySet()) {
             ResolvedValueArgument argument = arguments.get(valueParameter);
-            if (argument instanceof ExpressionValueArgument) {
-                ValueArgument valueArgument = ((ExpressionValueArgument) argument).getValueArgument();
-                if (valueArgument != null && newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) != null) {
-                    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(valueParameter, valueArgument);
-                    }
-                }
-            }
-        }
-    }
 
-    @Nullable
-    private static NewResolvedCallImpl<?> getNewResolvedCallForCallWithPossibleSamConversions(@NotNull ResolvedCall<?> call) {
-        if (call instanceof NewVariableAsFunctionResolvedCallImpl) {
-            return ((NewVariableAsFunctionResolvedCallImpl) call).getFunctionCall();
-        }
-        else if (call instanceof NewResolvedCallImpl) {
-            return (NewResolvedCallImpl<?>) call;
-        }
-        else {
-            return null;
+            if (!(argument instanceof ExpressionValueArgument)) continue;
+            ValueArgument valueArgument = ((ExpressionValueArgument) argument).getValueArgument();
+
+            if (valueArgument == null || newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) == null) continue;
+
+            valueParametersWithSAMConversion.add(valueParameter);
         }
+        writeSamValueForValueParameters(valueParametersWithSAMConversion, newResolvedCall.getValueArgumentsByIndex());
+
     }
 
     private void writeSamValueForValueParameters(
@@ -865,24 +854,13 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
             assert resolvedValueArgument instanceof ExpressionValueArgument : resolvedValueArgument;
             ValueArgument valueArgument = ((ExpressionValueArgument) resolvedValueArgument).getValueArgument();
             assert valueArgument != null;
-            recordSamTypeOnArgumentExpression(samType, valueArgument);
+            KtExpression argumentExpression = valueArgument.getArgumentExpression();
+            assert argumentExpression != null : valueArgument.asElement().getText();
+
+            bindingTrace.record(CodegenBinding.SAM_VALUE, argumentExpression, samType);
         }
     }
 
-    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();
-
-        bindingTrace.record(CodegenBinding.SAM_VALUE, argumentExpression, samType);
-    }
-
     @Override
     public void visitSuperTypeCallEntry(@NotNull KtSuperTypeCallEntry call) {
         // Closures in super type constructor calls for anonymous objects are created in outer context
@@ -964,7 +942,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         if (!(operationDescriptor instanceof FunctionDescriptor)) return;
 
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, bindingContext);
-        if (resolvedCall != null) recordSamValuesForNewInference(resolvedCall);
+        if (resolvedCall != null) recordSamValueForNewInference(resolvedCall);
 
         FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter((FunctionDescriptor) operationDescriptor);
         if (original == null) return;
@@ -989,7 +967,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         if (!(operationDescriptor instanceof FunctionDescriptor)) return;
 
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, bindingContext);
-        if (resolvedCall != null) recordSamValuesForNewInference(resolvedCall);
+        if (resolvedCall != null) recordSamValueForNewInference(resolvedCall);
 
         boolean isSetter = operationDescriptor.getName().asString().equals("set");
         FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter((FunctionDescriptor) operationDescriptor);

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

@@ -168,15 +168,11 @@ private fun isTopLevelCallableReference(descriptor: CallableDescriptor): Boolean
 internal fun getCallableReferenceTopLevelFlag(descriptor: CallableDescriptor): Int =
     if (isTopLevelCallableReference(descriptor)) 1 else 0
 
-internal fun generateFunctionReferenceSignature(iv: InstructionAdapter, callable: CallableDescriptor, state: GenerationState) {
+internal fun generateCallableReferenceSignature(iv: InstructionAdapter, callable: CallableDescriptor, state: GenerationState) {
     iv.aconst(getSignatureString(callable, state))
 }
 
-internal fun generatePropertyReferenceSignature(iv: InstructionAdapter, callable: CallableDescriptor, state: GenerationState) {
-    iv.aconst(getSignatureString(callable, state, isPropertySignature = true))
-}
-
-private fun getSignatureString(callable: CallableDescriptor, state: GenerationState, isPropertySignature: Boolean = false): String {
+private fun getSignatureString(callable: CallableDescriptor, state: GenerationState): String {
     if (callable is LocalVariableDescriptor) {
         val asmType = state.bindingContext.get(CodegenBinding.DELEGATED_PROPERTY_METADATA_OWNER, callable)
             ?: throw AssertionError("No delegated property metadata owner for $callable")
@@ -202,13 +198,10 @@ private fun getSignatureString(callable: CallableDescriptor, state: GenerationSt
         else -> error("Unsupported callable reference: $callable")
     }
     val declaration = DescriptorUtils.unwrapFakeOverride(accessor).original
-    val method = when {
-        callable.containingDeclaration.isInlineClass() && !declaration.isGetterOfUnderlyingPropertyOfInlineClass() ->
+    val method =
+        if (callable.containingDeclaration.isInlineClass() && !declaration.isGetterOfUnderlyingPropertyOfInlineClass())
             state.typeMapper.mapSignatureForInlineErasedClassSkipGeneric(declaration).asmMethod
-        isPropertySignature ->
-            state.typeMapper.mapPropertyReferenceSignature(declaration)
-        else ->
+        else
             state.typeMapper.mapAsmMethod(declaration)
-    }
     return method.name + method.descriptor
-}
+}

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

@@ -1,6 +1,17 @@
 /*
- * 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.
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 package org.jetbrains.kotlin.codegen

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

@@ -60,8 +60,6 @@ import org.jetbrains.org.objectweb.asm.Opcodes.*
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.commons.Method
-import org.jetbrains.org.objectweb.asm.tree.LabelNode
-import java.util.*
 
 fun generateIsCheck(
     v: InstructionAdapter,
@@ -590,7 +588,7 @@ private fun generateLambdaForRunSuspend(
 
     lambdaBuilder.newField(
         JvmDeclarationOrigin.NO_ORIGIN,
-        ACC_PRIVATE or ACC_FINAL or ACC_SYNTHETIC,
+        ACC_PRIVATE or ACC_FINAL,
         "args",
         ARRAY_OF_STRINGS_TYPE.descriptor, null, null
     )
@@ -667,22 +665,3 @@ private fun generateLambdaForRunSuspend(
     lambdaBuilder.done()
     return lambdaBuilder.thisName
 }
-
-internal fun LabelNode.linkWithLabel(): LabelNode {
-    // Remember labelNode in label and vise versa.
-    // Before ASM 8 there was JB patch in MethodNode that makes such linking in constructor of LabelNode.
-    //
-    // protected LabelNode getLabelNode(final Label label) {
-    //    if (!(label.info instanceof LabelNode)) {
-    //      //label.info = new LabelNode(label); //[JB: needed for Coverage agent]
-    //      label.info = new LabelNode(); //ASM 8
-    //    }
-    //    return (LabelNode) label.info;
-    //  }
-    if (label.info == null) {
-        label.info = this
-    }
-    return this
-}
-
-fun linkedLabel(): Label = LabelNode().linkWithLabel().label

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.codegen.coroutines
 import com.intellij.util.ArrayUtil
 import org.jetbrains.kotlin.backend.common.CodegenUtil
 import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
-import org.jetbrains.kotlin.cfg.index
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
@@ -19,12 +18,10 @@ import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
@@ -43,6 +40,7 @@ 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
@@ -103,9 +101,9 @@ abstract class AbstractCoroutineCodegen(
         ValueParameterDescriptorImpl(
             this, null, index, Annotations.EMPTY, name,
             type,
-            declaresDefaultValue = false, isCrossinline = false,
-            isNoinline = false,
-            varargElementType = null, source = SourceElement.NO_SOURCE
+            false, false,
+            false,
+            null, SourceElement.NO_SOURCE
         )
 
     override fun generateConstructor(): Method {
@@ -156,7 +154,7 @@ abstract class AbstractCoroutineCodegen(
         return constructor
     }
 
-    protected abstract val passArityToSuperClass: Boolean
+    abstract protected val passArityToSuperClass: Boolean
 }
 
 class CoroutineCodegenForLambda private constructor(
@@ -186,23 +184,6 @@ 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,
@@ -248,10 +229,10 @@ class CoroutineCodegenForLambda private constructor(
 
     override fun generateClosureBody() {
         for (parameter in allFunctionParameters()) {
-            val fieldInfo = fieldsForParameters[parameter] ?: continue
+            val fieldInfo = parameter.getFieldInfoForCoroutineLambdaParameter()
             v.newField(
                 OtherOrigin(parameter),
-                Opcodes.ACC_PRIVATE + Opcodes.ACC_SYNTHETIC,
+                Opcodes.ACC_PRIVATE,
                 fieldInfo.fieldName,
                 fieldInfo.fieldType.descriptor, null, null
             )
@@ -260,10 +241,6 @@ class CoroutineCodegenForLambda private constructor(
         generateResumeImpl()
     }
 
-    private fun ParameterDescriptor.isUnused(): Boolean =
-        originalSuspendFunctionDescriptor is AnonymousFunctionDescriptor &&
-                bindingContext[BindingContext.SUSPEND_LAMBDA_PARAMETER_USED, originalSuspendFunctionDescriptor to index()] != true
-
     private val generateErasedCreate: Boolean = allFunctionParameters().size <= 1
 
     private val doNotGenerateInvokeBridge: Boolean = !originalSuspendFunctionDescriptor.isLocalSuspendFunctionNotSuspendLambda()
@@ -272,7 +249,7 @@ class CoroutineCodegenForLambda private constructor(
         super.generateBody()
 
         if (doNotGenerateInvokeBridge) {
-            v.serializationBindings.put(
+            v.serializationBindings.put<FunctionDescriptor, Method>(
                 METHOD_FOR_FUNCTION,
                 originalSuspendFunctionDescriptor,
                 typeMapper.mapAsmMethod(erasedInvokeFunction)
@@ -335,7 +312,7 @@ class CoroutineCodegenForLambda private constructor(
             newarray(AsmTypes.OBJECT_TYPE)
             // 0 - this
             // 1..22 - parameters
-            // 23 - first empty slot
+            // 23 - first empy slot
             val arraySlot = 23
             store(arraySlot, AsmTypes.OBJECT_TYPE)
             for ((varIndex, type) in parameterTypes.withVariableIndices()) {
@@ -420,44 +397,42 @@ class CoroutineCodegenForLambda private constructor(
             // Pass lambda parameters to 'invoke' call on newly constructed object
             var index = 1
             for (parameter in allFunctionParameters()) {
-                val fieldInfoForCoroutineLambdaParameter = fieldsForParameters[parameter]
-                if (fieldInfoForCoroutineLambdaParameter != null) {
-                    if (isBigArity) {
-                        load(cloneIndex, fieldInfoForCoroutineLambdaParameter.ownerType)
-                        load(1, AsmTypes.OBJECT_TYPE)
-                        iconst(index - 1)
-                        aload(AsmTypes.OBJECT_TYPE)
+                val fieldInfoForCoroutineLambdaParameter = parameter.getFieldInfoForCoroutineLambdaParameter()
+                if (isBigArity) {
+                    load(cloneIndex, fieldInfoForCoroutineLambdaParameter.ownerType)
+                    load(1, AsmTypes.OBJECT_TYPE)
+                    iconst(index - 1)
+                    aload(AsmTypes.OBJECT_TYPE)
+                    StackValue.coerce(
+                        AsmTypes.OBJECT_TYPE, builtIns.nullableAnyType,
+                        fieldInfoForCoroutineLambdaParameter.fieldType, fieldInfoForCoroutineLambdaParameter.fieldKotlinType,
+                        this
+                    )
+                    putfield(
+                        fieldInfoForCoroutineLambdaParameter.ownerInternalName,
+                        fieldInfoForCoroutineLambdaParameter.fieldName,
+                        fieldInfoForCoroutineLambdaParameter.fieldType.descriptor
+                    )
+                } else {
+                    if (generateErasedCreate) {
+                        load(index, AsmTypes.OBJECT_TYPE)
                         StackValue.coerce(
                             AsmTypes.OBJECT_TYPE, builtIns.nullableAnyType,
                             fieldInfoForCoroutineLambdaParameter.fieldType, fieldInfoForCoroutineLambdaParameter.fieldKotlinType,
                             this
                         )
-                        putfield(
-                            fieldInfoForCoroutineLambdaParameter.ownerInternalName,
-                            fieldInfoForCoroutineLambdaParameter.fieldName,
-                            fieldInfoForCoroutineLambdaParameter.fieldType.descriptor
-                        )
                     } else {
-                        if (generateErasedCreate) {
-                            load(index, AsmTypes.OBJECT_TYPE)
-                            StackValue.coerce(
-                                AsmTypes.OBJECT_TYPE, builtIns.nullableAnyType,
-                                fieldInfoForCoroutineLambdaParameter.fieldType, fieldInfoForCoroutineLambdaParameter.fieldKotlinType,
-                                this
-                            )
-                        } else {
-                            load(index, fieldInfoForCoroutineLambdaParameter.fieldType)
-                        }
-                        AsmUtil.genAssignInstanceFieldFromParam(
-                            fieldInfoForCoroutineLambdaParameter,
-                            index,
-                            this,
-                            cloneIndex,
-                            generateErasedCreate
-                        )
+                        load(index, fieldInfoForCoroutineLambdaParameter.fieldType)
                     }
+                    AsmUtil.genAssignInstanceFieldFromParam(
+                        fieldInfoForCoroutineLambdaParameter,
+                        index,
+                        this,
+                        cloneIndex,
+                        generateErasedCreate
+                    )
                 }
-                index += if (isBigArity || generateErasedCreate) 1 else state.typeMapper.mapType(parameter.type).size
+                index += if (isBigArity || generateErasedCreate) 1 else fieldInfoForCoroutineLambdaParameter.fieldType.size
             }
 
             load(cloneIndex, AsmTypes.OBJECT_TYPE)
@@ -467,22 +442,16 @@ class CoroutineCodegenForLambda private constructor(
 
     private fun ExpressionCodegen.initializeCoroutineParameters() {
         for (parameter in allFunctionParameters()) {
-            val fieldForParameter = fieldsForParameters[parameter] ?: continue
-            val fieldStackValue = StackValue.field(fieldForParameter, generateThisOrOuter(context.thisDescriptor, false))
+            val fieldStackValue =
+                StackValue.field(
+                    parameter.getFieldInfoForCoroutineLambdaParameter(), generateThisOrOuter(context.thisDescriptor, false)
+                )
 
-            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 mappedType = typeMapper.mapType(parameter.type)
+            fieldStackValue.put(mappedType, v)
 
-            val newIndex = myFrameMap.enter(parameter, originalType)
-            StackValue.coerce(normalizedType, originalType, v)
-            v.store(newIndex, originalType)
+            val newIndex = myFrameMap.enter(parameter, mappedType)
+            v.store(newIndex, mappedType)
 
             val name =
                 if (parameter is ReceiverParameterDescriptor)
@@ -491,24 +460,23 @@ class CoroutineCodegenForLambda private constructor(
                     (getNameForDestructuredParameterOrNull(parameter as ValueParameterDescriptor) ?: parameter.name.asString())
             val label = Label()
             v.mark(label)
-            v.visitLocalVariable(name, originalType.descriptor, null, label, endLabel, newIndex)
+            v.visitLocalVariable(name, mappedType.descriptor, null, label, endLabel, newIndex)
         }
 
-        initializeVariablesForDestructuredLambdaParameters(
-            this,
-            originalSuspendFunctionDescriptor.valueParameters.filter { !it.isUnused() },
-            endLabel
-        )
+        initializeVariablesForDestructuredLambdaParameters(this, originalSuspendFunctionDescriptor.valueParameters, endLabel)
     }
 
     private fun allFunctionParameters(): List<ParameterDescriptor> =
         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).normalize(),
+            typeMapper.mapType(type),
             type,
             name
         )
@@ -530,9 +498,7 @@ class CoroutineCodegenForLambda private constructor(
                         containingClassInternalName = v.thisName,
                         isForNamedFunction = false,
                         languageVersionSettings = languageVersionSettings,
-                        disableTailCallOptimizationForFunctionReturningUnit = false,
-                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS),
-                        initialVarsCountByType = varsCountByType
+                        disableTailCallOptimizationForFunctionReturningUnit = false
                     )
                     val maybeWithForInline = if (forInline)
                         SuspendForInlineCopyingMethodVisitor(stateMachineBuilder, access, name, desc, functionCodegen::newMethod)
@@ -761,9 +727,7 @@ class CoroutineCodegenForNamedFunction private constructor(
         writeKotlinMetadata(v, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, 0) { av ->
             val serializer = DescriptorSerializer.createForLambda(JvmSerializerExtension(v.serializationBindings, state))
             val functionProto =
-                serializer.functionProto(
-                    createFreeFakeLambdaDescriptor(suspendFunctionJvmView, state.typeApproximator)
-                )?.build() ?: return@writeKotlinMetadata
+                serializer.functionProto(createFreeFakeLambdaDescriptor(suspendFunctionJvmView))?.build() ?: return@writeKotlinMetadata
             AsmUtil.writeAnnotationData(av, serializer, functionProto)
         }
     }
@@ -776,11 +740,16 @@ class CoroutineCodegenForNamedFunction private constructor(
             declaration: KtFunction
         ): CoroutineCodegenForNamedFunction {
             val bindingContext = expressionCodegen.state.bindingContext
-            val closure = bindingContext[CLOSURE, bindingContext[CodegenBinding.CLASS_FOR_CALLABLE, originalSuspendDescriptor]]
-                .sure { "There must be a closure defined for $originalSuspendDescriptor" }
+            val closure =
+                bindingContext[
+                        CodegenBinding.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()
@@ -798,8 +767,10 @@ class CoroutineCodegenForNamedFunction private constructor(
     }
 }
 
+private const val COROUTINE_LAMBDA_PARAMETER_PREFIX = "p$"
+
 private object FailingFunctionGenerationStrategy : FunctionGenerationStrategy() {
-    override fun skipNotNullAssertionsForParameters(): Boolean {
+    override fun skipNotNullAssertionsForParameters(): kotlin.Boolean {
         error("This functions must not be called")
     }
 

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

@@ -5,13 +5,23 @@
 
 package org.jetbrains.kotlin.codegen.coroutines
 
-import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.backend.common.CodegenUtil
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.ClassBuilder
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.TransformationMethodVisitor
 import org.jetbrains.kotlin.codegen.inline.*
+import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
 import org.jetbrains.kotlin.codegen.optimization.common.*
 import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransformer
+import org.jetbrains.kotlin.codegen.optimization.fixStack.top
+import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
+import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.utils.sure
 import org.jetbrains.org.objectweb.asm.Label
@@ -20,7 +30,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 org.jetbrains.org.objectweb.asm.tree.analysis.*
 import kotlin.math.max
 
 private const val COROUTINES_DEBUG_METADATA_VERSION = 1
@@ -62,11 +72,7 @@ class CoroutineTransformerMethodVisitor(
     // May differ from containingClassInternalName in case of DefaultImpls
     private val internalNameForDispatchReceiver: String? = null,
     // 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,
-    // Parameters of suspend lambda are put to the same fields as spilled variables
-    private val initialVarsCountByType: Map<Type, Int> = emptyMap()
+    private val putContinuationParameterToLvt: Boolean = true
 ) : TransformationMethodVisitor(delegate, access, name, desc, signature, exceptions) {
 
     private val classBuilderForCoroutineState: ClassBuilder by lazy(obtainClassBuilderForCoroutineState)
@@ -86,14 +92,14 @@ class CoroutineTransformerMethodVisitor(
         )
 
         FixStackMethodTransformer().transform(containingClassInternalName, methodNode)
-        val suspensionPoints = collectSuspensionPoints(methodNode)
-        RedundantLocalsEliminationMethodTransformer(suspensionPoints)
-            .transform(containingClassInternalName, methodNode)
+        RedundantLocalsEliminationMethodTransformer(languageVersionSettings).transform(containingClassInternalName, methodNode)
         if (languageVersionSettings.isReleaseCoroutines()) {
             ChangeBoxingMethodTransformer.transform(containingClassInternalName, methodNode)
         }
         updateMaxStack(methodNode)
 
+        val suspensionPoints = collectSuspensionPoints(methodNode)
+
         checkForSuspensionPointInsideMonitor(methodNode, suspensionPoints)
 
         // First instruction in the method node may change in case of named function
@@ -108,7 +114,6 @@ class CoroutineTransformerMethodVisitor(
                 languageVersionSettings,
                 containingClassInternalName,
                 methodNode,
-                suspensionPoints,
                 disableTailCallOptimizationForFunctionReturningUnit
             )
             if (examiner.allSuspensionPointsAreTailCalls(suspensionPoints)) {
@@ -135,19 +140,15 @@ class CoroutineTransformerMethodVisitor(
 
         UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
 
-        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
-
         val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)
 
         val suspendMarkerVarIndex = methodNode.maxLocals++
 
         val suspensionPointLineNumbers = suspensionPoints.map { findSuspensionPointLineNumber(it) }
 
-        // 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]
-            )
+        val continuationLabels = suspensionPoints.withIndex().map {
+            transformCallAndReturnContinuationLabel(
+                it.index + 1, it.value, methodNode, suspendMarkerVarIndex, suspensionPointLineNumbers[it.index])
         }
 
         methodNode.instructions.apply {
@@ -170,7 +171,7 @@ class CoroutineTransformerMethodVisitor(
                         0,
                         suspensionPoints.size,
                         defaultLabel,
-                        firstStateLabel, *stateLabels.toTypedArray()
+                        firstStateLabel, *continuationLabels.toTypedArray()
                     ),
                     firstStateLabel
                 )
@@ -187,38 +188,25 @@ class CoroutineTransformerMethodVisitor(
             })
         }
 
-        initializeFakeInlinerVariables(methodNode, stateLabels)
-
         dropSuspensionMarkers(methodNode)
         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) {
@@ -331,10 +319,31 @@ 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<SpilledVariableAndField>>
+        spilledToLocalMapping: List<List<SpilledVariableDescriptor>>
     ) {
         val lines = suspensionPointLineNumbers.map { it?.line ?: -1 }
         val metadata = classBuilderForCoroutineState.newAnnotation(DEBUG_METADATA_ANNOTATION_ASM_TYPE.descriptor, true)
@@ -568,9 +577,11 @@ class CoroutineTransformerMethodVisitor(
             return false
         }
 
-        return methodNode.instructions.asSequence().filter {
-            isBeforeSuspendMarker(it)
-        }.mapNotNull { start ->
+        val starts = methodNode.instructions.asSequence().filter {
+            isBeforeSuspendMarker(it) &&
+                    cfg.getPredecessorsIndices(it).isNotEmpty() // Ignore unreachable start markers
+        }.toList()
+        return starts.mapNotNull { start ->
             val ends = mutableSetOf<AbstractInsnNode>()
             if (collectSuspensionPointEnds(start, mutableSetOf(), ends)) return@mapNotNull null
             // Ignore suspension points, if the suspension call begin is alive and suspension call end is dead
@@ -579,7 +590,7 @@ class CoroutineTransformerMethodVisitor(
             // this is an exit point for the corresponding coroutine.
             val end = ends.find { isAfterSuspendMarker(it) } ?: return@mapNotNull null
             SuspensionPoint(start.previous, end)
-        }.toList()
+        }
     }
 
     private fun dropSuspensionMarkers(methodNode: MethodNode) {
@@ -589,31 +600,16 @@ class CoroutineTransformerMethodVisitor(
         }
     }
 
-    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableAndField>> {
+    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableDescriptor>> {
         val instructions = methodNode.instructions
-        val frames =
-            if (useOldSpilledVarTypeAnalysis) performRefinedTypeAnalysis(methodNode, containingClassInternalName)
-            else performSpilledVariableFieldTypesAnalysis(methodNode, containingClassInternalName)
-
+        val frames = performRefinedTypeAnalysis(methodNode, containingClassInternalName)
         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)
-
-        // 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
+        val spilledToVariableMapping = arrayListOf<List<SpilledVariableDescriptor>>()
 
         for (suspension in suspensionPoints) {
             val suspensionCallBegin = suspension.suspensionCallBegin
@@ -640,8 +636,7 @@ class CoroutineTransformerMethodVisitor(
             // NB: it's also rather useful for sake of optimization
             val livenessFrame = livenessFrames[suspensionCallBegin.index()]
 
-            val referencesToSpill = arrayListOf<ReferenceToSpill>()
-            val primitivesToSpill = arrayListOf<PrimitiveToSpill>()
+            val spilledToVariable = arrayListOf<SpilledVariableDescriptor>()
 
             // 0 - this
             // 1 - parameter
@@ -649,181 +644,77 @@ class CoroutineTransformerMethodVisitor(
             // k - continuation
             // k + 1 - data
             // k + 2 - exception
-            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
+            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 != StrictBasicValue.UNINITIALIZED_VALUE && livenessFrame.isAlive(index))
+                    }
 
-                if (value == StrictBasicValue.NULL_VALUE) {
-                    referencesToSpill += slot to null
+            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)
+                            })
+                        }
+                    }
                     continue
                 }
 
-                val type = value.type!!
+                val type = basicValue.type
                 val normalizedType = type.normalize()
 
                 val indexBySort = varsCountByType[normalizedType]?.plus(1) ?: 0
                 varsCountByType[normalizedType] = indexBySort
 
                 val fieldName = normalizedType.fieldNameForVar(indexBySort)
-                if (normalizedType == AsmTypes.OBJECT_TYPE) {
-                    referencesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
-                } else {
-                    primitivesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
+                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)
+                        })
+                    }
                 }
             }
 
-            referencesToSpillBySuspensionPointIndex += referencesToSpill
-            primitivesToSpillBySuspensionPointIndex += primitivesToSpill
+            spilledToVariableMapping.add(spilledToVariable)
 
-            for ((type, index) in varsCountByType) {
-                maxVarsCountByType[type] = max(maxVarsCountByType[type] ?: 0, index)
+            varsCountByType.forEach {
+                maxVarsCountByType[it.key] = max(maxVarsCountByType[it.key] ?: 0, it.value)
             }
         }
 
-        // Calculate variables to cleanup
+        postponedActions.forEach(Function0<Unit>::invoke)
 
-        // 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) {
+        maxVarsCountByType.forEach { entry ->
             val (type, maxIndex) = entry
-            for (index in (initialVarsCountByType[type]?.plus(1) ?: 0)..maxIndex) {
+            for (index in 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
     }
 
@@ -845,21 +736,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 transformCallAndReturnStateLabel(
+    private fun transformCallAndReturnContinuationLabel(
         id: Int,
         suspension: SuspensionPoint,
         methodNode: MethodNode,
         suspendMarkerVarIndex: Int,
         suspendPointLineNumber: LineNumberNode?
     ): LabelNode {
-        val stateLabel = LabelNode().linkWithLabel()
+        val continuationLabel = LabelNode()
         val continuationLabelAfterLoadedResult = LabelNode()
         val suspendElementLineNumber = lineNumber
         var nextLineNumberNode = nextDefinitelyHitLineNumber(suspension)
@@ -887,7 +778,7 @@ class CoroutineTransformerMethodVisitor(
                 load(suspendMarkerVarIndex, AsmTypes.OBJECT_TYPE)
                 areturn(AsmTypes.OBJECT_TYPE)
                 // Mark place for continuation
-                visitLabel(stateLabel.label)
+                visitLabel(continuationLabel.label)
             })
 
             // After suspension point there is always three nodes: L1, NOP, L2
@@ -938,7 +829,7 @@ class CoroutineTransformerMethodVisitor(
             }
         }
 
-        return stateLabel
+        return continuationLabel
     }
 
     // Find the next line number instruction that is defintely hit. That is, a line number
@@ -946,11 +837,9 @@ class CoroutineTransformerMethodVisitor(
     private fun nextDefinitelyHitLineNumber(suspension: SuspensionPoint): LineNumberNode? {
         var next = suspension.suspensionCallEnd.next
         while (next != null) {
-            when {
-                next.isBranchOrCall -> return null
-                next is LineNumberNode -> return next
-                else -> next = next.next
-            }
+            if (next.isBranchOrCall) return null
+            else if (next is LineNumberNode) return next
+            else next = next.next
         }
         return next
     }
@@ -1006,18 +895,199 @@ class CoroutineTransformerMethodVisitor(
         return
     }
 
-    private data class SpilledVariableAndField(val fieldName: String, val variableName: String)
+    private data class SpilledVariableDescriptor(val fieldName: String, val variableName: String)
 }
 
-private class SpillableVariable(
-    val value: BasicValue,
-    val type: Type,
-    val normalizedType: Type,
-    val fieldName: String
-)
+// TODO Use this in variable liveness analysis
+private class MethodNodeExaminer(
+    val languageVersionSettings: LanguageVersionSettings,
+    val containingClassInternalName: String,
+    val methodNode: MethodNode,
+    disableTailCallOptimizationForFunctionReturningUnit: Boolean
+) {
+    private val sourceFrames: Array<Frame<SourceValue>?> =
+        MethodTransformer.analyze(containingClassInternalName, methodNode, IgnoringCopyOperationSourceInterpreter())
+    private val controlFlowGraph = ControlFlowGraph.build(methodNode)
 
-private typealias ReferenceToSpill = Pair<Int, SpillableVariable?>
-private typealias PrimitiveToSpill = Pair<Int, SpillableVariable>
+    private val safeUnitInstances = mutableSetOf<AbstractInsnNode>()
+    private val popsBeforeSafeUnitInstances = mutableSetOf<AbstractInsnNode>()
+    private val areturnsAfterSafeUnitInstances = mutableSetOf<AbstractInsnNode>()
+    private val meaningfulSuccessorsCache = hashMapOf<AbstractInsnNode, List<AbstractInsnNode>>()
+    private val meaningfulPredecessorsCache = hashMapOf<AbstractInsnNode, List<AbstractInsnNode>>()
+
+    init {
+        if (!disableTailCallOptimizationForFunctionReturningUnit) {
+            // retrieve all POP insns
+            val pops = methodNode.instructions.asSequence().filter { it.opcode == Opcodes.POP }
+            // for each of them check that all successors are PUSH Unit
+            val popsBeforeUnitInstances = pops.map { it to it.meaningfulSuccessors() }
+                .filter { (_, succs) -> succs.all { it.isUnitInstance() } }
+                .map { it.first }.toList()
+            for (pop in popsBeforeUnitInstances) {
+                val units = pop.meaningfulSuccessors()
+                val allUnitsAreSafe = units.all { unit ->
+                    // check no other predecessor exists
+                    unit.meaningfulPredecessors().all { it in popsBeforeUnitInstances } &&
+                            // check they have only returns among successors
+                            unit.meaningfulSuccessors().all { it.opcode == Opcodes.ARETURN }
+                }
+                if (!allUnitsAreSafe) continue
+                // save them all to the properties
+                popsBeforeSafeUnitInstances += pop
+                safeUnitInstances += units
+                units.flatMapTo(areturnsAfterSafeUnitInstances) { it.meaningfulSuccessors() }
+            }
+        }
+    }
+
+    private fun AbstractInsnNode.index() = methodNode.instructions.indexOf(this)
+
+    // GETSTATIC kotlin/Unit.INSTANCE is considered safe iff
+    // it is part of POP, PUSH Unit, ARETURN sequence.
+    private fun AbstractInsnNode.isSafeUnitInstance(): Boolean = this in safeUnitInstances
+
+    private fun AbstractInsnNode.isPopBeforeSafeUnitInstance(): Boolean = this in popsBeforeSafeUnitInstances
+    private fun AbstractInsnNode.isAreturnAfterSafeUnitInstance(): Boolean = this in areturnsAfterSafeUnitInstances
+
+    private fun AbstractInsnNode.meaningfulSuccessors(): List<AbstractInsnNode> = meaningfulSuccessorsCache.getOrPut(this) {
+        meaningfulSuccessorsOrPredecessors(true)
+    }
+
+    private fun AbstractInsnNode.meaningfulPredecessors(): List<AbstractInsnNode> = meaningfulPredecessorsCache.getOrPut(this) {
+        meaningfulSuccessorsOrPredecessors(false)
+    }
+
+    private fun AbstractInsnNode.meaningfulSuccessorsOrPredecessors(isSuccessors: Boolean): List<AbstractInsnNode> {
+        fun AbstractInsnNode.isMeaningful() = isMeaningful && opcode != Opcodes.NOP && opcode != Opcodes.GOTO && this !is LineNumberNode
+
+        fun AbstractInsnNode.getIndices() =
+            if (isSuccessors) controlFlowGraph.getSuccessorsIndices(this)
+            else controlFlowGraph.getPredecessorsIndices(this)
+
+        val visited = arrayListOf<AbstractInsnNode>()
+        fun dfs(insn: AbstractInsnNode) {
+            if (insn in visited) return
+            visited += insn
+            if (!insn.isMeaningful()) {
+                for (succIndex in insn.getIndices()) {
+                    dfs(methodNode.instructions[succIndex])
+                }
+            }
+        }
+
+        for (succIndex in getIndices()) {
+            dfs(methodNode.instructions[succIndex])
+        }
+        return visited.filter { it.isMeaningful() }
+    }
+
+    fun replacePopsBeforeSafeUnitInstancesWithCoroutineSuspendedChecks() {
+        val basicAnalyser = Analyzer(BasicInterpreter())
+        basicAnalyser.analyze(containingClassInternalName, methodNode)
+        val typedFrames = basicAnalyser.frames
+
+        val isReferenceMap = popsBeforeSafeUnitInstances
+            .map { it to (!isUnreachable(it.index(), sourceFrames) && typedFrames[it.index()]?.top()?.isReference == true) }
+            .toMap()
+
+        for (pop in popsBeforeSafeUnitInstances) {
+            if (isReferenceMap[pop] == true) {
+                val label = Label()
+                methodNode.instructions.insertBefore(pop, withInstructionAdapter {
+                    dup()
+                    loadCoroutineSuspendedMarker(languageVersionSettings)
+                    ifacmpne(label)
+                    areturn(AsmTypes.OBJECT_TYPE)
+                    mark(label)
+                })
+            }
+        }
+    }
+
+    fun allSuspensionPointsAreTailCalls(suspensionPoints: List<SuspensionPoint>): Boolean {
+        val safelyReachableReturns = findSafelyReachableReturns()
+
+        val instructions = methodNode.instructions
+        return suspensionPoints.all { suspensionPoint ->
+            val beginIndex = instructions.indexOf(suspensionPoint.suspensionCallBegin)
+            val endIndex = instructions.indexOf(suspensionPoint.suspensionCallEnd)
+
+            if (isUnreachable(endIndex, sourceFrames)) return@all true
+
+            val insideTryBlock = methodNode.tryCatchBlocks.any { block ->
+                val tryBlockStartIndex = instructions.indexOf(block.start)
+                val tryBlockEndIndex = instructions.indexOf(block.end)
+
+                beginIndex in tryBlockStartIndex..tryBlockEndIndex
+            }
+            if (insideTryBlock) return@all false
+
+            safelyReachableReturns[endIndex + 1]?.all { returnIndex ->
+                sourceFrames[returnIndex]?.top().sure {
+                    "There must be some value on stack to return"
+                }.insns.any { sourceInsn ->
+                    sourceInsn?.let(instructions::indexOf) in beginIndex..endIndex
+                }
+            } ?: false
+        }
+    }
+
+    /**
+     * Let's call an instruction safe if its execution is always invisible: stack modifications, branching, variable insns (invisible in debug)
+     *
+     * For some instruction `insn` define the result as following:
+     * - if there is a path leading to the non-safe instruction then result is `null`
+     * - Otherwise result contains all the reachable ARETURN indices
+     *
+     * @return indices of safely reachable returns for each instruction in the method node
+     */
+    private fun findSafelyReachableReturns(): Array<Set<Int>?> {
+        val insns = methodNode.instructions
+        val reachableReturnsIndices = Array<Set<Int>?>(insns.size()) init@{ index ->
+            val insn = insns[index]
+
+            if (insn.opcode == Opcodes.ARETURN && !insn.isAreturnAfterSafeUnitInstance()) {
+                if (isUnreachable(index, sourceFrames)) return@init null
+                return@init setOf(index)
+            }
+
+            // Since POP, PUSH Unit, ARETURN behaves like normal return in terms of tail-call optimization, set return index to POP
+            if (insn.isPopBeforeSafeUnitInstance()) {
+                return@init setOf(index)
+            }
+
+            if (!insn.isMeaningful || insn.opcode in SAFE_OPCODES || insn.isInvisibleInDebugVarInsn(methodNode) || isInlineMarker(insn)
+                || insn.isSafeUnitInstance() || insn.isAreturnAfterSafeUnitInstance()
+            ) {
+                setOf<Int>()
+            } else null
+        }
+
+        var changed: Boolean
+        do {
+            changed = false
+            for (index in 0 until insns.size()) {
+                if (insns[index].opcode == Opcodes.ARETURN) continue
+
+                @Suppress("RemoveExplicitTypeArguments")
+                val newResult =
+                    controlFlowGraph
+                        .getSuccessorsIndices(index).plus(index)
+                        .map(reachableReturnsIndices::get)
+                        .fold<Set<Int>?, Set<Int>?>(mutableSetOf<Int>()) { acc, successorsResult ->
+                            if (acc != null && successorsResult != null) acc + successorsResult else null
+                        }
+
+                if (newResult != reachableReturnsIndices[index]) {
+                    reachableReturnsIndices[index] = newResult
+                    changed = true
+                }
+            }
+        } while (changed)
+
+        return reachableReturnsIndices
+    }
+}
 
 internal fun InstructionAdapter.generateContinuationConstructorCall(
     objectTypeForState: Type?,
@@ -1084,7 +1154,7 @@ inline fun withInstructionAdapter(block: InstructionAdapter.() -> Unit): InsnLis
     return tmpMethodNode.instructions
 }
 
-internal fun Type.normalize() =
+private fun Type.normalize() =
     when (sort) {
         Type.ARRAY, Type.OBJECT -> AsmTypes.OBJECT_TYPE
         else -> this
@@ -1099,25 +1169,15 @@ internal fun Type.normalize() =
  * ICONST_1
  * INVOKESTATIC InlineMarker.mark()
  */
-internal class SuspensionPoint(
+private class SuspensionPoint(
     // ICONST_0
     val suspensionCallBegin: AbstractInsnNode,
     // INVOKESTATIC InlineMarker.mark()
     val suspensionCallEnd: AbstractInsnNode
 ) {
     lateinit var tryCatchBlocksContinuationLabel: LabelNode
-
-    operator fun contains(insn: AbstractInsnNode): Boolean {
-        for (i in InsnSequence(suspensionCallBegin, suspensionCallEnd.next)) {
-            if (i == insn) return true
-        }
-        return false
-    }
 }
 
-internal operator fun List<SuspensionPoint>.contains(insn: AbstractInsnNode): Boolean =
-    any { insn in it }
-
 internal fun getLastParameterIndex(desc: String, access: Int) =
     Type.getArgumentTypes(desc).dropLast(1).map { it.size }.sum() + (if (!isStatic(access)) 1 else 0)
 
@@ -1148,6 +1208,25 @@ private fun getAllParameterTypes(desc: String, hasDispatchReceiver: Boolean, thi
     listOfNotNull(if (!hasDispatchReceiver) null else Type.getObjectType(thisName)).toTypedArray() +
             Type.getArgumentTypes(desc)
 
+internal class IgnoringCopyOperationSourceInterpreter : SourceInterpreter(Opcodes.API_VERSION) {
+    override fun copyOperation(insn: AbstractInsnNode?, value: SourceValue?) = value
+}
+
+// Check whether this instruction is unreachable, i.e. there is no path leading to this instruction
+internal fun <T : Value> isUnreachable(index: Int, sourceFrames: Array<out Frame<out T>?>): Boolean =
+    sourceFrames.size <= index || sourceFrames[index] == null
+
+private fun AbstractInsnNode?.isInvisibleInDebugVarInsn(methodNode: MethodNode): Boolean {
+    val insns = methodNode.instructions
+    val index = insns.indexOf(this)
+    return (this is VarInsnNode && methodNode.localVariables.none {
+        it.index == `var` && index in it.start.let(insns::indexOf)..it.end.let(insns::indexOf)
+    })
+}
+
+private val SAFE_OPCODES =
+    ((Opcodes.DUP..Opcodes.DUP2_X2) + Opcodes.NOP + Opcodes.POP + Opcodes.POP2 + (Opcodes.IFEQ..Opcodes.GOTO)).toSet()
+
 internal fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, continuationIndex: Int) {
     val fakeContinuations = methodNode.instructions.asSequence().filter(::isFakeContinuationMarker).toList()
     for (fakeContinuation in fakeContinuations) {
@@ -1155,72 +1234,3 @@ 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
-                // No LINENUMBER in range -> no way to put a breakpoint -> do not bother adding a record
-                if (InsnSequence(startLabel, endLabel).none { it is LineNumberNode }) continue
-                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

@@ -1,147 +1,245 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.codegen.coroutines
 
 import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
-import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.ControlFlowGraph
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
+import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
 import org.jetbrains.kotlin.codegen.optimization.common.removeAll
-import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.utils.keysToMap
 import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.tree.LabelNode
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import java.util.*
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.SourceInterpreter
 
-/**
- * This pass removes unused Unit values. These typically occur as a result of inlining and could end up spilling
- * into the continuation object or break tail-call elimination.
- *
- * Concretely, we remove "GETSTATIC kotlin/Unit.INSTANCE" instructions if they are unused, or all uses are either
- * POP instructions, or ASTORE instructions to locals which are never read and are not named local variables.
- *
- * This pass does not touch [suspensionPoints], as later passes rely on the bytecode patterns around suspension points.
- */
-internal class RedundantLocalsEliminationMethodTransformer(private val suspensionPoints: List<SuspensionPoint>) : MethodTransformer() {
+// Inliner emits a lot of locals during inlining.
+// Remove all of them since these locals are
+//  1) going to be spilled into continuation object
+//  2) breaking tail-call elimination
+class RedundantLocalsEliminationMethodTransformer(private val languageVersionSettings: LanguageVersionSettings) : MethodTransformer() {
+    lateinit var internalClassName: String
     override fun transform(internalClassName: String, methodNode: MethodNode) {
-        val interpreter = UnitSourceInterpreter(methodNode.localVariables?.mapTo(mutableSetOf()) { it.index } ?: setOf())
-        val frames = interpreter.run(internalClassName, methodNode)
+        this.internalClassName = internalClassName
+        do {
+            var changed = false
+            changed = simpleRemove(methodNode) || changed
+            changed = removeWithReplacement(methodNode) || changed
+            changed = removeAloadCheckcastContinuationAstore(methodNode, languageVersionSettings) || changed
+        } while (changed)
+    }
 
-        // Mark all unused instructions for deletion (except for labels which may be used in debug information)
-        val toDelete = mutableSetOf<AbstractInsnNode>()
-        methodNode.instructions.asSequence().zip(frames.asSequence()).mapNotNullTo(toDelete) { (insn, frame) ->
-            insn.takeIf { frame == null && insn !is LabelNode }
+    // Replace
+    //  GETSTATIC kotlin/Unit.INSTANCE
+    //  ASTORE N
+    //  ...
+    //  ALOAD N
+    // with
+    //  ...
+    //  GETSTATIC kotlin/Unit.INSTANCE
+    // or
+    //  ACONST_NULL
+    //  ASTORE N
+    //  ...
+    //  ALOAD N
+    // with
+    //  ...
+    //  ACONST_NULL
+    // or
+    //  ALOAD K
+    //  ASTORE N
+    //  ...
+    //  ALOAD N
+    // with
+    //  ...
+    //  ALOAD K
+    //
+    // But do not remove several at a time, since the same local (for example, ALOAD 0) might be loaded and stored multiple times in
+    // sequence, like
+    //  ALOAD 0
+    //  ASTORE 1
+    //  ALOAD 1
+    //  ASTORE 2
+    //  ALOAD 3
+    // Here, it is unsafe to replace ALOAD 3 with ALOAD 1, and then already removed ALOAD 1 with ALOAD 0.
+    private fun removeWithReplacement(
+        methodNode: MethodNode
+    ): Boolean {
+        val cfg = ControlFlowGraph.build(methodNode)
+        val insns = findSafeAstorePredecessors(methodNode, cfg, ignoreLocalVariableTable = false) {
+            it.isUnitInstance() || it.opcode == Opcodes.ACONST_NULL || it.opcode == Opcodes.ALOAD
+        }
+        for ((pred, astore) in insns) {
+            val aload = findSingleLoadFromAstore(astore, cfg, methodNode) ?: continue
+
+            methodNode.instructions.removeAll(listOf(pred, astore))
+            methodNode.instructions.set(aload, pred.clone())
+            return true
+        }
+        return false
+    }
+
+    private fun findSingleLoadFromAstore(
+        astore: AbstractInsnNode,
+        cfg: ControlFlowGraph,
+        methodNode: MethodNode
+    ): AbstractInsnNode? {
+        val aload = methodNode.instructions.asSequence()
+            .singleOrNull { it.opcode == Opcodes.ALOAD && it.localIndex() == astore.localIndex() } ?: return null
+        val succ = findImmediateSuccessors(astore, cfg, methodNode).singleOrNull() ?: return null
+        return if (aload == succ) aload else null
+    }
+
+    private fun AbstractInsnNode.clone() = when (this) {
+        is FieldInsnNode -> FieldInsnNode(opcode, owner, name, desc)
+        is VarInsnNode -> VarInsnNode(opcode, `var`)
+        is InsnNode -> InsnNode(opcode)
+        is TypeInsnNode -> TypeInsnNode(opcode, desc)
+        else -> error("clone of $this is not implemented yet")
+    }
+
+    // Remove
+    //  ALOAD N
+    //  POP
+    // or
+    //  ACONST_NULL
+    //  POP
+    // or
+    //  GETSTATIC kotlin/Unit.INSTANCE
+    //  POP
+    private fun simpleRemove(methodNode: MethodNode): Boolean {
+        val insns =
+            findPopPredecessors(methodNode) { it.isUnitInstance() || it.opcode == Opcodes.ACONST_NULL || it.opcode == Opcodes.ALOAD }
+        for ((pred, pop) in insns) {
+            methodNode.instructions.insertBefore(pred, InsnNode(Opcodes.NOP))
+            methodNode.instructions.removeAll(listOf(pred, pop))
+        }
+        return insns.isNotEmpty()
+    }
+
+    private fun findPopPredecessors(
+        methodNode: MethodNode,
+        predicate: (AbstractInsnNode) -> Boolean
+    ): Map<AbstractInsnNode, AbstractInsnNode> {
+        val insns = methodNode.instructions.asSequence().filter { predicate(it) }.toList()
+
+        val cfg = ControlFlowGraph.build(methodNode)
+
+        val res = hashMapOf<AbstractInsnNode, AbstractInsnNode>()
+        for (insn in insns) {
+            val succ = findImmediateSuccessors(insn, cfg, methodNode).singleOrNull() ?: continue
+            if (succ.opcode != Opcodes.POP) continue
+            if (insn.opcode == Opcodes.ALOAD && methodNode.localVariables.firstOrNull { it.index == insn.localIndex() } != null) continue
+            val sources = findSourceInstructions(internalClassName, methodNode, listOf(succ), ignoreCopy = false).values.flatten()
+            if (sources.size != 1) continue
+            res[insn] = succ
+        }
+        return res
+    }
+
+    // Replace
+    //  ALOAD K
+    //  CHECKCAST Continuation
+    //  ASTORE N
+    //  ...
+    //  ALOAD N
+    // with
+    //  ...
+    //  ALOAD K
+    //  CHECKCAST Continuation
+    private fun removeAloadCheckcastContinuationAstore(methodNode: MethodNode, languageVersionSettings: LanguageVersionSettings): Boolean {
+        // Here we ignore the duplicates of continuation in local variable table,
+        // Since it increases performance greatly.
+        val cfg = ControlFlowGraph.build(methodNode)
+        val insns = findSafeAstorePredecessors(methodNode, cfg, ignoreLocalVariableTable = true) {
+            it.opcode == Opcodes.CHECKCAST &&
+                    (it as TypeInsnNode).desc == languageVersionSettings.continuationAsmType().internalName &&
+                    it.previous?.opcode == Opcodes.ALOAD
         }
 
-        // Mark all spillable "GETSTATIC kotlin/Unit.INSTANCE" instructions for deletion
-        for ((unit, uses) in interpreter.unitUsageInformation) {
-            if (unit !in interpreter.unspillableUnitValues && unit !in suspensionPoints) {
-                toDelete += unit
-                toDelete += uses
+        var changed = false
+
+        for ((checkcast, astore) in insns) {
+            val aloadk = checkcast.previous
+            val aloadn = findSingleLoadFromAstore(astore, cfg, methodNode) ?: continue
+
+            methodNode.instructions.removeAll(listOf(aloadk, checkcast, astore))
+            methodNode.instructions.insertBefore(aloadn, aloadk.clone())
+            methodNode.instructions.set(aloadn, checkcast.clone())
+            changed = true
+        }
+        return changed
+    }
+
+    private fun findSafeAstorePredecessors(
+        methodNode: MethodNode,
+        cfg: ControlFlowGraph,
+        ignoreLocalVariableTable: Boolean,
+        predicate: (AbstractInsnNode) -> Boolean
+    ): Map<AbstractInsnNode, AbstractInsnNode> {
+        val insns = methodNode.instructions.asSequence().filter { predicate(it) }.toList()
+        val res = hashMapOf<AbstractInsnNode, AbstractInsnNode>()
+
+        for (insn in insns) {
+            val succ = findImmediateSuccessors(insn, cfg, methodNode).singleOrNull() ?: continue
+            if (succ.opcode != Opcodes.ASTORE) continue
+            if (methodNode.instructions.asSequence().count {
+                    it.opcode == Opcodes.ASTORE && it.localIndex() == succ.localIndex()
+                } != 1) continue
+            if (!ignoreLocalVariableTable && methodNode.localVariables.firstOrNull { it.index == succ.localIndex() } != null) continue
+            val sources = findSourceInstructions(internalClassName, methodNode, listOf(succ), ignoreCopy = false).values.flatten()
+            if (sources.size > 1) continue
+            res[insn] = succ
+        }
+
+        return res
+    }
+
+    // Find all meaningful successors of insn
+    private fun findImmediateSuccessors(
+        insn: AbstractInsnNode,
+        cfg: ControlFlowGraph,
+        methodNode: MethodNode
+    ): Collection<AbstractInsnNode> {
+        val visited = hashSetOf<AbstractInsnNode>()
+
+        fun dfs(current: AbstractInsnNode): Collection<AbstractInsnNode> {
+            if (!visited.add(current)) return emptySet()
+
+            return cfg.getSuccessorsIndices(current).flatMap {
+                val succ = methodNode.instructions[it]
+                if (!succ.isMeaningful || succ is JumpInsnNode || succ.opcode == Opcodes.NOP) dfs(succ)
+                else setOf(succ)
             }
         }
 
-        methodNode.instructions.removeAll(toDelete)
+        return dfs(insn)
+    }
+
+    private fun AbstractInsnNode.localIndex(): Int {
+        assert(this is VarInsnNode)
+        return (this as VarInsnNode).`var`
     }
 }
 
-// A version of SourceValue which inherits from BasicValue and is only used for Unit values.
-private class UnitValue(val insns: Set<AbstractInsnNode>) : BasicValue(AsmTypes.OBJECT_TYPE) {
-    constructor(insn: AbstractInsnNode) : this(Collections.singleton(insn))
-
-    override fun equals(other: Any?): Boolean = other is UnitValue && insns == other.insns
-    override fun hashCode() = Objects.hash(insns)
-    override fun toString() = "U"
-}
-
-// A specialized SourceInterpreter which only keeps track of the use sites for Unit values which are exclusively used as
-// arguments to POP and unused ASTORE instructions.
-private class UnitSourceInterpreter(private val localVariables: Set<Int>) : BasicInterpreter(Opcodes.API_VERSION) {
-    // All unit values with visible use-sites.
-    val unspillableUnitValues = mutableSetOf<AbstractInsnNode>()
-
-    // Map from unit values to ASTORE/POP use-sites.
-    val unitUsageInformation = mutableMapOf<AbstractInsnNode, MutableSet<AbstractInsnNode>>()
-
-    private fun markUnspillable(value: BasicValue?) =
-        value?.safeAs<UnitValue>()?.let { unspillableUnitValues += it.insns }
-
-    private fun collectUnitUsage(use: AbstractInsnNode, value: UnitValue) {
-        for (def in value.insns) {
-            if (def !in unspillableUnitValues) {
-                unitUsageInformation.getOrPut(def) { mutableSetOf() } += use
-            }
-        }
-    }
-
-    fun run(internalClassName: String, methodNode: MethodNode): Array<Frame<BasicValue>?> {
-        val frames = MethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
-        // The ASM analyzer does not visit POP instructions, so we do so here.
-        for ((insn, frame) in methodNode.instructions.asSequence().zip(frames.asSequence())) {
-            if (frame != null && insn.opcode == Opcodes.POP) {
-                val value = frame.top()
-                value.safeAs<UnitValue>()?.let { collectUnitUsage(insn, it) }
-            }
-        }
-        return frames
-    }
-
-    override fun newOperation(insn: AbstractInsnNode?): BasicValue =
-        if (insn?.isUnitInstance() == true) UnitValue(insn) else super.newOperation(insn)
-
-    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        if (value is UnitValue) {
-            if (insn is VarInsnNode && insn.opcode == Opcodes.ASTORE && insn.`var` !in localVariables) {
-                collectUnitUsage(insn, value)
-                // We track the stored value in case it is subsequently read.
-                return value
-            }
-            unspillableUnitValues += value.insns
-        }
-        return super.copyOperation(insn, value)
-    }
-
-    override fun unaryOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        markUnspillable(value)
-        return super.unaryOperation(insn, value)
-    }
-
-    override fun binaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?): BasicValue? {
-        markUnspillable(value1)
-        markUnspillable(value2)
-        return super.binaryOperation(insn, value1, value2)
-    }
-
-    override fun ternaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?, value3: BasicValue?): BasicValue? {
-        markUnspillable(value1)
-        markUnspillable(value2)
-        markUnspillable(value3)
-        return super.ternaryOperation(insn, value1, value2, value3)
-    }
-
-    override fun naryOperation(insn: AbstractInsnNode, values: List<BasicValue>?): BasicValue? {
-        values?.forEach(this::markUnspillable)
-        return super.naryOperation(insn, values)
-    }
-
-    override fun merge(value1: BasicValue?, value2: BasicValue?): BasicValue? =
-        if (value1 is UnitValue && value2 is UnitValue) {
-            UnitValue(value1.insns.union(value2.insns))
-        } 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.
-            markUnspillable(value1)
-            markUnspillable(value2)
-            super.merge(value1, value2)
-        }
+private fun findSourceInstructions(
+    internalClassName: String,
+    methodNode: MethodNode,
+    insns: Collection<AbstractInsnNode>,
+    ignoreCopy: Boolean
+): Map<AbstractInsnNode, Collection<AbstractInsnNode>> {
+    val frames = MethodTransformer.analyze(
+        internalClassName,
+        methodNode,
+        if (ignoreCopy) IgnoringCopyOperationSourceInterpreter() else SourceInterpreter()
+    )
+    return insns.keysToMap {
+        val index = methodNode.instructions.indexOf(it)
+        if (isUnreachable(index, frames)) return@keysToMap emptySet<AbstractInsnNode>()
+        frames[index].getStack(0).insns
+    }
 }

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

@@ -1,160 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.coroutines
-
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
-import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
-import org.jetbrains.org.objectweb.asm.Label
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-
-// BasicValue interpreter from ASM does not distinct 'int' types from other int-like types like 'byte' or 'boolean',
-// neither do HotSpot and JVM spec.
-// But it seems like Dalvik does not follow it, and spilling boolean value into an 'int' field fails with VerifyError on Android 4,
-// so this function calculates refined frames' markup.
-// Note that type of some values is only possible to determine by their usages (e.g. ICONST_1, BALOAD both may push boolean or byte on stack)
-// In this case, coerce the type of the value.
-
-internal class IloadedValue(val insns: Set<VarInsnNode>) : BasicValue(Type.INT_TYPE)
-
-private class IntLikeCoerceInterpreter : OptimizationBasicInterpreter() {
-    val needsToBeCoerced = mutableMapOf<VarInsnNode, Type>()
-
-    private fun coerce(value: IloadedValue, type: Type) {
-        for (insn in value.insns) {
-            needsToBeCoerced[insn] = type
-        }
-    }
-
-    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? =
-        when {
-            insn.opcode == Opcodes.ILOAD -> IloadedValue(setOf(insn as VarInsnNode))
-            value == null -> null
-            else -> BasicValue(value.type)
-        }
-
-    override fun binaryOperation(insn: AbstractInsnNode, v: BasicValue, w: BasicValue): BasicValue? {
-        if (insn.opcode == Opcodes.PUTFIELD) {
-            val expectedType = Type.getType((insn as FieldInsnNode).desc)
-            if (w is IloadedValue && expectedType.isIntLike()) {
-                coerce(w, expectedType)
-            }
-        }
-        return super.binaryOperation(insn, v, w)
-    }
-
-    override fun unaryOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        if (insn.opcode == Opcodes.PUTSTATIC) {
-            val expectedType = Type.getType((insn as FieldInsnNode).desc)
-            if (value is IloadedValue && expectedType.isIntLike()) {
-                coerce(value, expectedType)
-            }
-        }
-        return super.unaryOperation(insn, value)
-    }
-
-    override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out BasicValue?>): BasicValue? {
-        fun checkTypes(argTypes: Array<Type>, withReceiver: Boolean) {
-            val offset = if (withReceiver) 1 else 0
-            for ((index, argType) in argTypes.withIndex()) {
-                val value = values[index + offset] ?: continue
-                if (argType.isIntLike() && value is IloadedValue) {
-                    coerce(value, argType)
-                }
-            }
-        }
-        when (insn.opcode) {
-            Opcodes.INVOKEDYNAMIC -> {
-                checkTypes(Type.getArgumentTypes((insn as InvokeDynamicInsnNode).desc), false)
-            }
-            Opcodes.INVOKESTATIC -> {
-                checkTypes(Type.getArgumentTypes((insn as MethodInsnNode).desc), false)
-            }
-            Opcodes.INVOKEVIRTUAL, Opcodes.INVOKEINTERFACE, Opcodes.INVOKESPECIAL -> {
-                checkTypes(Type.getArgumentTypes((insn as MethodInsnNode).desc), true)
-            }
-        }
-        return super.naryOperation(insn, values)
-    }
-
-    override fun ternaryOperation(insn: AbstractInsnNode, arrayref: BasicValue?, index: BasicValue?, value: BasicValue?): BasicValue? {
-        when (insn.opcode) {
-            Opcodes.BASTORE -> {
-                if (value is IloadedValue) {
-                    val type = if (arrayref?.type?.descriptor == "[Z") Type.BOOLEAN_TYPE else Type.BYTE_TYPE
-                    coerce(value, type)
-                }
-            }
-            Opcodes.CASTORE -> {
-                if (value is IloadedValue) {
-                    coerce(value, Type.CHAR_TYPE)
-                }
-            }
-            Opcodes.SASTORE -> {
-                if (value is IloadedValue) {
-                    coerce(value, Type.SHORT_TYPE)
-                }
-            }
-        }
-        return super.ternaryOperation(insn, arrayref, index, value)
-    }
-
-    override fun merge(v: BasicValue, w: BasicValue): BasicValue =
-        when {
-            v is IloadedValue && w is IloadedValue && v.type == w.type -> {
-                val insns = v.insns + w.insns
-                insns.find { it in needsToBeCoerced }?.let {
-                    val type = needsToBeCoerced[it]!!
-                    coerce(v, type)
-                    coerce(w, type)
-                }
-                IloadedValue(insns)
-            }
-            v.type == w.type -> {
-                if (w is IloadedValue) w else v
-            }
-            else -> super.merge(v, w)
-        }
-}
-
-internal fun performSpilledVariableFieldTypesAnalysis(
-    methodNode: MethodNode,
-    thisName: String
-): Array<out Frame<BasicValue>?> {
-    val interpreter = IntLikeCoerceInterpreter()
-    MethodAnalyzer(thisName, methodNode, interpreter).analyze()
-    for ((insn, type) in interpreter.needsToBeCoerced) {
-        methodNode.instructions.insert(insn, withInstructionAdapter { coerceInt(type, this) })
-    }
-    return MethodAnalyzer(thisName, methodNode, OptimizationBasicInterpreter()).analyze()
-}
-
-private fun coerceInt(to: Type, v: InstructionAdapter) {
-    if (to == Type.BOOLEAN_TYPE) {
-        with(v) {
-            val zeroLabel = Label()
-            val resLabel = Label()
-            ifeq(zeroLabel)
-            iconst(1)
-            goTo(resLabel)
-            mark(zeroLabel)
-            iconst(0)
-            mark(resLabel)
-        }
-    } else {
-        StackValue.coerce(Type.INT_TYPE, to, v)
-    }
-}
-
-private fun Type.isIntLike(): Boolean = when (sort) {
-    Type.BOOLEAN, Type.BYTE, Type.CHAR, Type.SHORT -> true
-    else -> false
-}

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.codegen.inline.addFakeContinuationConstructorCallMar
 import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.inline.preprocessSuspendMarkers
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JVMConstructorCallNormalizationMode
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.languageVersionSettings
@@ -96,8 +95,7 @@ class SuspendFunctionGenerationStrategy(
             languageVersionSettings = languageVersionSettings,
             disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
                     originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&
-                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit(),
-            useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
+                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit()
         )
     }
 

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

@@ -1,256 +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.kotlin.codegen.inline.isInlineMarker
-import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
-import org.jetbrains.kotlin.codegen.optimization.common.ControlFlowGraph
-import org.jetbrains.kotlin.codegen.optimization.common.asSequence
-import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
-import org.jetbrains.kotlin.codegen.optimization.fixStack.top
-import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.kotlin.utils.sure
-import org.jetbrains.org.objectweb.asm.Label
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.tree.LineNumberNode
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
-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
-
-internal class MethodNodeExaminer(
-    val languageVersionSettings: LanguageVersionSettings,
-    containingClassInternalName: String,
-    val methodNode: MethodNode,
-    suspensionPoints: List<SuspensionPoint>,
-    disableTailCallOptimizationForFunctionReturningUnit: Boolean
-) {
-    private val frames: Array<Frame<BasicValue>?> =
-        MethodTransformer.analyze(containingClassInternalName, methodNode, TcoInterpreter(suspensionPoints))
-    private val controlFlowGraph = ControlFlowGraph.build(methodNode)
-
-    private val safeUnitInstances = mutableSetOf<AbstractInsnNode>()
-    private val popsBeforeSafeUnitInstances = mutableSetOf<AbstractInsnNode>()
-    private val areturnsAfterSafeUnitInstances = mutableSetOf<AbstractInsnNode>()
-    private val meaningfulSuccessorsCache = hashMapOf<AbstractInsnNode, List<AbstractInsnNode>>()
-    private val meaningfulPredecessorsCache = hashMapOf<AbstractInsnNode, List<AbstractInsnNode>>()
-
-    init {
-        if (!disableTailCallOptimizationForFunctionReturningUnit) {
-            // retrieve all POP insns
-            val pops = methodNode.instructions.asSequence().filter { it.opcode == Opcodes.POP }
-            // for each of them check that all successors are PUSH Unit
-            val popsBeforeUnitInstances = pops.map { it to it.meaningfulSuccessors() }
-                .filter { (_, succs) -> succs.all { it.isUnitInstance() } }
-                .map { it.first }.toList()
-            for (pop in popsBeforeUnitInstances) {
-                val units = pop.meaningfulSuccessors()
-                val allUnitsAreSafe = units.all { unit ->
-                    // check no other predecessor exists
-                    unit.meaningfulPredecessors().all { it in popsBeforeUnitInstances } &&
-                            // check they have only returns among successors
-                            unit.meaningfulSuccessors().all { it.opcode == Opcodes.ARETURN }
-                }
-                if (!allUnitsAreSafe) continue
-                // save them all to the properties
-                popsBeforeSafeUnitInstances += pop
-                safeUnitInstances += units
-                units.flatMapTo(areturnsAfterSafeUnitInstances) { it.meaningfulSuccessors() }
-            }
-        }
-    }
-
-    // GETSTATIC kotlin/Unit.INSTANCE is considered safe iff
-    // it is part of POP, PUSH Unit, ARETURN sequence.
-    private fun AbstractInsnNode.isSafeUnitInstance(): Boolean = this in safeUnitInstances
-
-    private fun AbstractInsnNode.isPopBeforeSafeUnitInstance(): Boolean = this in popsBeforeSafeUnitInstances
-    private fun AbstractInsnNode.isAreturnAfterSafeUnitInstance(): Boolean = this in areturnsAfterSafeUnitInstances
-
-    private fun AbstractInsnNode.meaningfulSuccessors(): List<AbstractInsnNode> = meaningfulSuccessorsCache.getOrPut(this) {
-        meaningfulSuccessorsOrPredecessors(true)
-    }
-
-    private fun AbstractInsnNode.meaningfulPredecessors(): List<AbstractInsnNode> = meaningfulPredecessorsCache.getOrPut(this) {
-        meaningfulSuccessorsOrPredecessors(false)
-    }
-
-    private fun AbstractInsnNode.meaningfulSuccessorsOrPredecessors(isSuccessors: Boolean): List<AbstractInsnNode> {
-        fun AbstractInsnNode.isMeaningful() = isMeaningful && opcode != Opcodes.NOP && opcode != Opcodes.GOTO && this !is LineNumberNode
-
-        fun AbstractInsnNode.getIndices() =
-            if (isSuccessors) controlFlowGraph.getSuccessorsIndices(this)
-            else controlFlowGraph.getPredecessorsIndices(this)
-
-        val visited = mutableSetOf<AbstractInsnNode>()
-        fun dfs(insn: AbstractInsnNode) {
-            if (insn in visited) return
-            visited += insn
-            if (!insn.isMeaningful()) {
-                for (succIndex in insn.getIndices()) {
-                    dfs(methodNode.instructions[succIndex])
-                }
-            }
-        }
-
-        for (succIndex in getIndices()) {
-            dfs(methodNode.instructions[succIndex])
-        }
-        return visited.filter { it.isMeaningful() }
-    }
-
-    fun replacePopsBeforeSafeUnitInstancesWithCoroutineSuspendedChecks() {
-        val isReferenceMap =
-            popsBeforeSafeUnitInstances.associateWith { (frames[methodNode.instructions.indexOf(it)]?.top()?.isReference == true) }
-
-        for (pop in popsBeforeSafeUnitInstances) {
-            if (isReferenceMap[pop] == true) {
-                val label = Label()
-                methodNode.instructions.insertBefore(pop, withInstructionAdapter {
-                    dup()
-                    loadCoroutineSuspendedMarker(languageVersionSettings)
-                    ifacmpne(label)
-                    areturn(AsmTypes.OBJECT_TYPE)
-                    mark(label)
-                })
-            }
-        }
-    }
-
-    fun allSuspensionPointsAreTailCalls(suspensionPoints: List<SuspensionPoint>): Boolean {
-        val safelyReachableReturns = findSafelyReachableReturns()
-
-        val instructions = methodNode.instructions
-        return suspensionPoints.all { suspensionPoint ->
-            val beginIndex = instructions.indexOf(suspensionPoint.suspensionCallBegin)
-            val endIndex = instructions.indexOf(suspensionPoint.suspensionCallEnd)
-
-            val insideTryBlock = methodNode.tryCatchBlocks.any { block ->
-                val tryBlockStartIndex = instructions.indexOf(block.start)
-                val tryBlockEndIndex = instructions.indexOf(block.end)
-
-                beginIndex in tryBlockStartIndex until tryBlockEndIndex
-            }
-            if (insideTryBlock) return@all false
-
-            safelyReachableReturns[endIndex + 1]?.all { returnIndex ->
-                frames[returnIndex]?.top().sure {
-                    "There must be some value on stack to return"
-                } is FromSuspensionPointValue
-            } ?: false
-        }
-    }
-
-    /**
-     * Let's call an instruction safe if its execution is always invisible: stack modifications, branching, variable insns (invisible in debug)
-     *
-     * For some instruction `insn` define the result as following:
-     * - if there is a path leading to the non-safe instruction then result is `null`
-     * - Otherwise result contains all the reachable ARETURN indices
-     *
-     * @return indices of safely reachable returns for each instruction in the method node
-     */
-    private fun findSafelyReachableReturns(): Array<Set<Int>?> {
-        val insns = methodNode.instructions
-        val reachableReturnsIndices = Array(insns.size()) init@{ index ->
-            val insn = insns[index]
-
-            if (insn.opcode == Opcodes.ARETURN && !insn.isAreturnAfterSafeUnitInstance()) {
-                return@init setOf(index)
-            }
-
-            // Since POP, PUSH Unit, ARETURN behaves like normal return in terms of tail-call optimization, set return index to POP
-            if (insn.isPopBeforeSafeUnitInstance()) {
-                return@init setOf(index)
-            }
-
-            if (!insn.isMeaningful || insn.opcode in SAFE_OPCODES || insn.isInvisibleInDebugVarInsn(methodNode) || isInlineMarker(insn)
-                || insn.isSafeUnitInstance() || insn.isAreturnAfterSafeUnitInstance()
-            ) {
-                setOf()
-            } else null
-        }
-
-        var changed: Boolean
-        do {
-            changed = false
-            for (index in 0 until insns.size()) {
-                if (insns[index].opcode == Opcodes.ARETURN) continue
-
-                @Suppress("RemoveExplicitTypeArguments")
-                val newResult =
-                    controlFlowGraph
-                        .getSuccessorsIndices(index).plus(index)
-                        .map(reachableReturnsIndices::get)
-                        .fold<Set<Int>?, Set<Int>?>(mutableSetOf<Int>()) { acc, successorsResult ->
-                            if (acc != null && successorsResult != null) acc + successorsResult else null
-                        }
-
-                if (newResult != reachableReturnsIndices[index]) {
-                    reachableReturnsIndices[index] = newResult
-                    changed = true
-                }
-            }
-        } while (changed)
-
-        return reachableReturnsIndices
-    }
-}
-
-private fun AbstractInsnNode?.isInvisibleInDebugVarInsn(methodNode: MethodNode): Boolean {
-    val insns = methodNode.instructions
-    val index = insns.indexOf(this)
-    return (this is VarInsnNode && methodNode.localVariables.none {
-        it.index == `var` && index in it.start.let(insns::indexOf)..it.end.let(insns::indexOf)
-    })
-}
-
-private val SAFE_OPCODES =
-    ((Opcodes.DUP..Opcodes.DUP2_X2) + Opcodes.NOP + Opcodes.POP + Opcodes.POP2 + (Opcodes.IFEQ..Opcodes.GOTO)).toSet()
-
-private object FromSuspensionPointValue : BasicValue(AsmTypes.OBJECT_TYPE) {
-    override fun equals(other: Any?): Boolean = other is FromSuspensionPointValue
-}
-
-private fun BasicValue?.toFromSuspensionPoint(): BasicValue? = if (this?.type?.sort == Type.OBJECT) FromSuspensionPointValue else this
-
-private class TcoInterpreter(private val suspensionPoints: List<SuspensionPoint>) : BasicInterpreter(Opcodes.API_VERSION) {
-    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        return super.copyOperation(insn, value).convert(insn)
-    }
-
-    private fun BasicValue?.convert(insn: AbstractInsnNode): BasicValue? = if (insn in suspensionPoints) toFromSuspensionPoint() else this
-
-    override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out BasicValue?>?): BasicValue? {
-        return super.naryOperation(insn, values).convert(insn)
-    }
-
-    override fun ternaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?, value3: BasicValue?): BasicValue? {
-        return super.ternaryOperation(insn, value1, value2, value3).convert(insn)
-    }
-
-    override fun merge(value1: BasicValue?, value2: BasicValue?): BasicValue {
-        return if (value1 is FromSuspensionPointValue || value2 is FromSuspensionPointValue) FromSuspensionPointValue
-        else super.merge(value1, value2)
-    }
-
-    override fun unaryOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        return super.unaryOperation(insn, value).convert(insn)
-    }
-
-    override fun binaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?): BasicValue? {
-        return super.binaryOperation(insn, value1, value2).convert(insn)
-    }
-
-    override fun newOperation(insn: AbstractInsnNode): BasicValue? {
-        return super.newOperation(insn).convert(insn)
-    }
-}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 

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

@@ -17,20 +17,22 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.*
+import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
+import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
-import org.jetbrains.kotlin.types.*
 import java.util.*
 
 /**
  * Given a function descriptor, creates another function descriptor with type parameters copied from outer context(s).
  * This is needed because once we're serializing this to a proto, there's no place to store information about external type parameters.
  */
-fun createFreeFakeLambdaDescriptor(descriptor: FunctionDescriptor, typeApproximator: TypeApproximator?): FunctionDescriptor {
-    return createFreeDescriptor(descriptor, typeApproximator)
+fun createFreeFakeLambdaDescriptor(descriptor: FunctionDescriptor): FunctionDescriptor {
+    return createFreeDescriptor(descriptor)
 }
 
-private fun <D : CallableMemberDescriptor> createFreeDescriptor(descriptor: D, typeApproximator: TypeApproximator?): D {
+private fun <D : CallableMemberDescriptor> createFreeDescriptor(descriptor: D): D {
     @Suppress("UNCHECKED_CAST")
     val builder = descriptor.newCopyBuilder() as CallableMemberDescriptor.CopyBuilder<D>
 
@@ -41,82 +43,14 @@ private fun <D : CallableMemberDescriptor> createFreeDescriptor(descriptor: D, t
     while (container != null) {
         if (container is ClassDescriptor) {
             typeParameters.addAll(container.declaredTypeParameters)
-        } else if (container is CallableDescriptor && container !is ConstructorDescriptor) {
+        }
+        else if (container is CallableDescriptor && container !is ConstructorDescriptor) {
             typeParameters.addAll(container.typeParameters)
         }
         container = container.containingDeclaration
     }
 
-    val approximated = typeApproximator?.approximate(descriptor, builder) ?: false
-
-    return if (typeParameters.isEmpty() && !approximated) descriptor else builder.build()!!
-}
-
-private fun TypeApproximator.approximate(descriptor: CallableMemberDescriptor, builder: CallableMemberDescriptor.CopyBuilder<*>): Boolean {
-    var approximated = false
-
-    val returnType = descriptor.returnType
-    if (returnType != null) {
-        // unwrap to avoid instances of DeferredType
-        val approximatedType = approximate(returnType.unwrap(), toSuper = true)
-        if (approximatedType != null) {
-            builder.setReturnType(approximatedType)
-            approximated = true
-        }
-    }
-
-    if (builder !is FunctionDescriptor.CopyBuilder<*>) return approximated
-
-    val extensionReceiverParameter = descriptor.extensionReceiverParameter
-    if (extensionReceiverParameter != null) {
-        val approximatedExtensionReceiver = approximate(extensionReceiverParameter.type.unwrap(), toSuper = false)
-        if (approximatedExtensionReceiver != null) {
-            builder.setExtensionReceiverParameter(
-                extensionReceiverParameter.substituteTopLevelType(approximatedExtensionReceiver)
-            )
-            approximated = true
-        }
-    }
-
-    var valueParameterApproximated = false
-    val newParameters = descriptor.valueParameters.map {
-        val approximatedType = approximate(it.type.unwrap(), toSuper = false)
-        if (approximatedType != null) {
-            valueParameterApproximated = true
-            // invoking constructor explicitly as substitution on value parameters is not supported
-            ValueParameterDescriptorImpl(
-                it.containingDeclaration, it.original, it.index, it.annotations,
-                it.name, outType = approximatedType, it.declaresDefaultValue(),
-                it.isCrossinline, it.isNoinline, it.varargElementType, it.source
-            )
-        } else {
-            it
-        }
-    }
-
-    if (valueParameterApproximated) {
-        builder.setValueParameters(newParameters)
-        approximated = true
-    }
-
-    return approximated
-}
-
-private fun ReceiverParameterDescriptor.substituteTopLevelType(newType: KotlinType): ReceiverParameterDescriptor? {
-    val wrappedSubstitution = object : TypeSubstitution() {
-        override fun get(key: KotlinType): TypeProjection? = null
-        override fun prepareTopLevelType(topLevelType: KotlinType, position: Variance): KotlinType = newType
-    }
-
-    return substitute(TypeSubstitutor.create(wrappedSubstitution))
-}
-
-private fun TypeApproximator.approximate(type: UnwrappedType, toSuper: Boolean): KotlinType? {
-    if (type.arguments.isEmpty() && type.constructor.isDenotable) return null
-    return if (toSuper)
-        approximateToSuperType(type, TypeApproximatorConfiguration.PublicDeclaration)
-    else
-        approximateToSubType(type, TypeApproximatorConfiguration.PublicDeclaration)
+    return if (typeParameters.isEmpty()) descriptor else builder.build()!!
 }
 
 /**
@@ -124,31 +58,26 @@ private fun TypeApproximator.approximate(type: UnwrappedType, toSuper: Boolean):
  * when using reflection on that local variable at runtime.
  * Only members used by [DescriptorSerializer.propertyProto] are implemented correctly in this property descriptor.
  */
-fun createFreeFakeLocalPropertyDescriptor(descriptor: LocalVariableDescriptor, typeApproximator: TypeApproximator?): PropertyDescriptor {
+fun createFreeFakeLocalPropertyDescriptor(descriptor: LocalVariableDescriptor): PropertyDescriptor {
     val property = PropertyDescriptorImpl.create(
-        descriptor.containingDeclaration, descriptor.annotations, Modality.FINAL, descriptor.visibility, descriptor.isVar,
-        descriptor.name, CallableMemberDescriptor.Kind.DECLARATION, descriptor.source, false, descriptor.isConst,
-        false, false, false, descriptor.isDelegated
-    )
-    property.setType(
-        descriptor.type, descriptor.typeParameters,
-        descriptor.dispatchReceiverParameter, descriptor.extensionReceiverParameter
+            descriptor.containingDeclaration, descriptor.annotations, Modality.FINAL, descriptor.visibility, descriptor.isVar,
+            descriptor.name, CallableMemberDescriptor.Kind.DECLARATION, descriptor.source, false, descriptor.isConst,
+            false, false, false, @Suppress("DEPRECATION") descriptor.isDelegated
     )
+    property.setType(descriptor.type, descriptor.typeParameters, descriptor.dispatchReceiverParameter, descriptor.extensionReceiverParameter)
 
     property.initialize(
-        descriptor.getter?.run {
-            PropertyGetterDescriptorImpl(property, annotations, modality, visibility, true, isExternal, isInline, kind, null, source)
-                .apply {
+            descriptor.getter?.run {
+                PropertyGetterDescriptorImpl(property, annotations, modality, visibility, true, isExternal, isInline, kind, null, source).apply {
                     initialize(this@run.returnType)
                 }
-        },
-        descriptor.setter?.run {
-            PropertySetterDescriptorImpl(property, annotations, modality, visibility, true, isExternal, isInline, kind, null, source)
-                .apply {
+            },
+            descriptor.setter?.run {
+                PropertySetterDescriptorImpl(property, annotations, modality, visibility, true, isExternal, isInline, kind, null, source).apply {
                     initialize(this@run.valueParameters.single())
                 }
-        }
+            }
     )
 
-    return createFreeDescriptor(property, typeApproximator)
+    return createFreeDescriptor(property)
 }

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

@@ -42,7 +42,8 @@ class AnonymousObjectTransformer(
     private val fieldNames = hashMapOf<String, MutableList<String>>()
 
     private var constructor: MethodNode? = null
-    private lateinit var sourceMap: SMAP
+    private var sourceInfo: String? = null
+    private var debugInfo: String? = null
     private lateinit var sourceMapper: SourceMapper
     private val languageVersionSettings = inliningContext.state.languageVersionSettings
 
@@ -55,8 +56,6 @@ class AnonymousObjectTransformer(
         val methodsToTransform = ArrayList<MethodNode>()
         val metadataReader = ReadKotlinClassHeaderAnnotationVisitor()
         lateinit var superClassName: String
-        var sourceInfo: String? = null
-        var debugInfo: String? = null
 
         createClassReader().accept(object : ClassVisitor(Opcodes.API_VERSION, classBuilder.visitor) {
             override fun visit(version: Int, access: Int, name: String, signature: String?, superName: String, interfaces: Array<String>) {
@@ -114,12 +113,22 @@ class AnonymousObjectTransformer(
             override fun visitEnd() {}
         }, ClassReader.SKIP_FRAMES)
 
-        // When regenerating objects in inline lambdas, keep the old SMAP and don't remap the line numbers to
-        // save time. The result is effectively the same anyway.
-        val debugInfoToParse = if (inliningContext.isInliningLambda) null else debugInfo
-        val (firstLine, lastLine) = (methodsToTransform + listOfNotNull(constructor)).lineNumberRange()
-        sourceMap = SMAPParser.parseOrCreateDefault(debugInfoToParse, sourceInfo, oldObjectType.internalName, firstLine, lastLine)
-        sourceMapper = SourceMapper(sourceMap.fileMappings.firstOrNull { it.name == sourceInfo }?.toSourceInfo())
+        if (!inliningContext.isInliningLambda) {
+            sourceMapper = if (debugInfo != null && !debugInfo!!.isEmpty()) {
+                SourceMapper.createFromSmap(SMAPParser.parse(debugInfo!!))
+            } else {
+                //seems we can't do any clever mapping cause we don't know any about original class name
+                IdenticalSourceMapper
+            }
+            if (sourceInfo != null && !GENERATE_SMAP) {
+                classBuilder.visitSource(sourceInfo!!, debugInfo)
+            }
+        } else {
+            if (sourceInfo != null) {
+                classBuilder.visitSource(sourceInfo!!, debugInfo)
+            }
+            sourceMapper = IdenticalSourceMapper
+        }
 
         val allCapturedParamBuilder = ParametersBuilder.newBuilder()
         val constructorParamBuilder = ParametersBuilder.newBuilder()
@@ -174,11 +183,7 @@ class AnonymousObjectTransformer(
             }
         }
 
-        if (GENERATE_SMAP && !inliningContext.isInliningLambda) {
-            classBuilder.visitSMAP(sourceMapper, !state.languageVersionSettings.supportsFeature(LanguageFeature.CorrectSourceMappingSyntax))
-        } else if (sourceInfo != null) {
-            classBuilder.visitSource(sourceInfo!!, debugInfo)
-        }
+        classBuilder.visitSMAP(sourceMapper, !state.languageVersionSettings.supportsFeature(LanguageFeature.CorrectSourceMappingSyntax))
 
         val visitor = classBuilder.visitor
         innerClassNodes.forEach { node ->
@@ -291,7 +296,7 @@ class AnonymousObjectTransformer(
             remapper,
             isSameModule,
             "Transformer for " + transformationInfo.oldClassName,
-            SourceMapCopier(sourceMapper, sourceMap),
+            sourceMapper,
             InlineCallSiteInfo(
                 transformationInfo.oldClassName,
                 sourceNode.name,

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineAdapter.java

@@ -30,14 +30,14 @@ import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.GENERATE_
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.getLoadStoreArgSize;
 
 public class InlineAdapter extends InstructionAdapter {
-    private final SourceMapCopier sourceMapper;
+    private final SourceMapper sourceMapper;
     private final List<CatchBlock> blocks = new ArrayList<>();
 
     private boolean isLambdaInlining = false;
     private int nextLocalIndex = 0;
     private int nextLocalIndexBeforeInline = -1;
 
-    public InlineAdapter(@NotNull MethodVisitor mv, int localsSize, @NotNull SourceMapCopier sourceMapper) {
+    public InlineAdapter(@NotNull MethodVisitor mv, int localsSize, @NotNull SourceMapper sourceMapper) {
         super(Opcodes.API_VERSION, mv);
         this.nextLocalIndex = localsSize;
         this.sourceMapper = sourceMapper;

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

@@ -15,11 +15,8 @@ import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicArrayConstructors
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.incremental.components.Position
-import org.jetbrains.kotlin.incremental.components.ScopeKind
-import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -28,7 +25,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.inline.isInlineOnly
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -75,7 +72,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
     var activeLambda: LambdaInfo? = null
         protected set
 
-    private val sourceMapper = sourceCompiler.lazySourceMapper
+    private val defaultSourceMapper = sourceCompiler.lazySourceMapper
 
     protected var delayedHiddenWriting: Function0<Unit>? = null
 
@@ -87,9 +84,12 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         isSameModule = sourceCompiler.isCallInsideSameModuleAsDeclared(functionDescriptor)
 
         if (functionDescriptor !is FictitiousArrayConstructor) {
+            val functionOrAccessorName = jvmSignature.asmMethod.name
             //track changes for property accessor and @JvmName inline functions/property accessors
-            if (jvmSignature.asmMethod.name != functionDescriptor.name.asString()) {
-                trackLookup(functionDescriptor)
+            if (functionOrAccessorName != functionDescriptor.name.asString()) {
+                val scope = getMemberScope(functionDescriptor)
+                //Fake lookup to track track changes for property accessors and @JvmName functions/property accessors
+                scope?.getContributedFunctions(Name.identifier(functionOrAccessorName), sourceCompiler.lookupLocation)
             }
         }
     }
@@ -208,6 +208,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
 
     protected fun inlineCall(nodeAndSmap: SMAPAndMethodNode, inlineDefaultLambda: Boolean, isCallOfFunctionInCorrespondingDefaultDispatch: Boolean): InlineResult {
         assert(delayedHiddenWriting == null) { "'putHiddenParamsIntoLocals' should be called after 'processAndPutHiddenParameters(true)'" }
+        if (!isCallOfFunctionInCorrespondingDefaultDispatch) defaultSourceMapper.callSiteMarker = CallSiteMarker(codegen.lastLineNumber)
         val node = nodeAndSmap.node
         if (inlineDefaultLambda) {
             for (lambda in extractDefaultLambdas(node)) {
@@ -229,13 +230,11 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
             sourceCompiler, sourceCompiler.inlineCallSiteInfo, reifiedTypeInliner, typeParameterMappings
         )
 
-        val sourceInfo = sourceMapper.sourceInfo!!
-        val callSite = SourcePosition(codegen.lastLineNumber, sourceInfo.sourceFileName!!, sourceInfo.pathOrCleanFQN)
         val inliner = MethodInliner(
             node, parameters, info, FieldRemapper(null, null, parameters), isSameModule,
             "Method inlining " + sourceCompiler.callElementText,
-            SourceMapCopier(sourceMapper, nodeAndSmap.classSMAP, callSite.takeIf { !isCallOfFunctionInCorrespondingDefaultDispatch }),
-            info.callSiteInfo, if (functionDescriptor.isInlineOnly()) InlineOnlySmapSkipper(codegen) else null,
+            NestedSourceMapper(defaultSourceMapper, nodeAndSmap.classSMAP), info.callSiteInfo,
+            if (functionDescriptor.isInlineOnly()) InlineOnlySmapSkipper(codegen) else null,
             !isInlinedToInlineFunInKotlinRuntime()
         ) //with captured
 
@@ -270,6 +269,9 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         if (shouldSpillStack) {
             addInlineMarker(codegen.v, false)
         }
+
+        if (!isCallOfFunctionInCorrespondingDefaultDispatch) defaultSourceMapper.callSiteMarker = null
+
         return result
     }
 
@@ -497,24 +499,19 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         return true
     }
 
-    private fun trackLookup(functionOrAccessor: FunctionDescriptor) {
-        val functionOrAccessorName = jvmSignature.asmMethod.name
-        val lookupTracker = state.configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: return
-        val location = sourceCompiler.lookupLocation.location ?: return
-        val position = if (lookupTracker.requiresPosition) location.position else Position.NO_POSITION
-        val classOrPackageFragment = functionOrAccessor.containingDeclaration
-        lookupTracker.record(
-            location.filePath,
-            position,
-            DescriptorUtils.getFqName(classOrPackageFragment).asString(),
-            ScopeKind.CLASSIFIER,
-            functionOrAccessorName
-        )
-    }
-
 
     companion object {
 
+        private fun getMemberScope(functionOrAccessor: FunctionDescriptor): MemberScope? {
+            val callableMemberDescriptor = JvmCodegenUtil.getDirectMember(functionOrAccessor)
+            val classOrPackageFragment = callableMemberDescriptor.containingDeclaration
+            return when (classOrPackageFragment) {
+                is ClassDescriptor -> classOrPackageFragment.unsubstitutedMemberScope
+                is PackageFragmentDescriptor -> classOrPackageFragment.getMemberScope()
+                else -> null
+            }
+        }
+
         internal fun createInlineMethodNode(
             functionDescriptor: FunctionDescriptor,
             methodOwner: Type,
@@ -619,7 +616,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
                     callableDescriptor.name.asString() == "arrayOf" -> IntrinsicArrayConstructors.generateArrayOfBody(asmMethod)
                     else -> throw UnsupportedOperationException("Not an array intrinsic: $callableDescriptor")
                 }
-                return SMAPAndMethodNode(body, SMAP(listOf()))
+                return SMAPAndMethodNode(body, SMAP(listOf(FileMapping.SKIP)))
             }
 
             assert(callableDescriptor is DescriptorWithContainerSource) { "Not a deserialized function or proper: $callableDescriptor" }
@@ -634,7 +631,8 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
                     ?: throw IllegalStateException("Couldn't find declaration file for $containerId")
             }
 
-            val methodNode = getMethodNodeInner(containerId, bytes, asmMethod, callableDescriptor) ?: return null
+            val methodNode =
+                getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, AsmUtil.asmTypeByClassId(containerId)) ?: return null
 
             // KLUDGE: Inline suspend function built with compiler version less than 1.1.4/1.2-M1 did not contain proper
             // before/after suspension point marks, so we detect those functions here and insert the corresponding marks
@@ -645,28 +643,6 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
             return methodNode
         }
 
-        private fun getMethodNodeInner(
-            containerId: ClassId,
-            bytes: ByteArray,
-            asmMethod: Method,
-            callableDescriptor: CallableMemberDescriptor
-        ): SMAPAndMethodNode? {
-            val classType = AsmUtil.asmTypeByClassId(containerId)
-            var methodNode = getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, classType)
-            if (methodNode == null && requiresFunctionNameManglingForReturnType(callableDescriptor)) {
-                val nameWithoutManglingSuffix = asmMethod.name.stripManglingSuffixOrNull()
-                if (nameWithoutManglingSuffix != null) {
-                    methodNode = getMethodNode(bytes, nameWithoutManglingSuffix, asmMethod.descriptor, classType)
-                }
-            }
-            return methodNode
-        }
-
-        private fun String.stripManglingSuffixOrNull(): String? {
-            val dashIndex = indexOf('-')
-            return if (dashIndex < 0) null else substring(0, dashIndex)
-        }
-
         private fun isBuiltInArrayIntrinsic(callableDescriptor: CallableMemberDescriptor): Boolean {
             if (callableDescriptor is FictitiousArrayConstructor) return true
             val name = callableDescriptor.name.asString()

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import org.jetbrains.kotlin.codegen.*
-import org.jetbrains.kotlin.codegen.linkWithLabel
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
@@ -16,7 +15,6 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 class InlineCodegenForDefaultBody(
@@ -29,7 +27,7 @@ class InlineCodegenForDefaultBody(
 ) : CallGenerator {
     private val sourceMapper: SourceMapper = codegen.parentCodegen.orCreateSourceMapper
 
-    private val methodStartLabel = linkedLabel()
+    private val methodStartLabel = Label()
 
     init {
         assert(InlineUtil.isInline(function)) {
@@ -44,7 +42,7 @@ class InlineCodegenForDefaultBody(
         val nodeAndSmap = InlineCodegen.createInlineMethodNode(
             function, methodOwner, jvmSignature, callDefault, null, codegen.typeSystem, state, sourceCompilerForInline
         )
-        val childSourceMapper = SourceMapCopier(sourceMapper, nodeAndSmap.classSMAP)
+        val childSourceMapper = NestedSourceMapper(sourceMapper, nodeAndSmap.classSMAP, sameFile = true)
 
         val node = nodeAndSmap.node
         val transformedMethod = MethodNode(

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java

@@ -33,7 +33,6 @@ import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.*;
 
-import static org.jetbrains.kotlin.codegen.CodegenUtilKt.linkedLabel;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.*;
 import static org.jetbrains.kotlin.codegen.inline.MethodInlinerUtilKt.getNextMeaningful;
 
@@ -199,7 +198,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
                 //Creating temp node for finally block copy with some additional instruction
                 MethodNode finallyBlockCopy = createEmptyMethodNode();
                 Label newFinallyStart = new Label();
-                Label insertedBlockEnd = linkedLabel();
+                Label insertedBlockEnd = new Label();
 
                 boolean generateAloadAstore = nonLocalReturnType != Type.VOID_TYPE && !finallyInfo.isEmpty();
                 if (generateAloadAstore) {

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

@@ -100,11 +100,6 @@ class PsiDefaultLambda(
     override fun mapAsmSignature(sourceCompiler: SourceCompilerForInline): Method {
         return sourceCompiler.state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor).asmMethod
     }
-
-    override fun findInvokeMethodDescriptor(): FunctionDescriptor =
-        parameterDescriptor.type.memberScope
-            .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
-            .single()
 }
 
 abstract class DefaultLambda(
@@ -155,10 +150,14 @@ abstract class DefaultLambda(
             }
         }, ClassReader.SKIP_CODE or ClassReader.SKIP_FRAMES or ClassReader.SKIP_DEBUG)
 
-        invokeMethodDescriptor = findInvokeMethodDescriptor().let {
-            //property reference generates erased 'get' method
-            if (isPropertyReference) it.original else it
-        }
+        invokeMethodDescriptor =
+            parameterDescriptor.type.memberScope
+                .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
+                .single()
+                .let {
+                    //property reference generates erased 'get' method
+                    if (isPropertyReference) it.original else it
+                }
 
         val descriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
         val constructor = getMethodNode(
@@ -207,8 +206,6 @@ abstract class DefaultLambda(
 
     protected abstract fun mapAsmSignature(sourceCompiler: SourceCompilerForInline): Method
 
-    protected abstract fun findInvokeMethodDescriptor(): FunctionDescriptor
-
     private companion object {
         val PROPERTY_REFERENCE_SUPER_CLASSES =
             listOf(

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

@@ -54,7 +54,7 @@ class MethodInliner(
     private val nodeRemapper: FieldRemapper,
     private val isSameModule: Boolean,
     private val errorPrefix: String,
-    private val sourceMapper: SourceMapCopier,
+    private val sourceMapper: SourceMapper,
     private val inlineCallSiteInfo: InlineCallSiteInfo,
     private val inlineOnlySmapSkipper: InlineOnlySmapSkipper?, //non null only for root
     private val shouldPreprocessApiVersionCalls: Boolean = false
@@ -102,7 +102,7 @@ class MethodInliner(
         }
 
         //substitute returns with "goto end" instruction to keep non local returns in lambdas
-        val end = linkedLabel()
+        val end = Label()
         val isTransformingAnonymousObject = nodeRemapper is RegeneratedLambdaFieldRemapper
         transformedNode = doInline(transformedNode)
         if (!isTransformingAnonymousObject) {
@@ -278,7 +278,7 @@ class MethodInliner(
                         visitInsn(Opcodes.NOP)
                     }
 
-                    inlineOnlySmapSkipper?.onInlineLambdaStart(remappingMethodAdapter, info, sourceMapper.parent)
+                    inlineOnlySmapSkipper?.onInlineLambdaStart(remappingMethodAdapter, info)
                     addInlineMarker(this, true)
                     val lambdaParameters = info.addAllParameters(nodeRemapper)
 
@@ -288,14 +288,20 @@ class MethodInliner(
                     )
 
                     setLambdaInlining(true)
+                    val lambdaSMAP = info.node.classSMAP
+
+                    val childSourceMapper =
+                        if (inliningContext.classRegeneration && !inliningContext.isInliningLambda)
+                            NestedSourceMapper(sourceMapper, lambdaSMAP)
+                        else
+                            NestedSourceMapper(sourceMapper.parent!!, lambdaSMAP, sameFile = info !is DefaultLambda)
 
-                    val callSite = sourceMapper.callSite.takeIf { info is DefaultLambda }
                     val inliner = MethodInliner(
                         info.node.node, lambdaParameters, inliningContext.subInlineLambda(info),
                         newCapturedRemapper,
                         if (info is DefaultLambda) isSameModule else true /*cause all nested objects in same module as lambda*/,
                         "Lambda inlining " + info.lambdaClassType.internalName,
-                        SourceMapCopier(sourceMapper.parent, info.node.classSMAP, callSite), inlineCallSiteInfo, null
+                        childSourceMapper, inlineCallSiteInfo, null
                     )
 
                     val varRemapper = LocalVarRemapper(lambdaParameters, valueParamShift)